LCOV - code coverage report
Current view: top level - include/llvm/MC - MCInstrDesc.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 40 42 95.2 %
Date: 2018-07-13 00:08:38 Functions: 0 0 -
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===-- llvm/MC/MCInstrDesc.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 MCOperandInfo and MCInstrDesc classes, which
      11             : // are used to describe target instructions and their operands.
      12             : //
      13             : //===----------------------------------------------------------------------===//
      14             : 
      15             : #ifndef LLVM_MC_MCINSTRDESC_H
      16             : #define LLVM_MC_MCINSTRDESC_H
      17             : 
      18             : #include "llvm/MC/MCRegisterInfo.h"
      19             : #include "llvm/Support/DataTypes.h"
      20             : #include <string>
      21             : 
      22             : namespace llvm {
      23             :   class MCInst;
      24             :   class MCSubtargetInfo;
      25             :   class FeatureBitset;
      26             : 
      27             : //===----------------------------------------------------------------------===//
      28             : // Machine Operand Flags and Description
      29             : //===----------------------------------------------------------------------===//
      30             : 
      31             : namespace MCOI {
      32             : // Operand constraints
      33             : enum OperandConstraint {
      34             :   TIED_TO = 0,  // Must be allocated the same register as.
      35             :   EARLY_CLOBBER // Operand is an early clobber register operand
      36             : };
      37             : 
      38             : /// These are flags set on operands, but should be considered
      39             : /// private, all access should go through the MCOperandInfo accessors.
      40             : /// See the accessors for a description of what these are.
      41             : enum OperandFlags { LookupPtrRegClass = 0, Predicate, OptionalDef };
      42             : 
      43             : /// Operands are tagged with one of the values of this enum.
      44             : enum OperandType {
      45             :   OPERAND_UNKNOWN = 0,
      46             :   OPERAND_IMMEDIATE = 1,
      47             :   OPERAND_REGISTER = 2,
      48             :   OPERAND_MEMORY = 3,
      49             :   OPERAND_PCREL = 4,
      50             : 
      51             :   OPERAND_FIRST_GENERIC = 6,
      52             :   OPERAND_GENERIC_0 = 6,
      53             :   OPERAND_GENERIC_1 = 7,
      54             :   OPERAND_GENERIC_2 = 8,
      55             :   OPERAND_GENERIC_3 = 9,
      56             :   OPERAND_GENERIC_4 = 10,
      57             :   OPERAND_GENERIC_5 = 11,
      58             :   OPERAND_LAST_GENERIC = 11,
      59             : 
      60             :   OPERAND_FIRST_TARGET = 12,
      61             : };
      62             : 
      63             : }
      64             : 
      65             : /// This holds information about one operand of a machine instruction,
      66             : /// indicating the register class for register operands, etc.
      67             : class MCOperandInfo {
      68             : public:
      69             :   /// This specifies the register class enumeration of the operand
      70             :   /// if the operand is a register.  If isLookupPtrRegClass is set, then this is
      71             :   /// an index that is passed to TargetRegisterInfo::getPointerRegClass(x) to
      72             :   /// get a dynamic register class.
      73             :   int16_t RegClass;
      74             : 
      75             :   /// These are flags from the MCOI::OperandFlags enum.
      76             :   uint8_t Flags;
      77             : 
      78             :   /// Information about the type of the operand.
      79             :   uint8_t OperandType;
      80             :   /// The lower 16 bits are used to specify which constraints are set.
      81             :   /// The higher 16 bits are used to specify the value of constraints (4 bits
      82             :   /// each).
      83             :   uint32_t Constraints;
      84             : 
      85             :   /// Set if this operand is a pointer value and it requires a callback
      86             :   /// to look up its register class.
      87             :   bool isLookupPtrRegClass() const {
      88             :     return Flags & (1 << MCOI::LookupPtrRegClass);
      89             :   }
      90             : 
      91             :   /// Set if this is one of the operands that made up of the predicate
      92             :   /// operand that controls an isPredicable() instruction.
      93             :   bool isPredicate() const { return Flags & (1 << MCOI::Predicate); }
      94             : 
      95             :   /// Set if this operand is a optional def.
      96             :   bool isOptionalDef() const { return Flags & (1 << MCOI::OptionalDef); }
      97             : 
      98             :   bool isGenericType() const {
      99      146483 :     return OperandType >= MCOI::OPERAND_FIRST_GENERIC &&
     100             :            OperandType <= MCOI::OPERAND_LAST_GENERIC;
     101             :   }
     102             : 
     103             :   unsigned getGenericTypeIndex() const {
     104             :     assert(isGenericType() && "non-generic types don't have an index");
     105       42145 :     return OperandType - MCOI::OPERAND_FIRST_GENERIC;
     106             :   }
     107             : };
     108             : 
     109             : //===----------------------------------------------------------------------===//
     110             : // Machine Instruction Flags and Description
     111             : //===----------------------------------------------------------------------===//
     112             : 
     113             : namespace MCID {
     114             : /// These should be considered private to the implementation of the
     115             : /// MCInstrDesc class.  Clients should use the predicate methods on MCInstrDesc,
     116             : /// not use these directly.  These all correspond to bitfields in the
     117             : /// MCInstrDesc::Flags field.
     118             : enum Flag {
     119             :   Variadic = 0,
     120             :   HasOptionalDef,
     121             :   Pseudo,
     122             :   Return,
     123             :   Call,
     124             :   Barrier,
     125             :   Terminator,
     126             :   Branch,
     127             :   IndirectBranch,
     128             :   Compare,
     129             :   MoveImm,
     130             :   MoveReg,
     131             :   Bitcast,
     132             :   Select,
     133             :   DelaySlot,
     134             :   FoldableAsLoad,
     135             :   MayLoad,
     136             :   MayStore,
     137             :   Predicable,
     138             :   NotDuplicable,
     139             :   UnmodeledSideEffects,
     140             :   Commutable,
     141             :   ConvertibleTo3Addr,
     142             :   UsesCustomInserter,
     143             :   HasPostISelHook,
     144             :   Rematerializable,
     145             :   CheapAsAMove,
     146             :   ExtraSrcRegAllocReq,
     147             :   ExtraDefRegAllocReq,
     148             :   RegSequence,
     149             :   ExtractSubreg,
     150             :   InsertSubreg,
     151             :   Convergent,
     152             :   Add
     153             : };
     154             : }
     155             : 
     156             : /// Describe properties that are true of each instruction in the target
     157             : /// description file.  This captures information about side effects, register
     158             : /// use and many other things.  There is one instance of this struct for each
     159             : /// target instruction class, and the MachineInstr class points to this struct
     160             : /// directly to describe itself.
     161             : class MCInstrDesc {
     162             : public:
     163             :   unsigned short Opcode;         // The opcode number
     164             :   unsigned short NumOperands;    // Num of args (may be more if variable_ops)
     165             :   unsigned char NumDefs;         // Num of args that are definitions
     166             :   unsigned char Size;            // Number of bytes in encoding.
     167             :   unsigned short SchedClass;     // enum identifying instr sched class
     168             :   uint64_t Flags;                // Flags identifying machine instr class
     169             :   uint64_t TSFlags;              // Target Specific Flag values
     170             :   const MCPhysReg *ImplicitUses; // Registers implicitly read by this instr
     171             :   const MCPhysReg *ImplicitDefs; // Registers implicitly defined by this instr
     172             :   const MCOperandInfo *OpInfo;   // 'NumOperands' entries about operands
     173             :   // Subtarget feature that this is deprecated on, if any
     174             :   // -1 implies this is not deprecated by any single feature. It may still be
     175             :   // deprecated due to a "complex" reason, below.
     176             :   int64_t DeprecatedFeature;
     177             : 
     178             :   // A complex method to determine if a certain instruction is deprecated or
     179             :   // not, and return the reason for deprecation.
     180             :   bool (*ComplexDeprecationInfo)(MCInst &, const MCSubtargetInfo &,
     181             :                                  std::string &);
     182             : 
     183             :   /// Returns the value of the specific constraint if
     184             :   /// it is set. Returns -1 if it is not set.
     185             :   int getOperandConstraint(unsigned OpNum,
     186             :                            MCOI::OperandConstraint Constraint) const {
     187   184843942 :     if (OpNum < NumOperands &&
     188    92108772 :         (OpInfo[OpNum].Constraints & (1 << Constraint))) {
     189             :       unsigned Pos = 16 + Constraint * 4;
     190     1604091 :       return (int)(OpInfo[OpNum].Constraints >> Pos) & 0xf;
     191             :     }
     192             :     return -1;
     193             :   }
     194             : 
     195             :   /// Returns true if a certain instruction is deprecated and if so
     196             :   /// returns the reason in \p Info.
     197             :   bool getDeprecatedInfo(MCInst &MI, const MCSubtargetInfo &STI,
     198             :                          std::string &Info) const;
     199             : 
     200             :   /// Return the opcode number for this descriptor.
     201    33486032 :   unsigned getOpcode() const { return Opcode; }
     202             : 
     203             :   /// Return the number of declared MachineOperands for this
     204             :   /// MachineInstruction.  Note that variadic (isVariadic() returns true)
     205             :   /// instructions may have additional operands at the end of the list, and note
     206             :   /// that the machine instruction may include implicit register def/uses as
     207             :   /// well.
     208   277299019 :   unsigned getNumOperands() const { return NumOperands; }
     209             : 
     210             :   using const_opInfo_iterator = const MCOperandInfo *;
     211             : 
     212             :   const_opInfo_iterator opInfo_begin() const { return OpInfo; }
     213          94 :   const_opInfo_iterator opInfo_end() const { return OpInfo + NumOperands; }
     214             : 
     215             :   iterator_range<const_opInfo_iterator> operands() const {
     216          94 :     return make_range(opInfo_begin(), opInfo_end());
     217             :   }
     218             : 
     219             :   /// Return the number of MachineOperands that are register
     220             :   /// definitions.  Register definitions always occur at the start of the
     221             :   /// machine operand list.  This is the number of "outs" in the .td file,
     222             :   /// and does not include implicit defs.
     223   119747243 :   unsigned getNumDefs() const { return NumDefs; }
     224             : 
     225             :   /// Return flags of this instruction.
     226             :   uint64_t getFlags() const { return Flags; }
     227             : 
     228             :   /// Return true if this instruction can have a variable number of
     229             :   /// operands.  In this case, the variable operands will be after the normal
     230             :   /// operands but before the implicit definitions and uses (if any are
     231             :   /// present).
     232    29598928 :   bool isVariadic() const { return Flags & (1ULL << MCID::Variadic); }
     233             : 
     234             :   /// Set if this instruction has an optional definition, e.g.
     235             :   /// ARM instructions which can set condition code if 's' bit is set.
     236      743093 :   bool hasOptionalDef() const { return Flags & (1ULL << MCID::HasOptionalDef); }
     237             : 
     238             :   /// Return true if this is a pseudo instruction that doesn't
     239             :   /// correspond to a real machine instruction.
     240        3961 :   bool isPseudo() const { return Flags & (1ULL << MCID::Pseudo); }
     241             : 
     242             :   /// Return true if the instruction is a return.
     243      272147 :   bool isReturn() const { return Flags & (1ULL << MCID::Return); }
     244             : 
     245             :   /// Return true if the instruction is an add instruction.
     246        1590 :   bool isAdd() const { return Flags & (1ULL << MCID::Add); }
     247             : 
     248             :   /// Return true if the instruction is a register to register move.
     249             :   bool isMoveReg() const { return Flags & (1ULL << MCID::MoveReg); }
     250             : 
     251             :   ///  Return true if the instruction is a call.
     252     8696980 :   bool isCall() const { return Flags & (1ULL << MCID::Call); }
     253             : 
     254             :   /// Returns true if the specified instruction stops control flow
     255             :   /// from executing the instruction immediately following it.  Examples include
     256             :   /// unconditional branches and return instructions.
     257      689398 :   bool isBarrier() const { return Flags & (1ULL << MCID::Barrier); }
     258             : 
     259             :   /// Returns true if this instruction part of the terminator for
     260             :   /// a basic block.  Typically this is things like return and branch
     261             :   /// instructions.
     262             :   ///
     263             :   /// Various passes use this to insert code into the bottom of a basic block,
     264             :   /// but before control flow occurs.
     265      125640 :   bool isTerminator() const { return Flags & (1ULL << MCID::Terminator); }
     266             : 
     267             :   /// Returns true if this is a conditional, unconditional, or
     268             :   /// indirect branch.  Predicates below can be used to discriminate between
     269             :   /// these cases, and the TargetInstrInfo::AnalyzeBranch method can be used to
     270             :   /// get more information.
     271      752295 :   bool isBranch() const { return Flags & (1ULL << MCID::Branch); }
     272             : 
     273             :   /// Return true if this is an indirect branch, such as a
     274             :   /// branch through a register.
     275      690317 :   bool isIndirectBranch() const { return Flags & (1ULL << MCID::IndirectBranch); }
     276             : 
     277             :   /// Return true if this is a branch which may fall
     278             :   /// through to the next instruction or may transfer control flow to some other
     279             :   /// block.  The TargetInstrInfo::AnalyzeBranch method can be used to get more
     280             :   /// information about this branch.
     281             :   bool isConditionalBranch() const {
     282     1026500 :     return isBranch() & !isBarrier() & !isIndirectBranch();
     283             :   }
     284             : 
     285             :   /// Return true if this is a branch which always
     286             :   /// transfers control flow to some other block.  The
     287             :   /// TargetInstrInfo::AnalyzeBranch method can be used to get more information
     288             :   /// about this branch.
     289             :   bool isUnconditionalBranch() const {
     290      694492 :     return isBranch() & isBarrier() & !isIndirectBranch();
     291             :   }
     292             : 
     293             :   /// Return true if this is a branch or an instruction which directly
     294             :   /// writes to the program counter. Considered 'may' affect rather than
     295             :   /// 'does' affect as things like predication are not taken into account.
     296             :   bool mayAffectControlFlow(const MCInst &MI, const MCRegisterInfo &RI) const;
     297             : 
     298             :   /// Return true if this instruction has a predicate operand
     299             :   /// that controls execution. It may be set to 'always', or may be set to other
     300             :   /// values. There are various methods in TargetInstrInfo that can be used to
     301             :   /// control and modify the predicate in this instruction.
     302     1190929 :   bool isPredicable() const { return Flags & (1ULL << MCID::Predicable); }
     303             : 
     304             :   /// Return true if this instruction is a comparison.
     305             :   bool isCompare() const { return Flags & (1ULL << MCID::Compare); }
     306             : 
     307             :   /// Return true if this instruction is a move immediate
     308             :   /// (including conditional moves) instruction.
     309             :   bool isMoveImmediate() const { return Flags & (1ULL << MCID::MoveImm); }
     310             : 
     311             :   /// Return true if this instruction is a bitcast instruction.
     312             :   bool isBitcast() const { return Flags & (1ULL << MCID::Bitcast); }
     313             : 
     314             :   /// Return true if this is a select instruction.
     315             :   bool isSelect() const { return Flags & (1ULL << MCID::Select); }
     316             : 
     317             :   /// Return true if this instruction cannot be safely
     318             :   /// duplicated.  For example, if the instruction has a unique labels attached
     319             :   /// to it, duplicating it would cause multiple definition errors.
     320             :   bool isNotDuplicable() const { return Flags & (1ULL << MCID::NotDuplicable); }
     321             : 
     322             :   /// Returns true if the specified instruction has a delay slot which
     323             :   /// must be filled by the code generator.
     324       36261 :   bool hasDelaySlot() const { return Flags & (1ULL << MCID::DelaySlot); }
     325             : 
     326             :   /// Return true for instructions that can be folded as memory operands
     327             :   /// in other instructions. The most common use for this is instructions that
     328             :   /// are simple loads from memory that don't modify the loaded value in any
     329             :   /// way, but it can also be used for instructions that can be expressed as
     330             :   /// constant-pool loads, such as V_SETALLONES on x86, to allow them to be
     331             :   /// folded when it is beneficial.  This should only be set on instructions
     332             :   /// that return a value in their only virtual register definition.
     333             :   bool canFoldAsLoad() const { return Flags & (1ULL << MCID::FoldableAsLoad); }
     334             : 
     335             :   /// Return true if this instruction behaves
     336             :   /// the same way as the generic REG_SEQUENCE instructions.
     337             :   /// E.g., on ARM,
     338             :   /// dX VMOVDRR rY, rZ
     339             :   /// is equivalent to
     340             :   /// dX = REG_SEQUENCE rY, ssub_0, rZ, ssub_1.
     341             :   ///
     342             :   /// Note that for the optimizers to be able to take advantage of
     343             :   /// this property, TargetInstrInfo::getRegSequenceLikeInputs has to be
     344             :   /// override accordingly.
     345             :   bool isRegSequenceLike() const { return Flags & (1ULL << MCID::RegSequence); }
     346             : 
     347             :   /// Return true if this instruction behaves
     348             :   /// the same way as the generic EXTRACT_SUBREG instructions.
     349             :   /// E.g., on ARM,
     350             :   /// rX, rY VMOVRRD dZ
     351             :   /// is equivalent to two EXTRACT_SUBREG:
     352             :   /// rX = EXTRACT_SUBREG dZ, ssub_0
     353             :   /// rY = EXTRACT_SUBREG dZ, ssub_1
     354             :   ///
     355             :   /// Note that for the optimizers to be able to take advantage of
     356             :   /// this property, TargetInstrInfo::getExtractSubregLikeInputs has to be
     357             :   /// override accordingly.
     358             :   bool isExtractSubregLike() const {
     359             :     return Flags & (1ULL << MCID::ExtractSubreg);
     360             :   }
     361             : 
     362             :   /// Return true if this instruction behaves
     363             :   /// the same way as the generic INSERT_SUBREG instructions.
     364             :   /// E.g., on ARM,
     365             :   /// dX = VSETLNi32 dY, rZ, Imm
     366             :   /// is equivalent to a INSERT_SUBREG:
     367             :   /// dX = INSERT_SUBREG dY, rZ, translateImmToSubIdx(Imm)
     368             :   ///
     369             :   /// Note that for the optimizers to be able to take advantage of
     370             :   /// this property, TargetInstrInfo::getInsertSubregLikeInputs has to be
     371             :   /// override accordingly.
     372             :   bool isInsertSubregLike() const { return Flags & (1ULL << MCID::InsertSubreg); }
     373             : 
     374             : 
     375             :   /// Return true if this instruction is convergent.
     376             :   ///
     377             :   /// Convergent instructions may not be made control-dependent on any
     378             :   /// additional values.
     379             :   bool isConvergent() const { return Flags & (1ULL << MCID::Convergent); }
     380             : 
     381             :   //===--------------------------------------------------------------------===//
     382             :   // Side Effect Analysis
     383             :   //===--------------------------------------------------------------------===//
     384             : 
     385             :   /// Return true if this instruction could possibly read memory.
     386             :   /// Instructions with this flag set are not necessarily simple load
     387             :   /// instructions, they may load a value and modify it, for example.
     388     4938883 :   bool mayLoad() const { return Flags & (1ULL << MCID::MayLoad); }
     389             : 
     390             :   /// Return true if this instruction could possibly modify memory.
     391             :   /// Instructions with this flag set are not necessarily simple store
     392             :   /// instructions, they may store a modified value based on their operands, or
     393             :   /// may not actually modify anything, for example.
     394     1111950 :   bool mayStore() const { return Flags & (1ULL << MCID::MayStore); }
     395             : 
     396             :   /// Return true if this instruction has side
     397             :   /// effects that are not modeled by other flags.  This does not return true
     398             :   /// for instructions whose effects are captured by:
     399             :   ///
     400             :   ///  1. Their operand list and implicit definition/use list.  Register use/def
     401             :   ///     info is explicit for instructions.
     402             :   ///  2. Memory accesses.  Use mayLoad/mayStore.
     403             :   ///  3. Calling, branching, returning: use isCall/isReturn/isBranch.
     404             :   ///
     405             :   /// Examples of side effects would be modifying 'invisible' machine state like
     406             :   /// a control register, flushing a cache, modifying a register invisible to
     407             :   /// LLVM, etc.
     408             :   bool hasUnmodeledSideEffects() const {
     409       48961 :     return Flags & (1ULL << MCID::UnmodeledSideEffects);
     410             :   }
     411             : 
     412             :   //===--------------------------------------------------------------------===//
     413             :   // Flags that indicate whether an instruction can be modified by a method.
     414             :   //===--------------------------------------------------------------------===//
     415             : 
     416             :   /// Return true if this may be a 2- or 3-address instruction (of the
     417             :   /// form "X = op Y, Z, ..."), which produces the same result if Y and Z are
     418             :   /// exchanged.  If this flag is set, then the
     419             :   /// TargetInstrInfo::commuteInstruction method may be used to hack on the
     420             :   /// instruction.
     421             :   ///
     422             :   /// Note that this flag may be set on instructions that are only commutable
     423             :   /// sometimes.  In these cases, the call to commuteInstruction will fail.
     424             :   /// Also note that some instructions require non-trivial modification to
     425             :   /// commute them.
     426     3656417 :   bool isCommutable() const { return Flags & (1ULL << MCID::Commutable); }
     427             : 
     428             :   /// Return true if this is a 2-address instruction which can be changed
     429             :   /// into a 3-address instruction if needed.  Doing this transformation can be
     430             :   /// profitable in the register allocator, because it means that the
     431             :   /// instruction can use a 2-address form if possible, but degrade into a less
     432             :   /// efficient form if the source and dest register cannot be assigned to the
     433             :   /// same register.  For example, this allows the x86 backend to turn a "shl
     434             :   /// reg, 3" instruction into an LEA instruction, which is the same speed as
     435             :   /// the shift but has bigger code size.
     436             :   ///
     437             :   /// If this returns true, then the target must implement the
     438             :   /// TargetInstrInfo::convertToThreeAddress method for this instruction, which
     439             :   /// is allowed to fail if the transformation isn't valid for this specific
     440             :   /// instruction (e.g. shl reg, 4 on x86).
     441             :   ///
     442             :   bool isConvertibleTo3Addr() const {
     443             :     return Flags & (1ULL << MCID::ConvertibleTo3Addr);
     444             :   }
     445             : 
     446             :   /// Return true if this instruction requires custom insertion support
     447             :   /// when the DAG scheduler is inserting it into a machine basic block.  If
     448             :   /// this is true for the instruction, it basically means that it is a pseudo
     449             :   /// instruction used at SelectionDAG time that is expanded out into magic code
     450             :   /// by the target when MachineInstrs are formed.
     451             :   ///
     452             :   /// If this is true, the TargetLoweringInfo::InsertAtEndOfBasicBlock method
     453             :   /// is used to insert this into the MachineBasicBlock.
     454             :   bool usesCustomInsertionHook() const {
     455             :     return Flags & (1ULL << MCID::UsesCustomInserter);
     456             :   }
     457             : 
     458             :   /// Return true if this instruction requires *adjustment* after
     459             :   /// instruction selection by calling a target hook. For example, this can be
     460             :   /// used to fill in ARM 's' optional operand depending on whether the
     461             :   /// conditional flag register is used.
     462     2837642 :   bool hasPostISelHook() const { return Flags & (1ULL << MCID::HasPostISelHook); }
     463             : 
     464             :   /// Returns true if this instruction is a candidate for remat. This
     465             :   /// flag is only used in TargetInstrInfo method isTriviallyRematerializable.
     466             :   ///
     467             :   /// If this flag is set, the isReallyTriviallyReMaterializable()
     468             :   /// or isReallyTriviallyReMaterializableGeneric methods are called to verify
     469             :   /// the instruction is really rematable.
     470             :   bool isRematerializable() const {
     471      842040 :     return Flags & (1ULL << MCID::Rematerializable);
     472             :   }
     473             : 
     474             :   /// Returns true if this instruction has the same cost (or less) than a
     475             :   /// move instruction. This is useful during certain types of optimizations
     476             :   /// (e.g., remat during two-address conversion or machine licm) where we would
     477             :   /// like to remat or hoist the instruction, but not if it costs more than
     478             :   /// moving the instruction into the appropriate register. Note, we are not
     479             :   /// marking copies from and to the same register class with this flag.
     480             :   ///
     481             :   /// This method could be called by interface TargetInstrInfo::isAsCheapAsAMove
     482             :   /// for different subtargets.
     483             :   bool isAsCheapAsAMove() const { return Flags & (1ULL << MCID::CheapAsAMove); }
     484             : 
     485             :   /// Returns true if this instruction source operands have special
     486             :   /// register allocation requirements that are not captured by the operand
     487             :   /// register classes. e.g. ARM::STRD's two source registers must be an even /
     488             :   /// odd pair, ARM::STM registers have to be in ascending order.  Post-register
     489             :   /// allocation passes should not attempt to change allocations for sources of
     490             :   /// instructions with this flag.
     491             :   bool hasExtraSrcRegAllocReq() const {
     492             :     return Flags & (1ULL << MCID::ExtraSrcRegAllocReq);
     493             :   }
     494             : 
     495             :   /// Returns true if this instruction def operands have special register
     496             :   /// allocation requirements that are not captured by the operand register
     497             :   /// classes. e.g. ARM::LDRD's two def registers must be an even / odd pair,
     498             :   /// ARM::LDM registers have to be in ascending order.  Post-register
     499             :   /// allocation passes should not attempt to change allocations for definitions
     500             :   /// of instructions with this flag.
     501             :   bool hasExtraDefRegAllocReq() const {
     502             :     return Flags & (1ULL << MCID::ExtraDefRegAllocReq);
     503             :   }
     504             : 
     505             :   /// Return a list of registers that are potentially read by any
     506             :   /// instance of this machine instruction.  For example, on X86, the "adc"
     507             :   /// instruction adds two register operands and adds the carry bit in from the
     508             :   /// flags register.  In this case, the instruction is marked as implicitly
     509             :   /// reading the flags.  Likewise, the variable shift instruction on X86 is
     510             :   /// marked as implicitly reading the 'CL' register, which it always does.
     511             :   ///
     512             :   /// This method returns null if the instruction has no implicit uses.
     513             :   const MCPhysReg *getImplicitUses() const { return ImplicitUses; }
     514             : 
     515             :   /// Return the number of implicit uses this instruction has.
     516             :   unsigned getNumImplicitUses() const {
     517     8336027 :     if (!ImplicitUses)
     518             :       return 0;
     519             :     unsigned i = 0;
     520     4459555 :     for (; ImplicitUses[i]; ++i) /*empty*/
     521             :       ;
     522             :     return i;
     523             :   }
     524             : 
     525             :   /// Return a list of registers that are potentially written by any
     526             :   /// instance of this machine instruction.  For example, on X86, many
     527             :   /// instructions implicitly set the flags register.  In this case, they are
     528             :   /// marked as setting the FLAGS.  Likewise, many instructions always deposit
     529             :   /// their result in a physical register.  For example, the X86 divide
     530             :   /// instruction always deposits the quotient and remainder in the EAX/EDX
     531             :   /// registers.  For that instruction, this will return a list containing the
     532             :   /// EAX/EDX/EFLAGS registers.
     533             :   ///
     534             :   /// This method returns null if the instruction has no implicit defs.
     535             :   const MCPhysReg *getImplicitDefs() const { return ImplicitDefs; }
     536             : 
     537             :   /// Return the number of implicit defs this instruct has.
     538             :   unsigned getNumImplicitDefs() const {
     539     8139507 :     if (!ImplicitDefs)
     540             :       return 0;
     541             :     unsigned i = 0;
     542     3470337 :     for (; ImplicitDefs[i]; ++i) /*empty*/
     543             :       ;
     544             :     return i;
     545             :   }
     546             : 
     547             :   /// Return true if this instruction implicitly
     548             :   /// uses the specified physical register.
     549             :   bool hasImplicitUseOfPhysReg(unsigned Reg) const {
     550         281 :     if (const MCPhysReg *ImpUses = ImplicitUses)
     551           0 :       for (; *ImpUses; ++ImpUses)
     552           0 :         if (*ImpUses == Reg)
     553             :           return true;
     554             :     return false;
     555             :   }
     556             : 
     557             :   /// Return true if this instruction implicitly
     558             :   /// defines the specified physical register.
     559             :   bool hasImplicitDefOfPhysReg(unsigned Reg,
     560             :                                const MCRegisterInfo *MRI = nullptr) const;
     561             : 
     562             :   /// Return the scheduling class for this instruction.  The
     563             :   /// scheduling class is an index into the InstrItineraryData table.  This
     564             :   /// returns zero if there is no known scheduling information for the
     565             :   /// instruction.
     566    15733777 :   unsigned getSchedClass() const { return SchedClass; }
     567             : 
     568             :   /// Return the number of bytes in the encoding of this instruction,
     569             :   /// or zero if the encoding size cannot be known from the opcode.
     570     2288574 :   unsigned getSize() const { return Size; }
     571             : 
     572             :   /// Find the index of the first operand in the
     573             :   /// operand list that is used to represent the predicate. It returns -1 if
     574             :   /// none is found.
     575             :   int findFirstPredOperandIdx() const {
     576             :     if (isPredicable()) {
     577       75904 :       for (unsigned i = 0, e = getNumOperands(); i != e; ++i)
     578       37952 :         if (OpInfo[i].isPredicate())
     579        9726 :           return i;
     580             :     }
     581             :     return -1;
     582             :   }
     583             : 
     584             :   /// Return true if this instruction defines the specified physical
     585             :   /// register, either explicitly or implicitly.
     586             :   bool hasDefOfPhysReg(const MCInst &MI, unsigned Reg,
     587             :                        const MCRegisterInfo &RI) const;
     588             : };
     589             : 
     590             : } // end namespace llvm
     591             : 
     592             : #endif

Generated by: LCOV version 1.13