X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FCodeGen%2FMachineOperand.h;h=e3cc814011722d1547cfaed10d0b96267fe5b2a6;hb=5b200d8a133a07af1f7802025bd5a58a1cdd544d;hp=d62c8f8b4749d2372bd32ac1cc1a58db2cb4f92b;hpb=f8e43be758c94e21634d1e9e7c22fd5d218f7423;p=oota-llvm.git

diff --git a/include/llvm/CodeGen/MachineOperand.h b/include/llvm/CodeGen/MachineOperand.h
index d62c8f8b474..e3cc8140117 100644
--- a/include/llvm/CodeGen/MachineOperand.h
+++ b/include/llvm/CodeGen/MachineOperand.h
@@ -15,7 +15,6 @@
 #define LLVM_CODEGEN_MACHINEOPERAND_H
 
 #include "llvm/Support/DataTypes.h"
-#include <vector>
 #include <cassert>
 #include <iosfwd>
 
@@ -27,6 +26,7 @@ class GlobalValue;
 class MachineInstr;
 class TargetMachine;
 class MachineRegisterInfo;
+class raw_ostream;
   
 /// MachineOperand class - Representation of each machine instruction operand.
 ///
@@ -68,6 +68,11 @@ private:
   /// This is only valid on definitions of registers.
   bool IsDead : 1;
 
+  /// IsEarlyClobber - True if this MO_Register 'def' operand is written to
+  /// by the MachineInstr before all input registers are read.  This is used to
+  /// model the GCC inline asm '&' constraint modifier.
+  bool IsEarlyClobber : 1;
+
   /// SubReg - Subregister number, only valid for MO_Register.  A value of 0
   /// indicates the MO_Register has no subReg.
   unsigned char SubReg;
@@ -79,7 +84,7 @@ private:
   /// Contents union - This contains the payload for the various operand types.
   union {
     MachineBasicBlock *MBB;   // For MO_MachineBasicBlock.
-    ConstantFP *CFP;          // For MO_FPImmediate.
+    const ConstantFP *CFP;    // For MO_FPImmediate.
     int64_t ImmVal;           // For MO_Immediate.
 
     struct {                  // For MO_Register.
@@ -96,7 +101,7 @@ private:
         const char *SymbolName;   // For MO_ExternalSymbol.
         GlobalValue *GV;          // For MO_GlobalAddress.
       } Val;
-      int Offset;   // An offset from the object.
+      int64_t Offset;   // An offset from the object.
     } OffsetedInfo;
   } Contents;
   
@@ -118,72 +123,80 @@ public:
   const MachineInstr *getParent() const { return ParentMI; }
   
   void print(std::ostream &os, const TargetMachine *TM = 0) const;
+  void print(raw_ostream &os, const TargetMachine *TM = 0) const;
 
-  /// Accessors that tell you what kind of MachineOperand you're looking at.
-  ///
-  bool isRegister() const { return OpKind == MO_Register; }
-  bool isImmediate() const { return OpKind == MO_Immediate; }
-  bool isFPImmediate() const { return OpKind == MO_FPImmediate; }
-  bool isMachineBasicBlock() const { return OpKind == MO_MachineBasicBlock; }
-  bool isFrameIndex() const { return OpKind == MO_FrameIndex; }
-  bool isConstantPoolIndex() const { return OpKind == MO_ConstantPoolIndex; }
-  bool isJumpTableIndex() const { return OpKind == MO_JumpTableIndex; }
-  bool isGlobalAddress() const { return OpKind == MO_GlobalAddress; }
-  bool isExternalSymbol() const { return OpKind == MO_ExternalSymbol; }
+  //===--------------------------------------------------------------------===//
+  // Accessors that tell you what kind of MachineOperand you're looking at.
+  //===--------------------------------------------------------------------===//
 
+  /// isReg - Tests if this is a MO_Register operand.
   bool isReg() const { return OpKind == MO_Register; }
+  /// isImm - Tests if this is a MO_Immediate operand.
   bool isImm() const { return OpKind == MO_Immediate; }
+  /// isFPImm - Tests if this is a MO_FPImmediate operand.
+  bool isFPImm() const { return OpKind == MO_FPImmediate; }
+  /// isMBB - Tests if this is a MO_MachineBasicBlock operand.
   bool isMBB() const { return OpKind == MO_MachineBasicBlock; }
+  /// isFI - Tests if this is a MO_FrameIndex operand.
   bool isFI() const { return OpKind == MO_FrameIndex; }
+  /// isCPI - Tests if this is a MO_ConstantPoolIndex operand.
   bool isCPI() const { return OpKind == MO_ConstantPoolIndex; }
+  /// isJTI - Tests if this is a MO_JumpTableIndex operand.
   bool isJTI() const { return OpKind == MO_JumpTableIndex; }
+  /// isGlobal - Tests if this is a MO_GlobalAddress operand.
   bool isGlobal() const { return OpKind == MO_GlobalAddress; }
+  /// isSymbol - Tests if this is a MO_ExternalSymbol operand.
   bool isSymbol() const { return OpKind == MO_ExternalSymbol; }
-  
+
   //===--------------------------------------------------------------------===//
   // Accessors for Register Operands
   //===--------------------------------------------------------------------===//
 
   /// getReg - Returns the register number.
   unsigned getReg() const {
-    assert(isRegister() && "This is not a register operand!");
+    assert(isReg() && "This is not a register operand!");
     return Contents.Reg.RegNo;
   }
   
   unsigned getSubReg() const {
-    assert(isRegister() && "Wrong MachineOperand accessor");
+    assert(isReg() && "Wrong MachineOperand accessor");
     return (unsigned)SubReg;
   }
   
   bool isUse() const { 
-    assert(isRegister() && "Wrong MachineOperand accessor");
+    assert(isReg() && "Wrong MachineOperand accessor");
     return !IsDef;
   }
   
   bool isDef() const {
-    assert(isRegister() && "Wrong MachineOperand accessor");
+    assert(isReg() && "Wrong MachineOperand accessor");
     return IsDef;
   }
   
   bool isImplicit() const { 
-    assert(isRegister() && "Wrong MachineOperand accessor");
+    assert(isReg() && "Wrong MachineOperand accessor");
     return IsImp;
   }
   
   bool isDead() const {
-    assert(isRegister() && "Wrong MachineOperand accessor");
+    assert(isReg() && "Wrong MachineOperand accessor");
     return IsDead;
   }
   
   bool isKill() const {
-    assert(isRegister() && "Wrong MachineOperand accessor");
+    assert(isReg() && "Wrong MachineOperand accessor");
     return IsKill;
   }
   
+  bool isEarlyClobber() const {
+    assert(isReg() && "Wrong MachineOperand accessor");
+    return IsEarlyClobber;
+  }
+
   /// getNextOperandForReg - Return the next MachineOperand in the function that
   /// uses or defines this register.
   MachineOperand *getNextOperandForReg() const {
-    assert(isRegister() && "This is not a register operand!");
+    assert(isReg() && "This is not a register operand!");
     return Contents.Reg.Next;
   }
 
@@ -196,74 +209,78 @@ public:
   void setReg(unsigned Reg);
   
   void setSubReg(unsigned subReg) {
-    assert(isRegister() && "Wrong MachineOperand accessor");
+    assert(isReg() && "Wrong MachineOperand accessor");
     SubReg = (unsigned char)subReg;
   }
   
   void setIsUse(bool Val = true) {
-    assert(isRegister() && "Wrong MachineOperand accessor");
+    assert(isReg() && "Wrong MachineOperand accessor");
     IsDef = !Val;
   }
   
   void setIsDef(bool Val = true) {
-    assert(isRegister() && "Wrong MachineOperand accessor");
+    assert(isReg() && "Wrong MachineOperand accessor");
     IsDef = Val;
   }
 
   void setImplicit(bool Val = true) { 
-    assert(isRegister() && "Wrong MachineOperand accessor");
+    assert(isReg() && "Wrong MachineOperand accessor");
     IsImp = Val;
   }
 
   void setIsKill(bool Val = true) {
-    assert(isRegister() && !IsDef && "Wrong MachineOperand accessor");
+    assert(isReg() && !IsDef && "Wrong MachineOperand accessor");
     IsKill = Val;
   }
   
   void setIsDead(bool Val = true) {
-    assert(isRegister() && IsDef && "Wrong MachineOperand accessor");
+    assert(isReg() && IsDef && "Wrong MachineOperand accessor");
     IsDead = Val;
   }
 
+  void setIsEarlyClobber(bool Val = true) {
+    assert(isReg() && IsDef && "Wrong MachineOperand accessor");
+    IsEarlyClobber = Val;
+  }
 
   //===--------------------------------------------------------------------===//
   // Accessors for various operand types.
   //===--------------------------------------------------------------------===//
   
   int64_t getImm() const {
-    assert(isImmediate() && "Wrong MachineOperand accessor");
+    assert(isImm() && "Wrong MachineOperand accessor");
     return Contents.ImmVal;
   }
   
-  ConstantFP *getFPImm() const {
-    assert(isFPImmediate() && "Wrong MachineOperand accessor");
+  const ConstantFP *getFPImm() const {
+    assert(isFPImm() && "Wrong MachineOperand accessor");
     return Contents.CFP;
   }
   
   MachineBasicBlock *getMBB() const {
-    assert(isMachineBasicBlock() && "Wrong MachineOperand accessor");
+    assert(isMBB() && "Wrong MachineOperand accessor");
     return Contents.MBB;
   }
 
   int getIndex() const {
-    assert((isFrameIndex() || isConstantPoolIndex() || isJumpTableIndex()) &&
+    assert((isFI() || isCPI() || isJTI()) &&
            "Wrong MachineOperand accessor");
     return Contents.OffsetedInfo.Val.Index;
   }
   
   GlobalValue *getGlobal() const {
-    assert(isGlobalAddress() && "Wrong MachineOperand accessor");
+    assert(isGlobal() && "Wrong MachineOperand accessor");
     return Contents.OffsetedInfo.Val.GV;
   }
   
-  int getOffset() const {
-    assert((isGlobalAddress() || isExternalSymbol() || isConstantPoolIndex()) &&
+  int64_t getOffset() const {
+    assert((isGlobal() || isSymbol() || isCPI()) &&
            "Wrong MachineOperand accessor");
     return Contents.OffsetedInfo.Offset;
   }
   
   const char *getSymbolName() const {
-    assert(isExternalSymbol() && "Wrong MachineOperand accessor");
+    assert(isSymbol() && "Wrong MachineOperand accessor");
     return Contents.OffsetedInfo.Val.SymbolName;
   }
   
@@ -272,24 +289,24 @@ public:
   //===--------------------------------------------------------------------===//
   
   void setImm(int64_t immVal) {
-    assert(isImmediate() && "Wrong MachineOperand mutator");
+    assert(isImm() && "Wrong MachineOperand mutator");
     Contents.ImmVal = immVal;
   }
 
-  void setOffset(int Offset) {
-    assert((isGlobalAddress() || isExternalSymbol() || isConstantPoolIndex()) &&
+  void setOffset(int64_t Offset) {
+    assert((isGlobal() || isSymbol() || isCPI()) &&
         "Wrong MachineOperand accessor");
     Contents.OffsetedInfo.Offset = Offset;
   }
   
   void setIndex(int Idx) {
-    assert((isFrameIndex() || isConstantPoolIndex() || isJumpTableIndex()) &&
+    assert((isFI() || isCPI() || isJTI()) &&
            "Wrong MachineOperand accessor");
     Contents.OffsetedInfo.Val.Index = Idx;
   }
   
   void setMBB(MachineBasicBlock *MBB) {
-    assert(isMachineBasicBlock() && "Wrong MachineOperand accessor");
+    assert(isMBB() && "Wrong MachineOperand accessor");
     Contents.MBB = MBB;
   }
   
@@ -322,7 +339,7 @@ public:
     return Op;
   }
   
-  static MachineOperand CreateFPImm(ConstantFP *CFP) {
+  static MachineOperand CreateFPImm(const ConstantFP *CFP) {
     MachineOperand Op(MachineOperand::MO_FPImmediate);
     Op.Contents.CFP = CFP;
     return Op;
@@ -330,12 +347,14 @@ public:
   
   static MachineOperand CreateReg(unsigned Reg, bool isDef, bool isImp = false,
                                   bool isKill = false, bool isDead = false,
-                                  unsigned SubReg = 0) {
+                                  unsigned SubReg = 0,
+                                  bool isEarlyClobber = false) {
     MachineOperand Op(MachineOperand::MO_Register);
     Op.IsDef = isDef;
     Op.IsImp = isImp;
     Op.IsKill = isKill;
     Op.IsDead = isDead;
+    Op.IsEarlyClobber = isEarlyClobber;
     Op.Contents.Reg.RegNo = Reg;
     Op.Contents.Reg.Prev = 0;
     Op.Contents.Reg.Next = 0;
@@ -363,13 +382,13 @@ public:
     Op.setIndex(Idx);
     return Op;
   }
-  static MachineOperand CreateGA(GlobalValue *GV, int Offset) {
+  static MachineOperand CreateGA(GlobalValue *GV, int64_t Offset) {
     MachineOperand Op(MachineOperand::MO_GlobalAddress);
     Op.Contents.OffsetedInfo.Val.GV = GV;
     Op.setOffset(Offset);
     return Op;
   }
-  static MachineOperand CreateES(const char *SymName, int Offset = 0) {
+  static MachineOperand CreateES(const char *SymName, int64_t Offset = 0) {
     MachineOperand Op(MachineOperand::MO_ExternalSymbol);
     Op.Contents.OffsetedInfo.Val.SymbolName = SymName;
     Op.setOffset(Offset);
@@ -381,6 +400,7 @@ public:
     IsImp    = MO.IsImp;
     IsKill   = MO.IsKill;
     IsDead   = MO.IsDead;
+    IsEarlyClobber = MO.IsEarlyClobber;
     SubReg   = MO.SubReg;
     ParentMI = MO.ParentMI;
     Contents = MO.Contents;
@@ -408,7 +428,7 @@ private:
   void AddRegOperandToRegInfo(MachineRegisterInfo *RegInfo);
 
   void RemoveRegOperandFromRegInfo() {
-    assert(isOnRegUseList() && "Can only add reg operand to use lists");
+    assert(isOnRegUseList() && "Reg operand is not on a use list");
     // Unlink this from the doubly linked list of operands.
     MachineOperand *NextOp = Contents.Reg.Next;
     *Contents.Reg.Prev = NextOp; 
@@ -426,6 +446,11 @@ inline std::ostream &operator<<(std::ostream &OS, const MachineOperand &MO) {
   return OS;
 }
 
+inline raw_ostream &operator<<(raw_ostream &OS, const MachineOperand& MO) {
+  MO.print(OS, 0);
+  return OS;
+}
+
 } // End llvm namespace
 
 #endif