All callers of these methods actually wanted them to preserve the flags,

so get rid of the def/use parameters that were getting passed in.

**** This now changes the semantics of these methods to preserve the flags,
     not clobber them!


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@7602 91177308-0d34-0410-b5e6-96231b3b80d8

2 files changed, 9 insertions, 36 deletions

diff --git a/include/llvm/CodeGen/MachineInstr.h b/include/llvm/CodeGen/MachineInstr.h
index 117e4ad..47f244b 100644
--- a/include/llvm/CodeGen/MachineInstr.h
+++ b/include/llvm/CodeGen/MachineInstr.h
@@ -432,12 +432,10 @@ public:
     ++numImplicitRefs;
     addRegOperand(V, isDef, isDefAndUse);
   }
-  void setImplicitRef(unsigned i, Value* V, bool isDef=false,
-                      bool isDefAndUse=false) {
+  void setImplicitRef(unsigned i, Value* V) {
     assert(i < getNumImplicitRefs() && "setImplicitRef() out of range!");
     SetMachineOperandVal(i + getNumOperands(),
-                         MachineOperand::MO_VirtualRegister,
-                         V, isDef, isDefAndUse);
+                         MachineOperand::MO_VirtualRegister, V);
   }
 
   //
@@ -631,17 +629,13 @@ public:
   // 
   void SetMachineOperandVal     (unsigned i,
                                  MachineOperand::MachineOperandType operandType,
-                                 Value* V,
-                                 bool isDef=false,
-                                 bool isDefAndUse=false);
+                                 Value* V);
 
   void SetMachineOperandConst   (unsigned i,
                                  MachineOperand::MachineOperandType operandType,
                                  int64_t intValue);
 
-  void SetMachineOperandReg     (unsigned i,
-                                 int regNum,
-                                 bool isDef=false);
+  void SetMachineOperandReg(unsigned i, int regNum);
 
 
   unsigned substituteValue(const Value* oldVal, Value* newVal,
diff --git a/lib/CodeGen/MachineInstr.cpp b/lib/CodeGen/MachineInstr.cpp
index d51c807..904a412 100644
--- a/lib/CodeGen/MachineInstr.cpp
+++ b/lib/CodeGen/MachineInstr.cpp
@@ -80,24 +80,13 @@ void MachineInstr::replace(MachineOpCode Opcode, unsigned numOperands)
   operands.resize(numOperands, MachineOperand());
 }
 
-void
-MachineInstr::SetMachineOperandVal(unsigned i,
-                                   MachineOperand::MachineOperandType opType,
-                                   Value* V,
-                                   bool isdef,
-                                   bool isDefAndUse)
-{
+void MachineInstr::SetMachineOperandVal(unsigned i,
+                                        MachineOperand::MachineOperandType opTy,
+                                        Value* V) {
   assert(i < operands.size());          // may be explicit or implicit op
-  operands[i].opType = opType;
+  operands[i].opType = opTy;
   operands[i].value = V;
   operands[i].regNum = -1;
-
-  if (isDefAndUse)
-    operands[i].flags = MachineOperand::DEFUSEFLAG;
-  else if (isdef || TargetInstrDescriptors[opCode].resultPos == (int) i)
-    operands[i].flags = MachineOperand::DEFONLYFLAG;
-  else
-    operands[i].flags = 0;
 }
 
 void
@@ -116,22 +105,12 @@ MachineInstr::SetMachineOperandConst(unsigned i,
   operands[i].flags = 0;
 }
 
-void
-MachineInstr::SetMachineOperandReg(unsigned i,
-                                   int regNum,
-                                   bool isdef) {
+void MachineInstr::SetMachineOperandReg(unsigned i, int regNum) {
   assert(i < getNumOperands());          // must be explicit op
 
   operands[i].opType = MachineOperand::MO_MachineRegister;
   operands[i].value = NULL;
   operands[i].regNum = regNum;
-
-  if (isdef || TargetInstrDescriptors[opCode].resultPos == (int)i) {
-    assert(operands[i].flags == MachineOperand::DEFONLYFLAG &&
-           "Shouldn't be changing a register type once set!");
-    operands[i].flags = MachineOperand::DEFONLYFLAG;
-  }
-
   insertUsedReg(regNum);
 }