* Wrap some comments to 80 cols
[oota-llvm.git] / include / llvm / CodeGen / MachineInstr.h
index f4f65da2fc3938da19e79fed75483fab144f4602..a9f1352b47b6079b2ef59e1c15ee04ae7bf7a39d 100644 (file)
@@ -1,7 +1,14 @@
-//===-- llvm/CodeGen/MachineInstr.h - MachineInstr class ---------*- C++ -*--=//
+//===-- llvm/CodeGen/MachineInstr.h - MachineInstr class --------*- C++ -*-===//
+// 
+//                     The LLVM Compiler Infrastructure
+//
+// This file was developed by the LLVM research group and is distributed under
+// the University of Illinois Open Source License. See LICENSE.TXT for details.
+// 
+//===----------------------------------------------------------------------===//
 //
 // This file contains the declaration of the MachineInstr class, which is the
-// basic representation for all target dependant machine instructions used by
+// basic representation for all target dependent machine instructions used by
 // the back end.
 //
 //===----------------------------------------------------------------------===//
 #ifndef LLVM_CODEGEN_MACHINEINSTR_H
 #define LLVM_CODEGEN_MACHINEINSTR_H
 
-#include "llvm/Target/MRegisterInfo.h"
-#include "Support/Annotation.h"
-#include "Support/NonCopyable.h"
-#include "Support/iterator"
+#include "llvm/ADT/iterator"
+#include <string>
+#include <vector>
+#include <cassert>
+
+namespace llvm {
+
 class Value;
 class Function;
 class MachineBasicBlock;
 class TargetMachine;
 class GlobalValue;
 
-typedef int MachineOpCode;
+template <typename T> class ilist_traits;
+template <typename T> class ilist;
 
-/// 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
-  };
-}
+typedef short MachineOpCode;
 
-//---------------------------------------------------------------------------
+//===----------------------------------------------------------------------===//
 // class MachineOperand 
 // 
 // Purpose:
@@ -68,9 +67,34 @@ namespace MOTy {
 //   - Ptr will also be of virtual register type MO_VirtualReg.
 //     Again, the field Value* value identifies the value.
 // 
-//---------------------------------------------------------------------------
+//===----------------------------------------------------------------------===//
 
 struct MachineOperand {
+private:
+  // Bit fields of the flags variable used for different operand properties
+  enum {
+    DEFFLAG     = 0x01,       // this is a def of the operand
+    USEFLAG     = 0x02,       // this is a use of the operand
+    HIFLAG32    = 0x04,       // operand is %hi32(value_or_immedVal)
+    LOFLAG32    = 0x08,       // operand is %lo32(value_or_immedVal)
+    HIFLAG64    = 0x10,       // operand is %hi64(value_or_immedVal)
+    LOFLAG64    = 0x20,       // operand is %lo64(value_or_immedVal)
+    PCRELATIVE  = 0x40,       // Operand is relative to PC, not a global address
+  };
+
+public:
+  // UseType - This enum describes how the machine operand is used by
+  // the instruction. 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.
+  //
+  enum UseType {
+    Use = USEFLAG,        /// only read
+    Def = DEFFLAG,        /// only written
+    UseAndDef = Use | Def /// read AND written
+  };
+
   enum MachineOperandType {
     MO_VirtualRegister,                // virtual register for *value
     MO_MachineRegister,                // pre-assigned machine register `regNum'
@@ -85,112 +109,95 @@ struct MachineOperand {
     MO_GlobalAddress,           // Address of a global value
   };
   
-private:
-  // Bit fields of the flags variable used for different operand properties
-  enum {
-    DEFONLYFLAG = 0x01,       // this is a def but not a use of the operand
-    DEFUSEFLAG  = 0x02,       // this is both a def and a use
-    HIFLAG32    = 0x04,       // operand is %hi32(value_or_immedVal)
-    LOFLAG32    = 0x08,       // operand is %lo32(value_or_immedVal)
-    HIFLAG64    = 0x10,       // operand is %hi64(value_or_immedVal)
-    LOFLAG64    = 0x20,       // operand is %lo64(value_or_immedVal)
-    PCRELATIVE  = 0x40,       // Operand is relative to PC, not a global address
-  
-    USEDEFMASK = 0x03,
-  };
-
 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.
+    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.
 
-    int64_t immedVal;          // Constant value for an explicit constant
+    int immedVal;              // Constant value for an explicit constant
 
     MachineBasicBlock *MBB;     // For MO_MachineBasicBlock type
     std::string *SymbolName;    // For MO_ExternalSymbol type
-  };
+  } contents;
 
   char flags;                   // see bit field definitions above
   MachineOperandType opType:8;  // Pack into 8 bits efficiently after flags.
   int regNum;                  // register number for an explicit register
                                 // will be set for a value after reg allocation
 private:
-  MachineOperand()
-    : immedVal(0),
-      flags(0),
-      opType(MO_VirtualRegister),
-      regNum(-1) {}
-
-  MachineOperand(int64_t ImmVal, MachineOperandType OpTy)
-    : immedVal(ImmVal),
-      flags(0),
-      opType(OpTy),
-      regNum(-1) {}
-
-  MachineOperand(int Reg, MachineOperandType OpTy, MOTy::UseType UseTy)
-    : immedVal(0),
-      opType(OpTy),
-      regNum(Reg) {
-    switch (UseTy) {
-    case MOTy::Use:       flags = 0; break;
-    case MOTy::Def:       flags = DEFONLYFLAG; break;
-    case MOTy::UseAndDef: flags = DEFUSEFLAG; break;
-    default: assert(0 && "Invalid value for UseTy!");
-    }
+  void zeroContents () { 
+    memset (&contents, 0, sizeof (contents));
   }
 
-  MachineOperand(Value *V, MachineOperandType OpTy, MOTy::UseType UseTy,
+  MachineOperand(int ImmVal = 0, MachineOperandType OpTy = MO_VirtualRegister)
+    : flags(0), opType(OpTy), regNum(-1) {
+    zeroContents ();
+    contents.immedVal = ImmVal;
+  }
+
+  MachineOperand(int Reg, MachineOperandType OpTy, UseType UseTy)
+    : flags(UseTy), opType(OpTy), regNum(Reg) {
+    zeroContents ();
+  }
+
+  MachineOperand(Value *V, MachineOperandType OpTy, UseType UseTy,
                 bool isPCRelative = false)
-    : value(V), opType(OpTy), regNum(-1) {
-    switch (UseTy) {
-    case MOTy::Use:       flags = 0; break;
-    case MOTy::Def:       flags = DEFONLYFLAG; break;
-    case MOTy::UseAndDef: flags = DEFUSEFLAG; break;
-    default: assert(0 && "Invalid value for UseTy!");
-    }
-    if (isPCRelative) flags |= PCRELATIVE;
+    : flags(UseTy | (isPCRelative?PCRELATIVE:0)), opType(OpTy), regNum(-1) {
+    zeroContents ();
+    contents.value = V;
   }
 
   MachineOperand(MachineBasicBlock *mbb)
-    : MBB(mbb), flags(0), opType(MO_MachineBasicBlock), regNum(-1) {}
+    : flags(0), opType(MO_MachineBasicBlock), regNum(-1) {
+    zeroContents ();
+    contents.MBB = mbb;
+  }
 
   MachineOperand(const std::string &SymName, bool isPCRelative)
-    : SymbolName(new std::string(SymName)), flags(isPCRelative ? PCRELATIVE :0),
-      opType(MO_ExternalSymbol), regNum(-1) {}
+    : flags(isPCRelative?PCRELATIVE:0), opType(MO_ExternalSymbol), regNum(-1) {
+    zeroContents ();
+    contents.SymbolName = new std::string (SymName);
+  }
 
 public:
-  MachineOperand(const MachineOperand &M) : immedVal(M.immedVal),
-                                           flags(M.flags),
-                                           opType(M.opType),
-                                           regNum(M.regNum) {
+  MachineOperand(const MachineOperand &M)
+    : flags(M.flags), opType(M.opType), regNum(M.regNum) {
+    zeroContents ();
+    contents = M.contents;
     if (isExternalSymbol())
-      SymbolName = new std::string(M.getSymbolName());
+      contents.SymbolName = new std::string(M.getSymbolName());
   }
 
   ~MachineOperand() {
     if (isExternalSymbol())
-      delete SymbolName;
+      delete contents.SymbolName;
   }
   
   const MachineOperand &operator=(const MachineOperand &MO) {
-    immedVal = MO.immedVal;
+    if (isExternalSymbol())             // if old operand had a symbol name,
+      delete contents.SymbolName;       // release old memory
+    contents = MO.contents;
     flags    = MO.flags;
     opType   = MO.opType;
     regNum   = MO.regNum;
     if (isExternalSymbol())
-      SymbolName = new std::string(MO.getSymbolName());
+      contents.SymbolName = new std::string(MO.getSymbolName());
     return *this;
   }
 
-  // Accessor methods.  Caller is responsible for checking the
-  // operand type before invoking the corresponding accessor.
-  // 
+  /// getType - Returns the MachineOperandType for this operand.
+  /// 
   MachineOperandType getType() const { return opType; }
 
+  /// getUseType - Returns the MachineOperandUseType of this operand.
+  ///
+  UseType getUseType() const { return UseType(flags & (USEFLAG|DEFFLAG)); }
+
   /// isPCRelative - This returns the value of the PCRELATIVE flag, which
   /// indicates whether this operand should be emitted as a PC relative value
   /// instead of a global address.  This is used for operands of the forms:
@@ -198,22 +205,18 @@ public:
   ///
   bool isPCRelative() const { return (flags & PCRELATIVE) != 0; }
 
-
-  // This is to finally stop caring whether we have a virtual or machine
-  // register -- an easier interface is to simply call both virtual and machine
-  // registers essentially the same, yet be able to distinguish when
-  // necessary. Thus the instruction selector can just add registers without
-  // abandon, and the register allocator won't be confused.
-  bool isVirtualRegister() const {
-    return (opType == MO_VirtualRegister || opType == MO_MachineRegister) 
-      && regNum >= MRegisterInfo::FirstVirtualRegister;
-  }
-  bool isPhysicalRegister() const {
-    return (opType == MO_VirtualRegister || opType == MO_MachineRegister) 
-      && (unsigned)regNum < MRegisterInfo::FirstVirtualRegister;
+  /// isRegister - Return true if this operand is a register operand.  The X86
+  /// backend currently can't decide whether to use MO_MR or MO_VR to represent
+  /// them, so we accept both.
+  ///
+  /// Note: The sparc backend should not use this method.
+  ///
+  bool isRegister() const {
+    return opType == MO_MachineRegister || opType == MO_VirtualRegister;
   }
-  bool isRegister() const { return isVirtualRegister() || isPhysicalRegister();}
-  bool isMachineRegister() const { return !isVirtualRegister(); }
+
+  /// Accessors that tell you what kind of MachineOperand you're looking at.
+  ///
   bool isMachineBasicBlock() const { return opType == MO_MachineBasicBlock; }
   bool isPCRelativeDisp() const { return opType == MO_PCRelativeDisp; }
   bool isImmediate() const {
@@ -224,80 +227,118 @@ public:
   bool isGlobalAddress() const { return opType == MO_GlobalAddress; }
   bool isExternalSymbol() const { return opType == MO_ExternalSymbol; }
 
-  Value* getVRegValue() const {
-    assert(opType == MO_VirtualRegister || opType == MO_CCRegister || 
-          isPCRelativeDisp());
-    return value;
-  }
+  /// getVRegValueOrNull - Get the Value* out of a MachineOperand if it
+  /// has one. This is deprecated and only used by the SPARC v9 backend.
+  ///
   Value* getVRegValueOrNull() const {
     return (opType == MO_VirtualRegister || opType == MO_CCRegister || 
-            isPCRelativeDisp()) ? value : NULL;
+            isPCRelativeDisp()) ? contents.value : NULL;
+  }
+
+  /// MachineOperand accessors that only work on certain types of
+  /// MachineOperand...
+  ///
+  Value* getVRegValue() const {
+    assert ((opType == MO_VirtualRegister || opType == MO_CCRegister
+             || isPCRelativeDisp()) && "Wrong MachineOperand accessor");
+    return contents.value;
   }
   int getMachineRegNum() const {
-    assert(opType == MO_MachineRegister);
+    assert(opType == MO_MachineRegister && "Wrong MachineOperand accessor");
     return regNum;
   }
-  int64_t getImmedValue() const { assert(isImmediate()); return immedVal; }
+  int getImmedValue() const {
+    assert(isImmediate() && "Wrong MachineOperand accessor");
+    return contents.immedVal;
+  }
   MachineBasicBlock *getMachineBasicBlock() const {
-    assert(isMachineBasicBlock() && "Can't get MBB in non-MBB operand!");
-    return MBB;
+    assert(isMachineBasicBlock() && "Wrong MachineOperand accessor");
+    return contents.MBB;
+  }
+  void setMachineBasicBlock(MachineBasicBlock *MBB) {
+    assert(isMachineBasicBlock() && "Wrong MachineOperand accessor");
+    contents.MBB = MBB;
+  }
+  int getFrameIndex() const {
+    assert(isFrameIndex() && "Wrong MachineOperand accessor");
+    return contents.immedVal;
   }
-  int getFrameIndex() const { assert(isFrameIndex()); return immedVal; }
   unsigned getConstantPoolIndex() const {
-    assert(isConstantPoolIndex());
-    return immedVal;
+    assert(isConstantPoolIndex() && "Wrong MachineOperand accessor");
+    return contents.immedVal;
   }
-
   GlobalValue *getGlobal() const {
-    assert(isGlobalAddress());
-    return (GlobalValue*)value;
+    assert(isGlobalAddress() && "Wrong MachineOperand accessor");
+    return (GlobalValue*)contents.value;
   }
-
   const std::string &getSymbolName() const {
-    assert(isExternalSymbol());
-    return *SymbolName;
+    assert(isExternalSymbol() && "Wrong MachineOperand accessor");
+    return *contents.SymbolName;
   }
 
-  bool          opIsUse         () const { return (flags & USEDEFMASK) == 0; }
-  bool         opIsDefOnly     () const { return flags & DEFONLYFLAG; }
-  bool         opIsDefAndUse   () const { return flags & DEFUSEFLAG; }
-  bool          opHiBits32      () const { return flags & HIFLAG32; }
-  bool          opLoBits32      () const { return flags & LOFLAG32; }
-  bool          opHiBits64      () const { return flags & HIFLAG64; }
-  bool          opLoBits64      () const { return flags & LOFLAG64; }
-
-  // used to check if a machine register has been allocated to this operand
+  /// MachineOperand methods for testing that work on any kind of
+  /// MachineOperand...
+  ///
+  bool            isUse           () const { return flags & USEFLAG; }
+  MachineOperand& setUse          ()       { flags |= USEFLAG; return *this; }
+  bool            isDef           () const { return flags & DEFFLAG; }
+  MachineOperand& setDef          ()       { flags |= DEFFLAG; return *this; }
+  bool            isHiBits32      () const { return flags & HIFLAG32; }
+  bool            isLoBits32      () const { return flags & LOFLAG32; }
+  bool            isHiBits64      () const { return flags & HIFLAG64; }
+  bool            isLoBits64      () const { return flags & LOFLAG64; }
+
+  /// hasAllocatedReg - Returns true iff a machine register has been
+  /// allocated to this operand.
+  ///
   bool hasAllocatedReg() const {
     return (regNum >= 0 &&
             (opType == MO_VirtualRegister || opType == MO_CCRegister || 
              opType == MO_MachineRegister));
   }
 
-  // used to get the reg number if when one is allocated
-  int getAllocatedRegNum() const {
-    assert(opType == MO_VirtualRegister || opType == MO_CCRegister || 
-          opType == MO_MachineRegister);
+  /// getReg - Returns the register number. It is a runtime error to call this
+  /// if a register is not allocated.
+  ///
+  unsigned getReg() const {
+    assert(hasAllocatedReg());
     return regNum;
   }
 
-  unsigned getReg() const {
-    assert(hasAllocatedReg() && "Cannot call MachineOperand::getReg()!");
-    return regNum;
-  }    
+  /// MachineOperand mutators...
+  ///
+  void setReg(unsigned Reg) {
+    // This method's comment used to say: 'TODO: get rid of this duplicate
+    // code.' It's not clear where the duplication is.
+    assert(hasAllocatedReg() && "This operand cannot have a register number!");
+    regNum = Reg;
+  }  
+
+  void setValueReg(Value *val) {
+    assert(getVRegValueOrNull() != 0 && "Original operand must of type Value*");
+    contents.value = val;
+  }
   
-  friend std::ostream& operator<<(std::ostream& os, const MachineOperand& mop);
+  void setImmedValue(int immVal) {
+    assert(isImmediate() && "Wrong MachineOperand mutator");
+    contents.immedVal = immVal;
+  }
 
-private:
+  friend std::ostream& operator<<(std::ostream& os, const MachineOperand& mop);
 
-  // Construction methods needed for fine-grain control.
-  // These must be accessed via coresponding methods in MachineInstr.
+  /// markHi32, markLo32, etc. - These methods are deprecated and only used by
+  /// the SPARC v9 back-end.
+  ///
   void markHi32()      { flags |= HIFLAG32; }
   void markLo32()      { flags |= LOFLAG32; }
   void markHi64()      { flags |= HIFLAG64; }
   void markLo64()      { flags |= LOFLAG64; }
   
-  // Replaces the Value with its corresponding physical register after
-  // register allocation is complete
+private:
+  /// setRegForValue - Replaces the Value with its corresponding physical
+  /// register after register allocation is complete. This is deprecated
+  /// and only used by the SPARC v9 back-end.
+  ///
   void setRegForValue(int reg) {
     assert(opType == MO_VirtualRegister || opType == MO_CCRegister || 
           opType == MO_MachineRegister);
@@ -308,7 +349,7 @@ private:
 };
 
 
-//---------------------------------------------------------------------------
+//===----------------------------------------------------------------------===//
 // class MachineInstr 
 // 
 // Purpose:
@@ -324,46 +365,54 @@ private:
 //  (2) "Implicit operands" are values implicitly used or defined by the
 //      machine instruction, such as arguments to a CALL, return value of
 //      a CALL (if any), and return value of a RETURN.
-//---------------------------------------------------------------------------
-
-class MachineInstr: public NonCopyable {      // Disable copy operations
+//===----------------------------------------------------------------------===//
 
-  MachineOpCode    opCode;              // the opcode
+class MachineInstr {
+  short Opcode;                         // the opcode
+  unsigned char numImplicitRefs;        // number of implicit operands
   std::vector<MachineOperand> operands; // the operands
-  unsigned numImplicitRefs;             // number of implicit operands
-
-  // regsUsed - all machine registers used for this instruction, including regs
-  // used to save values across the instruction.  This is a bitset of registers.
-  std::vector<bool> regsUsed;
+  MachineInstr* prev, *next;            // links for our intrusive list
+  MachineBasicBlock* parent;            // pointer to the owning basic block
 
   // OperandComplete - Return true if it's illegal to add a new operand
   bool OperandsComplete() const;
 
+  //Constructor used by clone() method
+  MachineInstr(const MachineInstr&);
+
+  void operator=(const MachineInstr&); // DO NOT IMPLEMENT
+
+  // Intrusive list support
+  //
+  friend class ilist_traits<MachineInstr>;
+
 public:
-  MachineInstr(MachineOpCode Opcode, unsigned numOperands);
+  MachineInstr(short Opcode, unsigned numOperands);
 
   /// MachineInstr ctor - This constructor only does a _reserve_ of the
   /// operands, not a resize for them.  It is expected that if you use this that
   /// you call add* methods below to fill up the operands, instead of the Set
   /// methods.  Eventually, the "resizing" ctors will be phased out.
   ///
-  MachineInstr(MachineOpCode Opcode, unsigned numOperands, bool XX, bool YY);
+  MachineInstr(short Opcode, unsigned numOperands, bool XX, bool YY);
 
   /// MachineInstr ctor - Work exactly the same as the ctor above, except that
   /// the MachineInstr is created and added to the end of the specified basic
   /// block.
   ///
-  MachineInstr(MachineBasicBlock *MBB, MachineOpCode Opcode, unsigned numOps);
+  MachineInstr(MachineBasicBlock *MBB, short Opcode, unsigned numOps);
   
+  ~MachineInstr();
 
-  // The opcode.
-  // 
-  const MachineOpCode getOpcode() const { return opCode; }
-  const MachineOpCode getOpCode() const { return opCode; }
+  const MachineBasicBlock* getParent() const { return parent; }
+  MachineBasicBlock* getParent() { return parent; }
 
-  //
-  // Access to explicit operands of the instruction
-  // 
+  /// getOpcode - Returns the opcode of this MachineInstr.
+  ///
+  const int getOpcode() const { return Opcode; }
+
+  /// Access to explicit operands of the instruction.
+  ///
   unsigned getNumOperands() const { return operands.size() - numImplicitRefs; }
   
   const MachineOperand& getOperand(unsigned i) const {
@@ -375,6 +424,18 @@ public:
     return operands[i];
   }
 
+  //
+  // Access to explicit or implicit operands of the instruction
+  // This returns the i'th entry in the operand vector.
+  // That represents the i'th explicit operand or the (i-N)'th implicit operand,
+  // depending on whether i < N or i >= N.
+  // 
+  const MachineOperand& getExplOrImplOperand(unsigned i) const {
+    assert(i < operands.size() && "getExplOrImplOperand() out of range!");
+    return (i < getNumOperands()? getOperand(i)
+                                : getImplicitOp(i - getNumOperands()));
+  }
+
   //
   // Access to implicit operands of the instruction
   // 
@@ -396,27 +457,24 @@ public:
     return getImplicitOp(i).getVRegValue();
   }
 
-  inline void addImplicitRef    (Value* V,
-                                 bool isDef=false,bool isDefAndUse=false);
-  inline void setImplicitRef    (unsigned i, Value* V,
-                                 bool isDef=false, bool isDefAndUse=false);
-
-  //
-  // Information about registers used in this instruction
-  // 
-  const std::vector<bool> &getRegsUsed() const { return regsUsed; }
-  
-  // insertUsedReg - Add a register to the Used registers set...
-  void insertUsedReg(unsigned Reg) {
-    if (Reg >= regsUsed.size())
-      regsUsed.resize(Reg+1);
-    regsUsed[Reg] = true;
+  void addImplicitRef(Value* V, bool isDef = false, bool isDefAndUse = false) {
+    ++numImplicitRefs;
+    addRegOperand(V, isDef, isDefAndUse);
+  }
+  void setImplicitRef(unsigned i, Value* V) {
+    assert(i < getNumImplicitRefs() && "setImplicitRef() out of range!");
+    SetMachineOperandVal(i + getNumOperands(),
+                         MachineOperand::MO_VirtualRegister, V);
   }
 
+  /// clone - Create a copy of 'this' instruction that is identical in
+  /// all ways except the the instruction has no parent, prev, or next.
+  MachineInstr* clone() const;
+
   //
   // Debugging support
   //
-  void print(std::ostream &OS, const TargetMachine &TM) const;
+  void print(std::ostream &OS, const TargetMachine *TM) const;
   void dump() const;
   friend std::ostream& operator<<(std::ostream& os, const MachineInstr& minstr);
 
@@ -440,19 +498,24 @@ public:
   void addRegOperand(Value *V, bool isDef, bool isDefAndUse=false) {
     assert(!OperandsComplete() &&
            "Trying to add an operand to a machine instr that is already done!");
-    operands.push_back(MachineOperand(V, MachineOperand::MO_VirtualRegister,
-             !isDef ? MOTy::Use : (isDefAndUse ? MOTy::UseAndDef : MOTy::Def)));
+    operands.push_back(
+      MachineOperand(V, MachineOperand::MO_VirtualRegister,
+                     !isDef ? MachineOperand::Use :
+                     (isDefAndUse ? MachineOperand::UseAndDef :
+                      MachineOperand::Def)));
   }
 
-  void addRegOperand(Value *V, MOTy::UseType UTy = MOTy::Use,
-                    bool isPCRelative = false) {
+  void addRegOperand(Value *V,
+                     MachineOperand::UseType UTy = MachineOperand::Use,
+                     bool isPCRelative = false) {
     assert(!OperandsComplete() &&
            "Trying to add an operand to a machine instr that is already done!");
     operands.push_back(MachineOperand(V, MachineOperand::MO_VirtualRegister,
                                       UTy, isPCRelative));
   }
 
-  void addCCRegOperand(Value *V, MOTy::UseType UTy = MOTy::Use) {
+  void addCCRegOperand(Value *V,
+                       MachineOperand::UseType UTy = MachineOperand::Use) {
     assert(!OperandsComplete() &&
            "Trying to add an operand to a machine instr that is already done!");
     operands.push_back(MachineOperand(V, MachineOperand::MO_CCRegister, UTy,
@@ -465,17 +528,19 @@ public:
   void addRegOperand(int reg, bool isDef) {
     assert(!OperandsComplete() &&
            "Trying to add an operand to a machine instr that is already done!");
-    operands.push_back(MachineOperand(reg, MachineOperand::MO_VirtualRegister,
-                                      isDef ? MOTy::Def : MOTy::Use));
+    operands.push_back(
+      MachineOperand(reg, MachineOperand::MO_VirtualRegister,
+                     isDef ? MachineOperand::Def : MachineOperand::Use));
   }
 
   /// addRegOperand - Add a symbolic virtual register reference...
   ///
-  void addRegOperand(int reg, MOTy::UseType UTy = MOTy::Use) {
+  void addRegOperand(int reg,
+                     MachineOperand::UseType UTy = MachineOperand::Use) {
     assert(!OperandsComplete() &&
            "Trying to add an operand to a machine instr that is already done!");
-    operands.push_back(MachineOperand(reg, MachineOperand::MO_VirtualRegister,
-                                      UTy));
+    operands.push_back(
+      MachineOperand(reg, MachineOperand::MO_VirtualRegister, UTy));
   }
 
   /// addPCDispOperand - Add a PC relative displacement operand to the MI
@@ -483,8 +548,8 @@ public:
   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,
-                                      MOTy::Use));
+    operands.push_back(
+      MachineOperand(V, MachineOperand::MO_PCRelativeDisp,MachineOperand::Use));
   }
 
   /// addMachineRegOperand - Add a virtual register operand to this MachineInstr
@@ -492,39 +557,39 @@ public:
   void addMachineRegOperand(int reg, bool isDef) {
     assert(!OperandsComplete() &&
            "Trying to add an operand to a machine instr that is already done!");
-    operands.push_back(MachineOperand(reg, MachineOperand::MO_MachineRegister,
-                                      isDef ? MOTy::Def : MOTy::Use));
-    insertUsedReg(reg);
+    operands.push_back(
+      MachineOperand(reg, MachineOperand::MO_MachineRegister,
+                     isDef ? MachineOperand::Def : MachineOperand::Use));
   }
 
   /// addMachineRegOperand - Add a virtual register operand to this MachineInstr
   ///
-  void addMachineRegOperand(int reg, MOTy::UseType UTy = MOTy::Use) {
+  void addMachineRegOperand(int reg,
+                            MachineOperand::UseType UTy = MachineOperand::Use) {
     assert(!OperandsComplete() &&
            "Trying to add an operand to a machine instr that is already done!");
-    operands.push_back(MachineOperand(reg, MachineOperand::MO_MachineRegister,
-                                      UTy));
-    insertUsedReg(reg);
+    operands.push_back(
+      MachineOperand(reg, MachineOperand::MO_MachineRegister, UTy));
   }
 
   /// addZeroExtImmOperand - Add a zero extended constant argument to the
   /// machine instruction.
   ///
-  void addZeroExtImmOperand(int64_t intValue) {
+  void addZeroExtImmOperand(int intValue) {
     assert(!OperandsComplete() &&
            "Trying to add an operand to a machine instr that is already done!");
-    operands.push_back(MachineOperand(intValue,
-                                      MachineOperand::MO_UnextendedImmed));
+    operands.push_back(
+      MachineOperand(intValue, MachineOperand::MO_UnextendedImmed));
   }
 
   /// addSignExtImmOperand - Add a zero extended constant argument to the
   /// machine instruction.
   ///
-  void addSignExtImmOperand(int64_t intValue) {
+  void addSignExtImmOperand(int intValue) {
     assert(!OperandsComplete() &&
            "Trying to add an operand to a machine instr that is already done!");
-    operands.push_back(MachineOperand(intValue,
-                                      MachineOperand::MO_SignExtendedImmed));
+    operands.push_back(
+      MachineOperand(intValue, MachineOperand::MO_SignExtendedImmed));
   }
 
   void addMachineBasicBlockOperand(MachineBasicBlock *MBB) {
@@ -553,9 +618,9 @@ public:
   void addGlobalAddressOperand(GlobalValue *GV, bool isPCRelative) {
     assert(!OperandsComplete() &&
            "Trying to add an operand to a machine instr that is already done!");
-    operands.push_back(MachineOperand((Value*)GV,
-                                     MachineOperand::MO_GlobalAddress,
-                                      MOTy::Use, isPCRelative));
+    operands.push_back(
+      MachineOperand((Value*)GV, MachineOperand::MO_GlobalAddress,
+                     MachineOperand::Use, isPCRelative));
   }
 
   /// addExternalSymbolOperand - Add an external symbol operand to this instr
@@ -573,11 +638,11 @@ public:
   /// simply replace() and then set new operands with Set.*Operand methods
   /// below.
   /// 
-  void replace(MachineOpCode Opcode, unsigned numOperands);
+  void replace(short Opcode, unsigned numOperands);
 
   /// setOpcode - Replace the opcode of the current instruction with a new one.
   ///
-  void setOpcode(unsigned Op) { opCode = Op; }
+  void setOpcode(unsigned Op) { Opcode = Op; }
 
   /// RemoveOperand - Erase an operand  from an instruction, leaving it with one
   /// fewer operand than it started with.
@@ -588,34 +653,27 @@ public:
 
   // Access to set the operands when building the machine instruction
   // 
-  void SetMachineOperandVal     (unsigned i,
-                                 MachineOperand::MachineOperandType operandType,
-                                 Value* V,
-                                 bool isDef=false,
-                                 bool isDefAndUse=false);
+  void SetMachineOperandVal(unsigned i,
+                            MachineOperand::MachineOperandType operandType,
+                            Value* V);
 
-  void SetMachineOperandConst   (unsigned i,
-                                 MachineOperand::MachineOperandType operandType,
-                                 int64_t intValue);
+  void SetMachineOperandConst(unsigned i,
+                              MachineOperand::MachineOperandType operandType,
+                              int intValue);
 
-  void SetMachineOperandReg     (unsigned i,
-                                 int regNum,
-                                 bool isDef=false);
+  void SetMachineOperandReg(unsigned i, int regNum);
 
 
   unsigned substituteValue(const Value* oldVal, Value* newVal,
-                           bool defsOnly = true);
-
-  void setOperandHi32(unsigned i) { operands[i].markHi32(); }
-  void setOperandLo32(unsigned i) { operands[i].markLo32(); }
-  void setOperandHi64(unsigned i) { operands[i].markHi64(); }
-  void setOperandLo64(unsigned i) { operands[i].markLo64(); }
-  
+                           bool defsOnly, bool notDefsAndUses,
+                           bool& someArgsWereIgnored);
   
-  // SetRegForOperand - Replaces the Value for the operand with its allocated
-  // physical register after register allocation is complete.
+  // SetRegForOperand -
+  // SetRegForImplicitRef -
+  // Mark an explicit or implicit operand with its allocated physical register.
   // 
   void SetRegForOperand(unsigned i, int regNum);
+  void SetRegForImplicitRef(unsigned i, int regNum);
 
   //
   // Iterator to enumerate machine operands.
@@ -649,9 +707,8 @@ public:
 
     inline VTy operator->() const { return operator*(); }
 
-    inline bool isUseOnly()   const { return MI->getOperand(i).opIsUse(); } 
-    inline bool isDefOnly()   const { return MI->getOperand(i).opIsDefOnly(); } 
-    inline bool isDefAndUse() const { return MI->getOperand(i).opIsDefAndUse();}
+    inline bool isUse()   const { return MI->getOperand(i).isUse(); } 
+    inline bool isDef()   const { return MI->getOperand(i).isDef(); } 
 
     inline _Self& operator++() { i++; skipToNextVal(); return *this; }
     inline _Self  operator++(int) { _Self tmp = *this; ++*this; return tmp; }
@@ -683,39 +740,13 @@ public:
   }
 };
 
-
-// Define here to enable inlining of the functions used.
-// 
-void MachineInstr::addImplicitRef(Value* V,
-                                  bool isDef,
-                                  bool isDefAndUse)
-{
-  ++numImplicitRefs;
-  addRegOperand(V, isDef, isDefAndUse);
-}
-
-void MachineInstr::setImplicitRef(unsigned i,
-                                  Value* V,
-                                  bool isDef,
-                                  bool isDefAndUse)
-{
-  assert(i < getNumImplicitRefs() && "setImplicitRef() out of range!");
-  SetMachineOperandVal(i + getNumOperands(),
-                       MachineOperand::MO_VirtualRegister,
-                       V, isDef, isDefAndUse);
-}
-
-
-//---------------------------------------------------------------------------
+//===----------------------------------------------------------------------===//
 // Debugging Support
-//---------------------------------------------------------------------------
 
-std::ostream& operator<<        (std::ostream& os,
-                                 const MachineInstr& minstr);
+std::ostream& operator<<(std::ostream &OS, const MachineInstr &MI);
+std::ostream& operator<<(std::ostream &OS, const MachineOperand &MO);
+void PrintMachineInstructions(const Function *F);
 
-std::ostream& operator<<        (std::ostream& os,
-                                 const MachineOperand& mop);
-                                        
-void PrintMachineInstructions   (const Function *F);
+} // End llvm namespace
 
 #endif