include/llvm/Target/TargetInstrDesc.h

   1 //===-- llvm/Target/TargetInstrDesc.h - Instruction Descriptors -*- 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 defines the TargetOperandInfo and TargetInstrDesc classes, which
  11 // are used to describe target instructions and their operands.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #ifndef LLVM_TARGET_TARGETINSTRDESC_H
  16 #define LLVM_TARGET_TARGETINSTRDESC_H
  17
  18 #include "llvm/System/DataTypes.h"
  19
  20 namespace llvm {
  21
  22 class TargetRegisterClass;
  23 class TargetRegisterInfo;
  24
  25 //===----------------------------------------------------------------------===//
  26 // Machine Operand Flags and Description
  27 //===----------------------------------------------------------------------===//
  28
  29 namespace TOI {
  30   // Operand constraints
  31   enum OperandConstraint {
  32     TIED_TO = 0,    // Must be allocated the same register as.
  33     EARLY_CLOBBER   // Operand is an early clobber register operand
  34   };
  35
  36   /// OperandFlags - These are flags set on operands, but should be considered
  37   /// private, all access should go through the TargetOperandInfo accessors.
  38   /// See the accessors for a description of what these are.
  39   enum OperandFlags {
  40     LookupPtrRegClass = 0,
  41     Predicate,
  42     OptionalDef
  43   };
  44 }
  45
  46 /// TargetOperandInfo - This holds information about one operand of a machine
  47 /// instruction, indicating the register class for register operands, etc.
  48 ///
  49 class TargetOperandInfo {
  50 public:
  51   /// RegClass - This specifies the register class enumeration of the operand
  52   /// if the operand is a register.  If isLookupPtrRegClass is set, then this is
  53   /// an index that is passed to TargetRegisterInfo::getPointerRegClass(x) to
  54   /// get a dynamic register class.
  55   ///
  56   /// NOTE: This member should be considered to be private, all access should go
  57   /// through "getRegClass(TRI)" below.
  58   short RegClass;
  59
  60   /// Flags - These are flags from the TOI::OperandFlags enum.
  61   unsigned short Flags;
  62
  63   /// Lower 16 bits are used to specify which constraints are set. The higher 16
  64   /// bits are used to specify the value of constraints (4 bits each).
  65   unsigned Constraints;
  66   /// Currently no other information.
  67
  68   /// getRegClass - Get the register class for the operand, handling resolution
  69   /// of "symbolic" pointer register classes etc.  If this is not a register
  70   /// operand, this returns null.
  71   const TargetRegisterClass *getRegClass(const TargetRegisterInfo *TRI) const;
  72
  73
  74   /// isLookupPtrRegClass - Set if this operand is a pointer value and it
  75   /// requires a callback to look up its register class.
  76   bool isLookupPtrRegClass() const { return Flags&(1 <<TOI::LookupPtrRegClass);}
  77
  78   /// isPredicate - Set if this is one of the operands that made up of
  79   /// the predicate operand that controls an isPredicable() instruction.
  80   bool isPredicate() const { return Flags & (1 << TOI::Predicate); }
  81
  82   /// isOptionalDef - Set if this operand is a optional def.
  83   ///
  84   bool isOptionalDef() const { return Flags & (1 << TOI::OptionalDef); }
  85 };
  86
  87
  88 //===----------------------------------------------------------------------===//
  89 // Machine Instruction Flags and Description
  90 //===----------------------------------------------------------------------===//
  91
  92 /// TargetInstrDesc flags - These should be considered private to the
  93 /// implementation of the TargetInstrDesc class.  Clients should use the
  94 /// predicate methods on TargetInstrDesc, not use these directly.  These
  95 /// all correspond to bitfields in the TargetInstrDesc::Flags field.
  96 namespace TID {
  97   enum {
  98     Variadic = 0,
  99     HasOptionalDef,
 100     Return,
 101     Call,
 102     Barrier,
 103     Terminator,
 104     Branch,
 105     IndirectBranch,
 106     Predicable,
 107     NotDuplicable,
 108     Compare,
 109     DelaySlot,
 110     FoldableAsLoad,
 111     MayLoad,
 112     MayStore,
 113     UnmodeledSideEffects,
 114     Commutable,
 115     ConvertibleTo3Addr,
 116     UsesCustomInserter,
 117     Rematerializable,
 118     CheapAsAMove,
 119     ExtraSrcRegAllocReq,
 120     ExtraDefRegAllocReq
 121   };
 122 }
 123
 124 /// TargetInstrDesc - Describe properties that are true of each
 125 /// instruction in the target description file.  This captures information about
 126 /// side effects, register use and many other things.  There is one instance of
 127 /// this struct for each target instruction class, and the MachineInstr class
 128 /// points to this struct directly to describe itself.
 129 class TargetInstrDesc {
 130 public:
 131   unsigned short  Opcode;        // The opcode number
 132   unsigned short  NumOperands;   // Num of args (may be more if variable_ops)
 133   unsigned short  NumDefs;       // Num of args that are definitions
 134   unsigned short  SchedClass;    // enum identifying instr sched class
 135   const char *    Name;          // Name of the instruction record in td file
 136   unsigned        Flags;         // Flags identifying machine instr class
 137   uint64_t        TSFlags;       // Target Specific Flag values
 138   const unsigned *ImplicitUses;  // Registers implicitly read by this instr
 139   const unsigned *ImplicitDefs;  // Registers implicitly defined by this instr
 140   const TargetRegisterClass **RCBarriers; // Reg classes completely "clobbered"
 141   const TargetOperandInfo *OpInfo; // 'NumOperands' entries about operands
 142
 143   /// getOperandConstraint - Returns the value of the specific constraint if
 144   /// it is set. Returns -1 if it is not set.
 145   int getOperandConstraint(unsigned OpNum,
 146                            TOI::OperandConstraint Constraint) const {
 147     if (OpNum < NumOperands &&
 148         (OpInfo[OpNum].Constraints & (1 << Constraint))) {
 149       unsigned Pos = 16 + Constraint * 4;
 150       return (int)(OpInfo[OpNum].Constraints >> Pos) & 0xf;
 151     }
 152     return -1;
 153   }
 154
 155   /// getOpcode - Return the opcode number for this descriptor.
 156   unsigned getOpcode() const {
 157     return Opcode;
 158   }
 159
 160   /// getName - Return the name of the record in the .td file for this
 161   /// instruction, for example "ADD8ri".
 162   const char *getName() const {
 163     return Name;
 164   }
 165
 166   /// getNumOperands - Return the number of declared MachineOperands for this
 167   /// MachineInstruction.  Note that variadic (isVariadic() returns true)
 168   /// instructions may have additional operands at the end of the list, and note
 169   /// that the machine instruction may include implicit register def/uses as
 170   /// well.
 171   unsigned getNumOperands() const {
 172     return NumOperands;
 173   }
 174
 175   /// getNumDefs - Return the number of MachineOperands that are register
 176   /// definitions.  Register definitions always occur at the start of the
 177   /// machine operand list.  This is the number of "outs" in the .td file,
 178   /// and does not include implicit defs.
 179   unsigned getNumDefs() const {
 180     return NumDefs;
 181   }
 182
 183   /// isVariadic - Return true if this instruction can have a variable number of
 184   /// operands.  In this case, the variable operands will be after the normal
 185   /// operands but before the implicit definitions and uses (if any are
 186   /// present).
 187   bool isVariadic() const {
 188     return Flags & (1 << TID::Variadic);
 189   }
 190
 191   /// hasOptionalDef - Set if this instruction has an optional definition, e.g.
 192   /// ARM instructions which can set condition code if 's' bit is set.
 193   bool hasOptionalDef() const {
 194     return Flags & (1 << TID::HasOptionalDef);
 195   }
 196
 197   /// getImplicitUses - Return a list of registers that are potentially
 198   /// read by any instance of this machine instruction.  For example, on X86,
 199   /// the "adc" instruction adds two register operands and adds the carry bit in
 200   /// from the flags register.  In this case, the instruction is marked as
 201   /// implicitly reading the flags.  Likewise, the variable shift instruction on
 202   /// X86 is marked as implicitly reading the 'CL' register, which it always
 203   /// does.
 204   ///
 205   /// This method returns null if the instruction has no implicit uses.
 206   const unsigned *getImplicitUses() const {
 207     return ImplicitUses;
 208   }
 209
 210   /// getNumImplicitUses - Return the number of implicit uses this instruction
 211   /// has.
 212   unsigned getNumImplicitUses() const {
 213     if (ImplicitUses == 0) return 0;
 214     unsigned i = 0;
 215     for (; ImplicitUses[i]; ++i) /*empty*/;
 216     return i;
 217   }
 218
 219
 220   /// getImplicitDefs - Return a list of registers that are potentially
 221   /// written by any instance of this machine instruction.  For example, on X86,
 222   /// many instructions implicitly set the flags register.  In this case, they
 223   /// are marked as setting the FLAGS.  Likewise, many instructions always
 224   /// deposit their result in a physical register.  For example, the X86 divide
 225   /// instruction always deposits the quotient and remainder in the EAX/EDX
 226   /// registers.  For that instruction, this will return a list containing the
 227   /// EAX/EDX/EFLAGS registers.
 228   ///
 229   /// This method returns null if the instruction has no implicit defs.
 230   const unsigned *getImplicitDefs() const {
 231     return ImplicitDefs;
 232   }
 233
 234   /// getNumImplicitDefs - Return the number of implicit defs this instruction
 235   /// has.
 236   unsigned getNumImplicitDefs() const {
 237     if (ImplicitDefs == 0) return 0;
 238     unsigned i = 0;
 239     for (; ImplicitDefs[i]; ++i) /*empty*/;
 240     return i;
 241   }
 242
 243   /// hasImplicitUseOfPhysReg - Return true if this instruction implicitly
 244   /// uses the specified physical register.
 245   bool hasImplicitUseOfPhysReg(unsigned Reg) const {
 246     if (const unsigned *ImpUses = ImplicitUses)
 247       for (; *ImpUses; ++ImpUses)
 248         if (*ImpUses == Reg) return true;
 249     return false;
 250   }
 251
 252   /// hasImplicitDefOfPhysReg - Return true if this instruction implicitly
 253   /// defines the specified physical register.
 254   bool hasImplicitDefOfPhysReg(unsigned Reg) const {
 255     if (const unsigned *ImpDefs = ImplicitDefs)
 256       for (; *ImpDefs; ++ImpDefs)
 257         if (*ImpDefs == Reg) return true;
 258     return false;
 259   }
 260
 261   /// getRegClassBarriers - Return a list of register classes that are
 262   /// completely clobbered by this machine instruction. For example, on X86
 263   /// the call instructions will completely clobber all the registers in the
 264   /// fp stack and XMM classes.
 265   ///
 266   /// This method returns null if the instruction doesn't completely clobber
 267   /// any register class.
 268   const TargetRegisterClass **getRegClassBarriers() const {
 269     return RCBarriers;
 270   }
 271
 272   /// getSchedClass - Return the scheduling class for this instruction.  The
 273   /// scheduling class is an index into the InstrItineraryData table.  This
 274   /// returns zero if there is no known scheduling information for the
 275   /// instruction.
 276   ///
 277   unsigned getSchedClass() const {
 278     return SchedClass;
 279   }
 280
 281   bool isReturn() const {
 282     return Flags & (1 << TID::Return);
 283   }
 284
 285   bool isCall() const {
 286     return Flags & (1 << TID::Call);
 287   }
 288
 289   /// isBarrier - Returns true if the specified instruction stops control flow
 290   /// from executing the instruction immediately following it.  Examples include
 291   /// unconditional branches and return instructions.
 292   bool isBarrier() const {
 293     return Flags & (1 << TID::Barrier);
 294   }
 295
 296   /// isTerminator - Returns true if this instruction part of the terminator for
 297   /// a basic block.  Typically this is things like return and branch
 298   /// instructions.
 299   ///
 300   /// Various passes use this to insert code into the bottom of a basic block,
 301   /// but before control flow occurs.
 302   bool isTerminator() const {
 303     return Flags & (1 << TID::Terminator);
 304   }
 305
 306   /// isBranch - Returns true if this is a conditional, unconditional, or
 307   /// indirect branch.  Predicates below can be used to discriminate between
 308   /// these cases, and the TargetInstrInfo::AnalyzeBranch method can be used to
 309   /// get more information.
 310   bool isBranch() const {
 311     return Flags & (1 << TID::Branch);
 312   }
 313
 314   /// isIndirectBranch - Return true if this is an indirect branch, such as a
 315   /// branch through a register.
 316   bool isIndirectBranch() const {
 317     return Flags & (1 << TID::IndirectBranch);
 318   }
 319
 320   /// isConditionalBranch - Return true if this is a branch which may fall
 321   /// through to the next instruction or may transfer control flow to some other
 322   /// block.  The TargetInstrInfo::AnalyzeBranch method can be used to get more
 323   /// information about this branch.
 324   bool isConditionalBranch() const {
 325     return isBranch() & !isBarrier() & !isIndirectBranch();
 326   }
 327
 328   /// isUnconditionalBranch - Return true if this is a branch which always
 329   /// transfers control flow to some other block.  The
 330   /// TargetInstrInfo::AnalyzeBranch method can be used to get more information
 331   /// about this branch.
 332   bool isUnconditionalBranch() const {
 333     return isBranch() & isBarrier() & !isIndirectBranch();
 334   }
 335
 336   // isPredicable - Return true if this instruction has a predicate operand that
 337   // controls execution.  It may be set to 'always', or may be set to other
 338   /// values.   There are various methods in TargetInstrInfo that can be used to
 339   /// control and modify the predicate in this instruction.
 340   bool isPredicable() const {
 341     return Flags & (1 << TID::Predicable);
 342   }
 343
 344   /// isCompare - Return true if this instruction is a comparison.
 345   bool isCompare() const {
 346     return Flags & (1 << TID::Compare);
 347   }
 348
 349   /// isNotDuplicable - Return true if this instruction cannot be safely
 350   /// duplicated.  For example, if the instruction has a unique labels attached
 351   /// to it, duplicating it would cause multiple definition errors.
 352   bool isNotDuplicable() const {
 353     return Flags & (1 << TID::NotDuplicable);
 354   }
 355
 356   /// hasDelaySlot - Returns true if the specified instruction has a delay slot
 357   /// which must be filled by the code generator.
 358   bool hasDelaySlot() const {
 359     return Flags & (1 << TID::DelaySlot);
 360   }
 361
 362   /// canFoldAsLoad - Return true for instructions that can be folded as
 363   /// memory operands in other instructions. The most common use for this
 364   /// is instructions that are simple loads from memory that don't modify
 365   /// the loaded value in any way, but it can also be used for instructions
 366   /// that can be expressed as constant-pool loads, such as V_SETALLONES
 367   /// on x86, to allow them to be folded when it is beneficial.
 368   /// This should only be set on instructions that return a value in their
 369   /// only virtual register definition.
 370   bool canFoldAsLoad() const {
 371     return Flags & (1 << TID::FoldableAsLoad);
 372   }
 373
 374   //===--------------------------------------------------------------------===//
 375   // Side Effect Analysis
 376   //===--------------------------------------------------------------------===//
 377
 378   /// mayLoad - Return true if this instruction could possibly read memory.
 379   /// Instructions with this flag set are not necessarily simple load
 380   /// instructions, they may load a value and modify it, for example.
 381   bool mayLoad() const {
 382     return Flags & (1 << TID::MayLoad);
 383   }
 384
 385
 386   /// mayStore - Return true if this instruction could possibly modify memory.
 387   /// Instructions with this flag set are not necessarily simple store
 388   /// instructions, they may store a modified value based on their operands, or
 389   /// may not actually modify anything, for example.
 390   bool mayStore() const {
 391     return Flags & (1 << TID::MayStore);
 392   }
 393
 394   /// hasUnmodeledSideEffects - Return true if this instruction has side
 395   /// effects that are not modeled by other flags.  This does not return true
 396   /// for instructions whose effects are captured by:
 397   ///
 398   ///  1. Their operand list and implicit definition/use list.  Register use/def
 399   ///     info is explicit for instructions.
 400   ///  2. Memory accesses.  Use mayLoad/mayStore.
 401   ///  3. Calling, branching, returning: use isCall/isReturn/isBranch.
 402   ///
 403   /// Examples of side effects would be modifying 'invisible' machine state like
 404   /// a control register, flushing a cache, modifying a register invisible to
 405   /// LLVM, etc.
 406   ///
 407   bool hasUnmodeledSideEffects() const {
 408     return Flags & (1 << TID::UnmodeledSideEffects);
 409   }
 410
 411   //===--------------------------------------------------------------------===//
 412   // Flags that indicate whether an instruction can be modified by a method.
 413   //===--------------------------------------------------------------------===//
 414
 415   /// isCommutable - Return true if this may be a 2- or 3-address
 416   /// instruction (of the form "X = op Y, Z, ..."), which produces the same
 417   /// result if Y and Z are exchanged.  If this flag is set, then the
 418   /// TargetInstrInfo::commuteInstruction method may be used to hack on the
 419   /// instruction.
 420   ///
 421   /// Note that this flag may be set on instructions that are only commutable
 422   /// sometimes.  In these cases, the call to commuteInstruction will fail.
 423   /// Also note that some instructions require non-trivial modification to
 424   /// commute them.
 425   bool isCommutable() const {
 426     return Flags & (1 << TID::Commutable);
 427   }
 428
 429   /// isConvertibleTo3Addr - Return true if this is a 2-address instruction
 430   /// which can be changed into a 3-address instruction if needed.  Doing this
 431   /// transformation can be profitable in the register allocator, because it
 432   /// means that the instruction can use a 2-address form if possible, but
 433   /// degrade into a less efficient form if the source and dest register cannot
 434   /// be assigned to the same register.  For example, this allows the x86
 435   /// backend to turn a "shl reg, 3" instruction into an LEA instruction, which
 436   /// is the same speed as the shift but has bigger code size.
 437   ///
 438   /// If this returns true, then the target must implement the
 439   /// TargetInstrInfo::convertToThreeAddress method for this instruction, which
 440   /// is allowed to fail if the transformation isn't valid for this specific
 441   /// instruction (e.g. shl reg, 4 on x86).
 442   ///
 443   bool isConvertibleTo3Addr() const {
 444     return Flags & (1 << TID::ConvertibleTo3Addr);
 445   }
 446
 447   /// usesCustomInsertionHook - Return true if this instruction requires
 448   /// custom insertion support when the DAG scheduler is inserting it into a
 449   /// machine basic block.  If this is true for the instruction, it basically
 450   /// means that it is a pseudo instruction used at SelectionDAG time that is
 451   /// expanded out into magic code by the target when MachineInstrs are formed.
 452   ///
 453   /// If this is true, the TargetLoweringInfo::InsertAtEndOfBasicBlock method
 454   /// is used to insert this into the MachineBasicBlock.
 455   bool usesCustomInsertionHook() const {
 456     return Flags & (1 << TID::UsesCustomInserter);
 457   }
 458
 459   /// isRematerializable - Returns true if this instruction is a candidate for
 460   /// remat.  This flag is deprecated, please don't use it anymore.  If this
 461   /// flag is set, the isReallyTriviallyReMaterializable() method is called to
 462   /// verify the instruction is really rematable.
 463   bool isRematerializable() const {
 464     return Flags & (1 << TID::Rematerializable);
 465   }
 466
 467   /// isAsCheapAsAMove - Returns true if this instruction has the same cost (or
 468   /// less) than a move instruction. This is useful during certain types of
 469   /// optimizations (e.g., remat during two-address conversion or machine licm)
 470   /// where we would like to remat or hoist the instruction, but not if it costs
 471   /// more than moving the instruction into the appropriate register. Note, we
 472   /// are not marking copies from and to the same register class with this flag.
 473   bool isAsCheapAsAMove() const {
 474     return Flags & (1 << TID::CheapAsAMove);
 475   }
 476
 477   /// hasExtraSrcRegAllocReq - Returns true if this instruction source operands
 478   /// have special register allocation requirements that are not captured by the
 479   /// operand register classes. e.g. ARM::STRD's two source registers must be an
 480   /// even / odd pair, ARM::STM registers have to be in ascending order.
 481   /// Post-register allocation passes should not attempt to change allocations
 482   /// for sources of instructions with this flag.
 483   bool hasExtraSrcRegAllocReq() const {
 484     return Flags & (1 << TID::ExtraSrcRegAllocReq);
 485   }
 486
 487   /// hasExtraDefRegAllocReq - Returns true if this instruction def operands
 488   /// have special register allocation requirements that are not captured by the
 489   /// operand register classes. e.g. ARM::LDRD's two def registers must be an
 490   /// even / odd pair, ARM::LDM registers have to be in ascending order.
 491   /// Post-register allocation passes should not attempt to change allocations
 492   /// for definitions of instructions with this flag.
 493   bool hasExtraDefRegAllocReq() const {
 494     return Flags & (1 << TID::ExtraDefRegAllocReq);
 495   }
 496 };
 497
 498 } // end namespace llvm
 499
 500 #endif