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