typedef int MachineOpCode;
+/// MOTy - MachineOperandType - This namespace contains an enum that describes
+/// how the machine operand is used by the instruction: is it read, defined, or
+/// both? Note that the MachineInstr/Operator class currently uses bool
+/// arguments to represent this information instead of an enum. Eventually this
+/// should change over to use this _easier to read_ representation instead.
+///
+namespace MOTy {
+ enum UseType {
+ Use, /// This machine operand is only read by the instruction
+ Def, /// This machine operand is only written by the instruction
+ UseAndDef /// This machine operand is read AND written
+ };
+}
+
//---------------------------------------------------------------------------
// class MachineOperand
//
flags(0),
regNum(-1) {}
- MachineOperand(int Reg, MachineOperandType OpTy, bool isDef = false)
+ MachineOperand(int Reg, MachineOperandType OpTy, MOTy::UseType UseTy)
: immedVal(0),
opType(OpTy),
- flags(isDef ? DEFFLAG : 0),
- regNum(Reg) {}
+ regNum(Reg) {
+ switch (UseTy) {
+ case MOTy::Use: flags = 0; break;
+ case MOTy::Def: flags = DEFFLAG; break;
+ case MOTy::UseAndDef: flags = DEFUSEFLAG; break;
+ default: assert(0 && "Invalid value for UseTy!");
+ }
+ }
- MachineOperand(Value *V, MachineOperandType OpTy,
- bool isDef = false, bool isDNU = false)
- : value(V),
- opType(OpTy),
- regNum(-1) {
- flags = (isDef ? DEFFLAG : 0) | (isDNU ? DEFUSEFLAG : 0);
+ MachineOperand(Value *V, MachineOperandType OpTy, MOTy::UseType UseTy)
+ : value(V), opType(OpTy), regNum(-1) {
+ switch (UseTy) {
+ case MOTy::Use: flags = 0; break;
+ case MOTy::Def: flags = DEFFLAG; break;
+ case MOTy::UseAndDef: flags = DEFUSEFLAG; break;
+ default: assert(0 && "Invalid value for UseTy!");
+ }
}
public:
assert(!OperandsComplete() &&
"Trying to add an operand to a machine instr that is already done!");
operands.push_back(MachineOperand(V, MachineOperand::MO_VirtualRegister,
- isDef, isDefAndUse));
+ !isDef ? MOTy::Use : (isDefAndUse ? MOTy::UseAndDef : MOTy::Def)));
+ }
+
+ void addRegOperand(Value *V, MOTy::UseType UTy = MOTy::Use) {
+ assert(!OperandsComplete() &&
+ "Trying to add an operand to a machine instr that is already done!");
+ operands.push_back(MachineOperand(V, MachineOperand::MO_VirtualRegister,
+ UTy));
}
/// addRegOperand - Add a symbolic virtual register reference...
assert(!OperandsComplete() &&
"Trying to add an operand to a machine instr that is already done!");
operands.push_back(MachineOperand(reg, MachineOperand::MO_VirtualRegister,
- isDef));
+ isDef ? MOTy::Def : MOTy::Use));
}
/// addPCDispOperand - Add a PC relative displacement operand to the MI
void addPCDispOperand(Value *V) {
assert(!OperandsComplete() &&
"Trying to add an operand to a machine instr that is already done!");
- operands.push_back(MachineOperand(V, MachineOperand::MO_PCRelativeDisp));
+ operands.push_back(MachineOperand(V, MachineOperand::MO_PCRelativeDisp,
+ MOTy::Use));
}
/// addMachineRegOperand - Add a virtual register operand to this MachineInstr
assert(!OperandsComplete() &&
"Trying to add an operand to a machine instr that is already done!");
operands.push_back(MachineOperand(reg, MachineOperand::MO_MachineRegister,
- isDef));
+ isDef ? MOTy::Def : MOTy::Use));
insertUsedReg(reg);
}
#include "llvm/CodeGen/MachineInstr.h"
-struct MachineInstrBuilder {
+struct MachineInstrBuilder {
MachineInstr *MI;
MachineInstrBuilder(MachineInstr *mi) : MI(mi) {}
/// addReg - Add a new virtual register operand...
///
- const MachineInstrBuilder &addReg(int RegNo, bool isDef = false) const {
- MI->addRegOperand(RegNo, isDef);
+ const MachineInstrBuilder &addReg(int RegNo,
+ MOTy::UseType Ty = MOTy::Use) const {
+ MI->addRegOperand(RegNo, Ty);
return *this;
}
/// addReg - Add an LLVM value that is to be used as a register...
///
- const MachineInstrBuilder &addReg(Value *V, bool isDef = false,
- bool isDNU = false) const {
- MI->addRegOperand(V, isDef, isDNU);
+ const MachineInstrBuilder &addReg(Value *V,
+ MOTy::UseType Ty = MOTy::Use) const {
+ MI->addRegOperand(V, Ty);
return *this;
}
/// addMReg - Add a machine register operand...
///
- const MachineInstrBuilder &addMReg(int Reg, bool isDef = false) const {
- MI->addMachineRegOperand(Reg, isDef);
+ const MachineInstrBuilder &addMReg(int Reg,
+ MOTy::UseType Ty = MOTy::Use) const {
+ MI->addMachineRegOperand(Reg, Ty);
return *this;
}
unsigned NumOperands, unsigned DestReg) {
return MachineInstrBuilder(new MachineInstr(BB, Opcode,
NumOperands+1)).addReg(DestReg,
- true);
+ MOTy::Def);
}
#endif