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