3 files changed, 15 insertions, 47 deletions

diff --git a/include/llvm/CodeGen/MachineInstr.h b/include/llvm/CodeGen/MachineInstr.h
index 1059b7c3d5..a0b8d1ad43 100644
--- a/include/llvm/CodeGen/MachineInstr.h
+++ b/include/llvm/CodeGen/MachineInstr.h
@@ -74,15 +74,8 @@ public:
 
 private:
   union {
-    Value*  value;      // BasicBlockVal for a label operand.
-                        // ConstantVal for a non-address immediate.
-                        // Virtual register for an SSA operand,
-                        //   including hidden operands required for
-                        //   the generated machine code.
-                        // LLVM global for MO_GlobalAddress.
-
+    GlobalValue *GV;    // LLVM global for MO_GlobalAddress.
     int64_t immedVal;   // Constant value for an explicit constant
-
     MachineBasicBlock *MBB;     // For MO_MachineBasicBlock type
     const char *SymbolName;     // For MO_ExternalSymbol type
   } contents;
@@ -90,36 +83,32 @@ private:
   char flags;                   // see bit field definitions above
   MachineOperandType opType:8;  // Pack into 8 bits efficiently after flags.
   union {
-    int regNum;                 // register number for an explicit register
-                                // will be set for a value after reg allocation
-
-    int offset;                 // Offset to address of global or external, only
-                                // valid for MO_GlobalAddress, MO_ExternalSym
-                                // and MO_ConstantPoolIndex
+    int regNum;     // register number for an explicit register
+    int offset;     // Offset to address of global or external, only
+                    // valid for MO_GlobalAddress, MO_ExternalSym
+                    // and MO_ConstantPoolIndex
   } extra;
 
-  void zeroContents () {
-    memset (&contents, 0, sizeof (contents));
-    memset (&extra, 0, sizeof (extra));
+  void zeroContents() {
+    contents.immedVal = 0;
+    extra.offset = 0;
   }
 
   MachineOperand(int64_t ImmVal, MachineOperandType OpTy, int Offset = 0)
     : flags(0), opType(OpTy) {
-    zeroContents ();
     contents.immedVal = ImmVal;
     extra.offset = Offset;
   }
 
   MachineOperand(int Reg, MachineOperandType OpTy, UseType UseTy)
     : flags(UseTy), opType(OpTy) {
-    zeroContents ();
+    zeroContents();
     extra.regNum = Reg;
   }
 
   MachineOperand(GlobalValue *V, int Offset = 0)
     : flags(MachineOperand::Use), opType(MachineOperand::MO_GlobalAddress) {
-    zeroContents ();
-    contents.value = (Value*)V;
+    contents.GV = V;
     extra.offset = Offset;
   }
 
@@ -206,7 +195,7 @@ public:
   }
   GlobalValue *getGlobal() const {
     assert(isGlobalAddress() && "Wrong MachineOperand accessor");
-    return (GlobalValue*)contents.value;
+    return contents.GV;
   }
   int getOffset() const {
     assert((isGlobalAddress() || isExternalSymbol() || isConstantPoolIndex()) &&
@@ -476,10 +465,6 @@ public:
 
   // Access to set the operands when building the machine instruction
   //
-  void SetMachineOperandVal(unsigned i,
-                            MachineOperand::MachineOperandType operandType,
-                            Value* V);
-
   void SetMachineOperandConst(unsigned i,
                               MachineOperand::MachineOperandType operandType,
                               int intValue);
diff --git a/include/llvm/CodeGen/MachineInstrBuilder.h b/include/llvm/CodeGen/MachineInstrBuilder.h
index c2944c0369..384cb70967 100644
--- a/include/llvm/CodeGen/MachineInstrBuilder.h
+++ b/include/llvm/CodeGen/MachineInstrBuilder.h
@@ -8,13 +8,7 @@
 //===----------------------------------------------------------------------===//
 //
 // This file exposes a function named BuildMI, which is useful for dramatically
-// simplifying how MachineInstr's are created.  Instead of using code like this:
-//
-//   M = new MachineInstr(X86::ADDrr8);
-//   M->SetMachineOperandVal(0, MachineOperand::MO_VirtualRegister, argVal1);
-//   M->SetMachineOperandVal(1, MachineOperand::MO_VirtualRegister, argVal2);
-//
-// we can now use code like this:
+// simplifying how MachineInstr's are created.  It allows use of code like this:
 //
 //   M = BuildMI(X86::ADDrr8, 2).addReg(argVal1).addReg(argVal2);
 //
diff --git a/lib/CodeGen/MachineInstr.cpp b/lib/CodeGen/MachineInstr.cpp
index e300993a10..dad1e1f2e7 100644
--- a/lib/CodeGen/MachineInstr.cpp
+++ b/lib/CodeGen/MachineInstr.cpp
@@ -107,33 +107,22 @@ bool MachineInstr::OperandsComplete() const {
   return false;
 }
 
-void MachineInstr::SetMachineOperandVal(unsigned i,
-                                        MachineOperand::MachineOperandType opTy,
-                                        Value* V) {
-  assert(i < operands.size());          // may be explicit or implicit op
-  operands[i].opType = opTy;
-  operands[i].contents.value = V;
-  operands[i].extra.regNum = -1;
-}
-
 void
 MachineInstr::SetMachineOperandConst(unsigned i,
                                      MachineOperand::MachineOperandType opTy,
                                      int intValue) {
-  assert(i < getNumOperands());          // must be explicit op
-
+  assert(i < getNumOperands());
   operands[i].opType = opTy;
-  operands[i].contents.value = NULL;
   operands[i].contents.immedVal = intValue;
   operands[i].extra.regNum = -1;
   operands[i].flags = 0;
 }
 
 void MachineInstr::SetMachineOperandReg(unsigned i, int regNum) {
-  assert(i < getNumOperands());          // must be explicit op
+  assert(i < getNumOperands());
 
   operands[i].opType = MachineOperand::MO_VirtualRegister;
-  operands[i].contents.value = NULL;
+  operands[i].contents.GV = NULL;
   operands[i].extra.regNum = regNum;
 }