include/llvm/CodeGen/MachineOperand.h

   1 //===-- llvm/CodeGen/MachineOperand.h - MachineOperand class ----*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file contains the declaration of the MachineOperand class.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #ifndef LLVM_CODEGEN_MACHINEOPERAND_H
  15 #define LLVM_CODEGEN_MACHINEOPERAND_H
  16
  17 #include "llvm/Support/DataTypes.h"
  18 #include <cassert>
  19
  20 namespace llvm {
  21
  22 class BlockAddress;
  23 class ConstantFP;
  24 class GlobalValue;
  25 class MachineBasicBlock;
  26 class MachineInstr;
  27 class MachineRegisterInfo;
  28 class MDNode;
  29 class TargetMachine;
  30 class TargetRegisterInfo;
  31 class raw_ostream;
  32 class MCSymbol;
  33
  34 /// MachineOperand class - Representation of each machine instruction operand.
  35 ///
  36 class MachineOperand {
  37 public:
  38   enum MachineOperandType {
  39     MO_Register,               ///< Register operand.
  40     MO_Immediate,              ///< Immediate operand
  41     MO_FPImmediate,            ///< Floating-point immediate operand
  42     MO_MachineBasicBlock,      ///< MachineBasicBlock reference
  43     MO_FrameIndex,             ///< Abstract Stack Frame Index
  44     MO_ConstantPoolIndex,      ///< Address of indexed Constant in Constant Pool
  45     MO_JumpTableIndex,         ///< Address of indexed Jump Table for switch
  46     MO_ExternalSymbol,         ///< Name of external global symbol
  47     MO_GlobalAddress,          ///< Address of a global value
  48     MO_BlockAddress,           ///< Address of a basic block
  49     MO_Metadata,               ///< Metadata reference (for debug info)
  50     MO_MCSymbol                ///< MCSymbol reference (for debug/eh info)
  51   };
  52
  53 private:
  54   /// OpKind - Specify what kind of operand this is.  This discriminates the
  55   /// union.
  56   unsigned char OpKind; // MachineOperandType
  57
  58   /// SubReg - Subregister number, only valid for MO_Register.  A value of 0
  59   /// indicates the MO_Register has no subReg.
  60   unsigned char SubReg;
  61
  62   /// TargetFlags - This is a set of target-specific operand flags.
  63   unsigned char TargetFlags;
  64
  65   /// IsDef/IsImp/IsKill/IsDead flags - These are only valid for MO_Register
  66   /// operands.
  67
  68   /// IsDef - True if this is a def, false if this is a use of the register.
  69   ///
  70   bool IsDef : 1;
  71
  72   /// IsImp - True if this is an implicit def or use, false if it is explicit.
  73   ///
  74   bool IsImp : 1;
  75
  76   /// IsKill - True if this instruction is the last use of the register on this
  77   /// path through the function.  This is only valid on uses of registers.
  78   bool IsKill : 1;
  79
  80   /// IsDead - True if this register is never used by a subsequent instruction.
  81   /// This is only valid on definitions of registers.
  82   bool IsDead : 1;
  83
  84   /// IsUndef - True if this is a register def / use of "undef", i.e. register
  85   /// defined by an IMPLICIT_DEF. This is only valid on registers.
  86   bool IsUndef : 1;
  87
  88   /// IsEarlyClobber - True if this MO_Register 'def' operand is written to
  89   /// by the MachineInstr before all input registers are read.  This is used to
  90   /// model the GCC inline asm '&' constraint modifier.
  91   bool IsEarlyClobber : 1;
  92
  93   /// IsDebug - True if this MO_Register 'use' operand is in a debug pseudo,
  94   /// not a real instruction.  Such uses should be ignored during codegen.
  95   bool IsDebug : 1;
  96
  97   /// SmallContents - Thisreally should be part of the Contents union, but lives
  98   /// out here so we can get a better packed struct.
  99   /// MO_Register: Register number.
 100   /// OffsetedInfo: Low bits of offset.
 101   union {
 102     unsigned RegNo;           // For MO_Register.
 103     unsigned OffsetLo;        // Matches Contents.OffsetedInfo.OffsetHi.
 104   } SmallContents;
 105
 106   /// ParentMI - This is the instruction that this operand is embedded into.
 107   /// This is valid for all operand types, when the operand is in an instr.
 108   MachineInstr *ParentMI;
 109
 110   /// Contents union - This contains the payload for the various operand types.
 111   union {
 112     MachineBasicBlock *MBB;   // For MO_MachineBasicBlock.
 113     const ConstantFP *CFP;    // For MO_FPImmediate.
 114     int64_t ImmVal;           // For MO_Immediate.
 115     const MDNode *MD;         // For MO_Metadata.
 116     MCSymbol *Sym;            // For MO_MCSymbol
 117
 118     struct {                  // For MO_Register.
 119       // Register number is in SmallContents.RegNo.
 120       MachineOperand **Prev;  // Access list for register.
 121       MachineOperand *Next;
 122     } Reg;
 123
 124     /// OffsetedInfo - This struct contains the offset and an object identifier.
 125     /// this represent the object as with an optional offset from it.
 126     struct {
 127       union {
 128         int Index;                // For MO_*Index - The index itself.
 129         const char *SymbolName;   // For MO_ExternalSymbol.
 130         const GlobalValue *GV;    // For MO_GlobalAddress.
 131         const BlockAddress *BA;   // For MO_BlockAddress.
 132       } Val;
 133       // Low bits of offset are in SmallContents.OffsetLo.
 134       int OffsetHi;               // An offset from the object, high 32 bits.
 135     } OffsetedInfo;
 136   } Contents;
 137
 138   explicit MachineOperand(MachineOperandType K) : OpKind(K), ParentMI(0) {
 139     TargetFlags = 0;
 140   }
 141 public:
 142   /// getType - Returns the MachineOperandType for this operand.
 143   ///
 144   MachineOperandType getType() const { return (MachineOperandType)OpKind; }
 145
 146   unsigned char getTargetFlags() const { return TargetFlags; }
 147   void setTargetFlags(unsigned char F) { TargetFlags = F; }
 148   void addTargetFlag(unsigned char F) { TargetFlags |= F; }
 149
 150
 151   /// getParent - Return the instruction that this operand belongs to.
 152   ///
 153   MachineInstr *getParent() { return ParentMI; }
 154   const MachineInstr *getParent() const { return ParentMI; }
 155
 156   /// clearParent - Reset the parent pointer.
 157   ///
 158   /// The MachineOperand copy constructor also copies ParentMI, expecting the
 159   /// original to be deleted. If a MachineOperand is ever stored outside a
 160   /// MachineInstr, the parent pointer must be cleared.
 161   ///
 162   /// Never call clearParent() on an operand in a MachineInstr.
 163   ///
 164   void clearParent() { ParentMI = 0; }
 165
 166   void print(raw_ostream &os, const TargetMachine *TM = 0) const;
 167
 168   //===--------------------------------------------------------------------===//
 169   // Accessors that tell you what kind of MachineOperand you're looking at.
 170   //===--------------------------------------------------------------------===//
 171
 172   /// isReg - Tests if this is a MO_Register operand.
 173   bool isReg() const { return OpKind == MO_Register; }
 174   /// isImm - Tests if this is a MO_Immediate operand.
 175   bool isImm() const { return OpKind == MO_Immediate; }
 176   /// isFPImm - Tests if this is a MO_FPImmediate operand.
 177   bool isFPImm() const { return OpKind == MO_FPImmediate; }
 178   /// isMBB - Tests if this is a MO_MachineBasicBlock operand.
 179   bool isMBB() const { return OpKind == MO_MachineBasicBlock; }
 180   /// isFI - Tests if this is a MO_FrameIndex operand.
 181   bool isFI() const { return OpKind == MO_FrameIndex; }
 182   /// isCPI - Tests if this is a MO_ConstantPoolIndex operand.
 183   bool isCPI() const { return OpKind == MO_ConstantPoolIndex; }
 184   /// isJTI - Tests if this is a MO_JumpTableIndex operand.
 185   bool isJTI() const { return OpKind == MO_JumpTableIndex; }
 186   /// isGlobal - Tests if this is a MO_GlobalAddress operand.
 187   bool isGlobal() const { return OpKind == MO_GlobalAddress; }
 188   /// isSymbol - Tests if this is a MO_ExternalSymbol operand.
 189   bool isSymbol() const { return OpKind == MO_ExternalSymbol; }
 190   /// isBlockAddress - Tests if this is a MO_BlockAddress operand.
 191   bool isBlockAddress() const { return OpKind == MO_BlockAddress; }
 192   /// isMetadata - Tests if this is a MO_Metadata operand.
 193   bool isMetadata() const { return OpKind == MO_Metadata; }
 194   bool isMCSymbol() const { return OpKind == MO_MCSymbol; }
 195
 196   //===--------------------------------------------------------------------===//
 197   // Accessors for Register Operands
 198   //===--------------------------------------------------------------------===//
 199
 200   /// getReg - Returns the register number.
 201   unsigned getReg() const {
 202     assert(isReg() && "This is not a register operand!");
 203     return SmallContents.RegNo;
 204   }
 205
 206   unsigned getSubReg() const {
 207     assert(isReg() && "Wrong MachineOperand accessor");
 208     return (unsigned)SubReg;
 209   }
 210
 211   bool isUse() const {
 212     assert(isReg() && "Wrong MachineOperand accessor");
 213     return !IsDef;
 214   }
 215
 216   bool isDef() const {
 217     assert(isReg() && "Wrong MachineOperand accessor");
 218     return IsDef;
 219   }
 220
 221   bool isImplicit() const {
 222     assert(isReg() && "Wrong MachineOperand accessor");
 223     return IsImp;
 224   }
 225
 226   bool isDead() const {
 227     assert(isReg() && "Wrong MachineOperand accessor");
 228     return IsDead;
 229   }
 230
 231   bool isKill() const {
 232     assert(isReg() && "Wrong MachineOperand accessor");
 233     return IsKill;
 234   }
 235
 236   bool isUndef() const {
 237     assert(isReg() && "Wrong MachineOperand accessor");
 238     return IsUndef;
 239   }
 240
 241   bool isEarlyClobber() const {
 242     assert(isReg() && "Wrong MachineOperand accessor");
 243     return IsEarlyClobber;
 244   }
 245
 246   bool isDebug() const {
 247     assert(isReg() && "Wrong MachineOperand accessor");
 248     return IsDebug;
 249   }
 250
 251   /// getNextOperandForReg - Return the next MachineOperand in the function that
 252   /// uses or defines this register.
 253   MachineOperand *getNextOperandForReg() const {
 254     assert(isReg() && "This is not a register operand!");
 255     return Contents.Reg.Next;
 256   }
 257
 258   //===--------------------------------------------------------------------===//
 259   // Mutators for Register Operands
 260   //===--------------------------------------------------------------------===//
 261
 262   /// Change the register this operand corresponds to.
 263   ///
 264   void setReg(unsigned Reg);
 265
 266   void setSubReg(unsigned subReg) {
 267     assert(isReg() && "Wrong MachineOperand accessor");
 268     SubReg = (unsigned char)subReg;
 269   }
 270
 271   /// substVirtReg - Substitute the current register with the virtual
 272   /// subregister Reg:SubReg. Take any existing SubReg index into account,
 273   /// using TargetRegisterInfo to compose the subreg indices if necessary.
 274   /// Reg must be a virtual register, SubIdx can be 0.
 275   ///
 276   void substVirtReg(unsigned Reg, unsigned SubIdx, const TargetRegisterInfo&);
 277
 278   /// substPhysReg - Substitute the current register with the physical register
 279   /// Reg, taking any existing SubReg into account. For instance,
 280   /// substPhysReg(%EAX) will change %reg1024:sub_8bit to %AL.
 281   ///
 282   void substPhysReg(unsigned Reg, const TargetRegisterInfo&);
 283
 284   void setIsUse(bool Val = true) {
 285     assert(isReg() && "Wrong MachineOperand accessor");
 286     assert((Val || !isDebug()) && "Marking a debug operation as def");
 287     IsDef = !Val;
 288   }
 289
 290   void setIsDef(bool Val = true) {
 291     assert(isReg() && "Wrong MachineOperand accessor");
 292     assert((!Val || !isDebug()) && "Marking a debug operation as def");
 293     IsDef = Val;
 294   }
 295
 296   void setImplicit(bool Val = true) {
 297     assert(isReg() && "Wrong MachineOperand accessor");
 298     IsImp = Val;
 299   }
 300
 301   void setIsKill(bool Val = true) {
 302     assert(isReg() && !IsDef && "Wrong MachineOperand accessor");
 303     assert((!Val || !isDebug()) && "Marking a debug operation as kill");
 304     IsKill = Val;
 305   }
 306
 307   void setIsDead(bool Val = true) {
 308     assert(isReg() && IsDef && "Wrong MachineOperand accessor");
 309     IsDead = Val;
 310   }
 311
 312   void setIsUndef(bool Val = true) {
 313     assert(isReg() && "Wrong MachineOperand accessor");
 314     IsUndef = Val;
 315   }
 316
 317   void setIsEarlyClobber(bool Val = true) {
 318     assert(isReg() && IsDef && "Wrong MachineOperand accessor");
 319     IsEarlyClobber = Val;
 320   }
 321
 322   void setIsDebug(bool Val = true) {
 323     assert(isReg() && IsDef && "Wrong MachineOperand accessor");
 324     IsDebug = Val;
 325   }
 326
 327   //===--------------------------------------------------------------------===//
 328   // Accessors for various operand types.
 329   //===--------------------------------------------------------------------===//
 330
 331   int64_t getImm() const {
 332     assert(isImm() && "Wrong MachineOperand accessor");
 333     return Contents.ImmVal;
 334   }
 335
 336   const ConstantFP *getFPImm() const {
 337     assert(isFPImm() && "Wrong MachineOperand accessor");
 338     return Contents.CFP;
 339   }
 340
 341   MachineBasicBlock *getMBB() const {
 342     assert(isMBB() && "Wrong MachineOperand accessor");
 343     return Contents.MBB;
 344   }
 345
 346   int getIndex() const {
 347     assert((isFI() || isCPI() || isJTI()) &&
 348            "Wrong MachineOperand accessor");
 349     return Contents.OffsetedInfo.Val.Index;
 350   }
 351
 352   const GlobalValue *getGlobal() const {
 353     assert(isGlobal() && "Wrong MachineOperand accessor");
 354     return Contents.OffsetedInfo.Val.GV;
 355   }
 356
 357   const BlockAddress *getBlockAddress() const {
 358     assert(isBlockAddress() && "Wrong MachineOperand accessor");
 359     return Contents.OffsetedInfo.Val.BA;
 360   }
 361
 362   MCSymbol *getMCSymbol() const {
 363     assert(isMCSymbol() && "Wrong MachineOperand accessor");
 364     return Contents.Sym;
 365   }
 366
 367   /// getOffset - Return the offset from the symbol in this operand. This always
 368   /// returns 0 for ExternalSymbol operands.
 369   int64_t getOffset() const {
 370     assert((isGlobal() || isSymbol() || isCPI() || isBlockAddress()) &&
 371            "Wrong MachineOperand accessor");
 372     return (int64_t(Contents.OffsetedInfo.OffsetHi) << 32) |
 373            SmallContents.OffsetLo;
 374   }
 375
 376   const char *getSymbolName() const {
 377     assert(isSymbol() && "Wrong MachineOperand accessor");
 378     return Contents.OffsetedInfo.Val.SymbolName;
 379   }
 380
 381   const MDNode *getMetadata() const {
 382     assert(isMetadata() && "Wrong MachineOperand accessor");
 383     return Contents.MD;
 384   }
 385
 386   //===--------------------------------------------------------------------===//
 387   // Mutators for various operand types.
 388   //===--------------------------------------------------------------------===//
 389
 390   void setImm(int64_t immVal) {
 391     assert(isImm() && "Wrong MachineOperand mutator");
 392     Contents.ImmVal = immVal;
 393   }
 394
 395   void setOffset(int64_t Offset) {
 396     assert((isGlobal() || isSymbol() || isCPI() || isBlockAddress()) &&
 397         "Wrong MachineOperand accessor");
 398     SmallContents.OffsetLo = unsigned(Offset);
 399     Contents.OffsetedInfo.OffsetHi = int(Offset >> 32);
 400   }
 401
 402   void setIndex(int Idx) {
 403     assert((isFI() || isCPI() || isJTI()) &&
 404            "Wrong MachineOperand accessor");
 405     Contents.OffsetedInfo.Val.Index = Idx;
 406   }
 407
 408   void setMBB(MachineBasicBlock *MBB) {
 409     assert(isMBB() && "Wrong MachineOperand accessor");
 410     Contents.MBB = MBB;
 411   }
 412
 413   //===--------------------------------------------------------------------===//
 414   // Other methods.
 415   //===--------------------------------------------------------------------===//
 416
 417   /// isIdenticalTo - Return true if this operand is identical to the specified
 418   /// operand. Note: This method ignores isKill and isDead properties.
 419   bool isIdenticalTo(const MachineOperand &Other) const;
 420
 421   /// ChangeToImmediate - Replace this operand with a new immediate operand of
 422   /// the specified value.  If an operand is known to be an immediate already,
 423   /// the setImm method should be used.
 424   void ChangeToImmediate(int64_t ImmVal);
 425
 426   /// ChangeToRegister - Replace this operand with a new register operand of
 427   /// the specified value.  If an operand is known to be an register already,
 428   /// the setReg method should be used.
 429   void ChangeToRegister(unsigned Reg, bool isDef, bool isImp = false,
 430                         bool isKill = false, bool isDead = false,
 431                         bool isUndef = false, bool isDebug = false);
 432
 433   //===--------------------------------------------------------------------===//
 434   // Construction methods.
 435   //===--------------------------------------------------------------------===//
 436
 437   static MachineOperand CreateImm(int64_t Val) {
 438     MachineOperand Op(MachineOperand::MO_Immediate);
 439     Op.setImm(Val);
 440     return Op;
 441   }
 442
 443   static MachineOperand CreateFPImm(const ConstantFP *CFP) {
 444     MachineOperand Op(MachineOperand::MO_FPImmediate);
 445     Op.Contents.CFP = CFP;
 446     return Op;
 447   }
 448
 449   static MachineOperand CreateReg(unsigned Reg, bool isDef, bool isImp = false,
 450                                   bool isKill = false, bool isDead = false,
 451                                   bool isUndef = false,
 452                                   bool isEarlyClobber = false,
 453                                   unsigned SubReg = 0,
 454                                   bool isDebug = false) {
 455     MachineOperand Op(MachineOperand::MO_Register);
 456     Op.IsDef = isDef;
 457     Op.IsImp = isImp;
 458     Op.IsKill = isKill;
 459     Op.IsDead = isDead;
 460     Op.IsUndef = isUndef;
 461     Op.IsEarlyClobber = isEarlyClobber;
 462     Op.IsDebug = isDebug;
 463     Op.SmallContents.RegNo = Reg;
 464     Op.Contents.Reg.Prev = 0;
 465     Op.Contents.Reg.Next = 0;
 466     Op.SubReg = SubReg;
 467     return Op;
 468   }
 469   static MachineOperand CreateMBB(MachineBasicBlock *MBB,
 470                                   unsigned char TargetFlags = 0) {
 471     MachineOperand Op(MachineOperand::MO_MachineBasicBlock);
 472     Op.setMBB(MBB);
 473     Op.setTargetFlags(TargetFlags);
 474     return Op;
 475   }
 476   static MachineOperand CreateFI(unsigned Idx) {
 477     MachineOperand Op(MachineOperand::MO_FrameIndex);
 478     Op.setIndex(Idx);
 479     return Op;
 480   }
 481   static MachineOperand CreateCPI(unsigned Idx, int Offset,
 482                                   unsigned char TargetFlags = 0) {
 483     MachineOperand Op(MachineOperand::MO_ConstantPoolIndex);
 484     Op.setIndex(Idx);
 485     Op.setOffset(Offset);
 486     Op.setTargetFlags(TargetFlags);
 487     return Op;
 488   }
 489   static MachineOperand CreateJTI(unsigned Idx,
 490                                   unsigned char TargetFlags = 0) {
 491     MachineOperand Op(MachineOperand::MO_JumpTableIndex);
 492     Op.setIndex(Idx);
 493     Op.setTargetFlags(TargetFlags);
 494     return Op;
 495   }
 496   static MachineOperand CreateGA(const GlobalValue *GV, int64_t Offset,
 497                                  unsigned char TargetFlags = 0) {
 498     MachineOperand Op(MachineOperand::MO_GlobalAddress);
 499     Op.Contents.OffsetedInfo.Val.GV = GV;
 500     Op.setOffset(Offset);
 501     Op.setTargetFlags(TargetFlags);
 502     return Op;
 503   }
 504   static MachineOperand CreateES(const char *SymName,
 505                                  unsigned char TargetFlags = 0) {
 506     MachineOperand Op(MachineOperand::MO_ExternalSymbol);
 507     Op.Contents.OffsetedInfo.Val.SymbolName = SymName;
 508     Op.setOffset(0); // Offset is always 0.
 509     Op.setTargetFlags(TargetFlags);
 510     return Op;
 511   }
 512   static MachineOperand CreateBA(const BlockAddress *BA,
 513                                  unsigned char TargetFlags = 0) {
 514     MachineOperand Op(MachineOperand::MO_BlockAddress);
 515     Op.Contents.OffsetedInfo.Val.BA = BA;
 516     Op.setOffset(0); // Offset is always 0.
 517     Op.setTargetFlags(TargetFlags);
 518     return Op;
 519   }
 520   static MachineOperand CreateMetadata(const MDNode *Meta) {
 521     MachineOperand Op(MachineOperand::MO_Metadata);
 522     Op.Contents.MD = Meta;
 523     return Op;
 524   }
 525
 526   static MachineOperand CreateMCSymbol(MCSymbol *Sym) {
 527     MachineOperand Op(MachineOperand::MO_MCSymbol);
 528     Op.Contents.Sym = Sym;
 529     return Op;
 530   }
 531
 532   friend class MachineInstr;
 533   friend class MachineRegisterInfo;
 534 private:
 535   //===--------------------------------------------------------------------===//
 536   // Methods for handling register use/def lists.
 537   //===--------------------------------------------------------------------===//
 538
 539   /// isOnRegUseList - Return true if this operand is on a register use/def list
 540   /// or false if not.  This can only be called for register operands that are
 541   /// part of a machine instruction.
 542   bool isOnRegUseList() const {
 543     assert(isReg() && "Can only add reg operand to use lists");
 544     return Contents.Reg.Prev != 0;
 545   }
 546
 547   /// AddRegOperandToRegInfo - Add this register operand to the specified
 548   /// MachineRegisterInfo.  If it is null, then the next/prev fields should be
 549   /// explicitly nulled out.
 550   void AddRegOperandToRegInfo(MachineRegisterInfo *RegInfo);
 551
 552   /// RemoveRegOperandFromRegInfo - Remove this register operand from the
 553   /// MachineRegisterInfo it is linked with.
 554   void RemoveRegOperandFromRegInfo();
 555 };
 556
 557 inline raw_ostream &operator<<(raw_ostream &OS, const MachineOperand& MO) {
 558   MO.print(OS, 0);
 559   return OS;
 560 }
 561
 562 } // End llvm namespace
 563
 564 #endif