[InstCombine] Signed saturation tests. NFC
[llvm-complete.git] / include / llvm / Target / Target.td
blobdd8679661b9aca19485aa3f6e8b92c95971d34cc
1 //===- Target.td - Target Independent TableGen interface ---*- tablegen -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file defines the target-independent interfaces which should be
10 // implemented by each target which is using a TableGen based code generator.
12 //===----------------------------------------------------------------------===//
14 // Include all information about LLVM intrinsics.
15 include "llvm/IR/Intrinsics.td"
17 //===----------------------------------------------------------------------===//
18 // Register file description - These classes are used to fill in the target
19 // description classes.
21 class RegisterClass; // Forward def
23 class HwMode<string FS> {
24   // A string representing subtarget features that turn on this HW mode.
25   // For example, "+feat1,-feat2" will indicate that the mode is active
26   // when "feat1" is enabled and "feat2" is disabled at the same time.
27   // Any other features are not checked.
28   // When multiple modes are used, they should be mutually exclusive,
29   // otherwise the results are unpredictable.
30   string Features = FS;
33 // A special mode recognized by tablegen. This mode is considered active
34 // when no other mode is active. For targets that do not use specific hw
35 // modes, this is the only mode.
36 def DefaultMode : HwMode<"">;
38 // A class used to associate objects with HW modes. It is only intended to
39 // be used as a base class, where the derived class should contain a member
40 // "Objects", which is a list of the same length as the list of modes.
41 // The n-th element on the Objects list will be associated with the n-th
42 // element on the Modes list.
43 class HwModeSelect<list<HwMode> Ms> {
44   list<HwMode> Modes = Ms;
47 // A common class that implements a counterpart of ValueType, which is
48 // dependent on a HW mode. This class inherits from ValueType itself,
49 // which makes it possible to use objects of this class where ValueType
50 // objects could be used. This is specifically applicable to selection
51 // patterns.
52 class ValueTypeByHwMode<list<HwMode> Ms, list<ValueType> Ts>
53     : HwModeSelect<Ms>, ValueType<0, 0> {
54   // The length of this list must be the same as the length of Ms.
55   list<ValueType> Objects = Ts;
58 // A class representing the register size, spill size and spill alignment
59 // in bits of a register.
60 class RegInfo<int RS, int SS, int SA> {
61   int RegSize = RS;         // Register size in bits.
62   int SpillSize = SS;       // Spill slot size in bits.
63   int SpillAlignment = SA;  // Spill slot alignment in bits.
66 // The register size/alignment information, parameterized by a HW mode.
67 class RegInfoByHwMode<list<HwMode> Ms = [], list<RegInfo> Ts = []>
68     : HwModeSelect<Ms> {
69   // The length of this list must be the same as the length of Ms.
70   list<RegInfo> Objects = Ts;
73 // SubRegIndex - Use instances of SubRegIndex to identify subregisters.
74 class SubRegIndex<int size, int offset = 0> {
75   string Namespace = "";
77   // Size - Size (in bits) of the sub-registers represented by this index.
78   int Size = size;
80   // Offset - Offset of the first bit that is part of this sub-register index.
81   // Set it to -1 if the same index is used to represent sub-registers that can
82   // be at different offsets (for example when using an index to access an
83   // element in a register tuple).
84   int Offset = offset;
86   // ComposedOf - A list of two SubRegIndex instances, [A, B].
87   // This indicates that this SubRegIndex is the result of composing A and B.
88   // See ComposedSubRegIndex.
89   list<SubRegIndex> ComposedOf = [];
91   // CoveringSubRegIndices - A list of two or more sub-register indexes that
92   // cover this sub-register.
93   //
94   // This field should normally be left blank as TableGen can infer it.
95   //
96   // TableGen automatically detects sub-registers that straddle the registers
97   // in the SubRegs field of a Register definition. For example:
98   //
99   //   Q0    = dsub_0 -> D0, dsub_1 -> D1
100   //   Q1    = dsub_0 -> D2, dsub_1 -> D3
101   //   D1_D2 = dsub_0 -> D1, dsub_1 -> D2
102   //   QQ0   = qsub_0 -> Q0, qsub_1 -> Q1
103   //
104   // TableGen will infer that D1_D2 is a sub-register of QQ0. It will be given
105   // the synthetic index dsub_1_dsub_2 unless some SubRegIndex is defined with
106   // CoveringSubRegIndices = [dsub_1, dsub_2].
107   list<SubRegIndex> CoveringSubRegIndices = [];
110 // ComposedSubRegIndex - A sub-register that is the result of composing A and B.
111 // Offset is set to the sum of A and B's Offsets. Size is set to B's Size.
112 class ComposedSubRegIndex<SubRegIndex A, SubRegIndex B>
113   : SubRegIndex<B.Size, !if(!eq(A.Offset, -1), -1,
114                         !if(!eq(B.Offset, -1), -1,
115                             !add(A.Offset, B.Offset)))> {
116   // See SubRegIndex.
117   let ComposedOf = [A, B];
120 // RegAltNameIndex - The alternate name set to use for register operands of
121 // this register class when printing.
122 class RegAltNameIndex {
123   string Namespace = "";
125   // A set to be used if the name for a register is not defined in this set.
126   // This allows creating name sets with only a few alternative names.
127   RegAltNameIndex FallbackRegAltNameIndex = ?;
129 def NoRegAltName : RegAltNameIndex;
131 // Register - You should define one instance of this class for each register
132 // in the target machine.  String n will become the "name" of the register.
133 class Register<string n, list<string> altNames = []> {
134   string Namespace = "";
135   string AsmName = n;
136   list<string> AltNames = altNames;
138   // Aliases - A list of registers that this register overlaps with.  A read or
139   // modification of this register can potentially read or modify the aliased
140   // registers.
141   list<Register> Aliases = [];
143   // SubRegs - A list of registers that are parts of this register. Note these
144   // are "immediate" sub-registers and the registers within the list do not
145   // themselves overlap. e.g. For X86, EAX's SubRegs list contains only [AX],
146   // not [AX, AH, AL].
147   list<Register> SubRegs = [];
149   // SubRegIndices - For each register in SubRegs, specify the SubRegIndex used
150   // to address it. Sub-sub-register indices are automatically inherited from
151   // SubRegs.
152   list<SubRegIndex> SubRegIndices = [];
154   // RegAltNameIndices - The alternate name indices which are valid for this
155   // register.
156   list<RegAltNameIndex> RegAltNameIndices = [];
158   // DwarfNumbers - Numbers used internally by gcc/gdb to identify the register.
159   // These values can be determined by locating the <target>.h file in the
160   // directory llvmgcc/gcc/config/<target>/ and looking for REGISTER_NAMES.  The
161   // order of these names correspond to the enumeration used by gcc.  A value of
162   // -1 indicates that the gcc number is undefined and -2 that register number
163   // is invalid for this mode/flavour.
164   list<int> DwarfNumbers = [];
166   // CostPerUse - Additional cost of instructions using this register compared
167   // to other registers in its class. The register allocator will try to
168   // minimize the number of instructions using a register with a CostPerUse.
169   // This is used by the x86-64 and ARM Thumb targets where some registers
170   // require larger instruction encodings.
171   int CostPerUse = 0;
173   // CoveredBySubRegs - When this bit is set, the value of this register is
174   // completely determined by the value of its sub-registers.  For example, the
175   // x86 register AX is covered by its sub-registers AL and AH, but EAX is not
176   // covered by its sub-register AX.
177   bit CoveredBySubRegs = 0;
179   // HWEncoding - The target specific hardware encoding for this register.
180   bits<16> HWEncoding = 0;
182   bit isArtificial = 0;
185 // RegisterWithSubRegs - This can be used to define instances of Register which
186 // need to specify sub-registers.
187 // List "subregs" specifies which registers are sub-registers to this one. This
188 // is used to populate the SubRegs and AliasSet fields of TargetRegisterDesc.
189 // This allows the code generator to be careful not to put two values with
190 // overlapping live ranges into registers which alias.
191 class RegisterWithSubRegs<string n, list<Register> subregs> : Register<n> {
192   let SubRegs = subregs;
195 // DAGOperand - An empty base class that unifies RegisterClass's and other forms
196 // of Operand's that are legal as type qualifiers in DAG patterns.  This should
197 // only ever be used for defining multiclasses that are polymorphic over both
198 // RegisterClass's and other Operand's.
199 class DAGOperand {
200   string OperandNamespace = "MCOI";
201   string DecoderMethod = "";
204 // RegisterClass - Now that all of the registers are defined, and aliases
205 // between registers are defined, specify which registers belong to which
206 // register classes.  This also defines the default allocation order of
207 // registers by register allocators.
209 class RegisterClass<string namespace, list<ValueType> regTypes, int alignment,
210                     dag regList, RegAltNameIndex idx = NoRegAltName>
211   : DAGOperand {
212   string Namespace = namespace;
214   // The register size/alignment information, parameterized by a HW mode.
215   RegInfoByHwMode RegInfos;
217   // RegType - Specify the list ValueType of the registers in this register
218   // class.  Note that all registers in a register class must have the same
219   // ValueTypes.  This is a list because some targets permit storing different
220   // types in same register, for example vector values with 128-bit total size,
221   // but different count/size of items, like SSE on x86.
222   //
223   list<ValueType> RegTypes = regTypes;
225   // Size - Specify the spill size in bits of the registers.  A default value of
226   // zero lets tablgen pick an appropriate size.
227   int Size = 0;
229   // Alignment - Specify the alignment required of the registers when they are
230   // stored or loaded to memory.
231   //
232   int Alignment = alignment;
234   // CopyCost - This value is used to specify the cost of copying a value
235   // between two registers in this register class. The default value is one
236   // meaning it takes a single instruction to perform the copying. A negative
237   // value means copying is extremely expensive or impossible.
238   int CopyCost = 1;
240   // MemberList - Specify which registers are in this class.  If the
241   // allocation_order_* method are not specified, this also defines the order of
242   // allocation used by the register allocator.
243   //
244   dag MemberList = regList;
246   // AltNameIndex - The alternate register name to use when printing operands
247   // of this register class. Every register in the register class must have
248   // a valid alternate name for the given index.
249   RegAltNameIndex altNameIndex = idx;
251   // isAllocatable - Specify that the register class can be used for virtual
252   // registers and register allocation.  Some register classes are only used to
253   // model instruction operand constraints, and should have isAllocatable = 0.
254   bit isAllocatable = 1;
256   // AltOrders - List of alternative allocation orders. The default order is
257   // MemberList itself, and that is good enough for most targets since the
258   // register allocators automatically remove reserved registers and move
259   // callee-saved registers to the end.
260   list<dag> AltOrders = [];
262   // AltOrderSelect - The body of a function that selects the allocation order
263   // to use in a given machine function. The code will be inserted in a
264   // function like this:
265   //
266   //   static inline unsigned f(const MachineFunction &MF) { ... }
267   //
268   // The function should return 0 to select the default order defined by
269   // MemberList, 1 to select the first AltOrders entry and so on.
270   code AltOrderSelect = [{}];
272   // Specify allocation priority for register allocators using a greedy
273   // heuristic. Classes with higher priority values are assigned first. This is
274   // useful as it is sometimes beneficial to assign registers to highly
275   // constrained classes first. The value has to be in the range [0,63].
276   int AllocationPriority = 0;
278   // The diagnostic type to present when referencing this operand in a match
279   // failure error message. If this is empty, the default Match_InvalidOperand
280   // diagnostic type will be used. If this is "<name>", a Match_<name> enum
281   // value will be generated and used for this operand type. The target
282   // assembly parser is responsible for converting this into a user-facing
283   // diagnostic message.
284   string DiagnosticType = "";
286   // A diagnostic message to emit when an invalid value is provided for this
287   // register class when it is being used an an assembly operand. If this is
288   // non-empty, an anonymous diagnostic type enum value will be generated, and
289   // the assembly matcher will provide a function to map from diagnostic types
290   // to message strings.
291   string DiagnosticString = "";
294 // The memberList in a RegisterClass is a dag of set operations. TableGen
295 // evaluates these set operations and expand them into register lists. These
296 // are the most common operation, see test/TableGen/SetTheory.td for more
297 // examples of what is possible:
299 // (add R0, R1, R2) - Set Union. Each argument can be an individual register, a
300 // register class, or a sub-expression. This is also the way to simply list
301 // registers.
303 // (sub GPR, SP) - Set difference. Subtract the last arguments from the first.
305 // (and GPR, CSR) - Set intersection. All registers from the first set that are
306 // also in the second set.
308 // (sequence "R%u", 0, 15) -> [R0, R1, ..., R15]. Generate a sequence of
309 // numbered registers.  Takes an optional 4th operand which is a stride to use
310 // when generating the sequence.
312 // (shl GPR, 4) - Remove the first N elements.
314 // (trunc GPR, 4) - Truncate after the first N elements.
316 // (rotl GPR, 1) - Rotate N places to the left.
318 // (rotr GPR, 1) - Rotate N places to the right.
320 // (decimate GPR, 2) - Pick every N'th element, starting with the first.
322 // (interleave A, B, ...) - Interleave the elements from each argument list.
324 // All of these operators work on ordered sets, not lists. That means
325 // duplicates are removed from sub-expressions.
327 // Set operators. The rest is defined in TargetSelectionDAG.td.
328 def sequence;
329 def decimate;
330 def interleave;
332 // RegisterTuples - Automatically generate super-registers by forming tuples of
333 // sub-registers. This is useful for modeling register sequence constraints
334 // with pseudo-registers that are larger than the architectural registers.
336 // The sub-register lists are zipped together:
338 //   def EvenOdd : RegisterTuples<[sube, subo], [(add R0, R2), (add R1, R3)]>;
340 // Generates the same registers as:
342 //   let SubRegIndices = [sube, subo] in {
343 //     def R0_R1 : RegisterWithSubRegs<"", [R0, R1]>;
344 //     def R2_R3 : RegisterWithSubRegs<"", [R2, R3]>;
345 //   }
347 // The generated pseudo-registers inherit super-classes and fields from their
348 // first sub-register. Most fields from the Register class are inferred, and
349 // the AsmName and Dwarf numbers are cleared.
351 // RegisterTuples instances can be used in other set operations to form
352 // register classes and so on. This is the only way of using the generated
353 // registers.
355 // RegNames may be specified to supply asm names for the generated tuples.
356 // If used must have the same size as the list of produced registers.
357 class RegisterTuples<list<SubRegIndex> Indices, list<dag> Regs,
358                      list<string> RegNames = []> {
359   // SubRegs - N lists of registers to be zipped up. Super-registers are
360   // synthesized from the first element of each SubRegs list, the second
361   // element and so on.
362   list<dag> SubRegs = Regs;
364   // SubRegIndices - N SubRegIndex instances. This provides the names of the
365   // sub-registers in the synthesized super-registers.
366   list<SubRegIndex> SubRegIndices = Indices;
368   // List of asm names for the generated tuple registers.
369   list<string> RegAsmNames = RegNames;
373 //===----------------------------------------------------------------------===//
374 // DwarfRegNum - This class provides a mapping of the llvm register enumeration
375 // to the register numbering used by gcc and gdb.  These values are used by a
376 // debug information writer to describe where values may be located during
377 // execution.
378 class DwarfRegNum<list<int> Numbers> {
379   // DwarfNumbers - Numbers used internally by gcc/gdb to identify the register.
380   // These values can be determined by locating the <target>.h file in the
381   // directory llvmgcc/gcc/config/<target>/ and looking for REGISTER_NAMES.  The
382   // order of these names correspond to the enumeration used by gcc.  A value of
383   // -1 indicates that the gcc number is undefined and -2 that register number
384   // is invalid for this mode/flavour.
385   list<int> DwarfNumbers = Numbers;
388 // DwarfRegAlias - This class declares that a given register uses the same dwarf
389 // numbers as another one. This is useful for making it clear that the two
390 // registers do have the same number. It also lets us build a mapping
391 // from dwarf register number to llvm register.
392 class DwarfRegAlias<Register reg> {
393       Register DwarfAlias = reg;
396 //===----------------------------------------------------------------------===//
397 // Pull in the common support for MCPredicate (portable scheduling predicates).
399 include "llvm/Target/TargetInstrPredicate.td"
401 //===----------------------------------------------------------------------===//
402 // Pull in the common support for scheduling
404 include "llvm/Target/TargetSchedule.td"
406 class Predicate; // Forward def
408 class InstructionEncoding {
409   // Size of encoded instruction.
410   int Size;
412   // The "namespace" in which this instruction exists, on targets like ARM
413   // which multiple ISA namespaces exist.
414   string DecoderNamespace = "";
416   // List of predicates which will be turned into isel matching code.
417   list<Predicate> Predicates = [];
419   string DecoderMethod = "";
421   // Is the instruction decoder method able to completely determine if the
422   // given instruction is valid or not. If the TableGen definition of the
423   // instruction specifies bitpattern A??B where A and B are static bits, the
424   // hasCompleteDecoder flag says whether the decoder method fully handles the
425   // ?? space, i.e. if it is a final arbiter for the instruction validity.
426   // If not then the decoder attempts to continue decoding when the decoder
427   // method fails.
428   //
429   // This allows to handle situations where the encoding is not fully
430   // orthogonal. Example:
431   // * InstA with bitpattern 0b0000????,
432   // * InstB with bitpattern 0b000000?? but the associated decoder method
433   //   DecodeInstB() returns Fail when ?? is 0b00 or 0b11.
434   //
435   // The decoder tries to decode a bitpattern that matches both InstA and
436   // InstB bitpatterns first as InstB (because it is the most specific
437   // encoding). In the default case (hasCompleteDecoder = 1), when
438   // DecodeInstB() returns Fail the bitpattern gets rejected. By setting
439   // hasCompleteDecoder = 0 in InstB, the decoder is informed that
440   // DecodeInstB() is not able to determine if all possible values of ?? are
441   // valid or not. If DecodeInstB() returns Fail the decoder will attempt to
442   // decode the bitpattern as InstA too.
443   bit hasCompleteDecoder = 1;
446 // Allows specifying an InstructionEncoding by HwMode. If an Instruction specifies
447 // an EncodingByHwMode, its Inst and Size members are ignored and Ts are used
448 // to encode and decode based on HwMode.
449 class EncodingByHwMode<list<HwMode> Ms = [], list<InstructionEncoding> Ts = []>
450     : HwModeSelect<Ms> {
451   // The length of this list must be the same as the length of Ms.
452   list<InstructionEncoding> Objects = Ts;
455 //===----------------------------------------------------------------------===//
456 // Instruction set description - These classes correspond to the C++ classes in
457 // the Target/TargetInstrInfo.h file.
459 class Instruction : InstructionEncoding {
460   string Namespace = "";
462   dag OutOperandList;       // An dag containing the MI def operand list.
463   dag InOperandList;        // An dag containing the MI use operand list.
464   string AsmString = "";    // The .s format to print the instruction with.
466   // Allows specifying a canonical InstructionEncoding by HwMode. If non-empty,
467   // the Inst member of this Instruction is ignored.
468   EncodingByHwMode EncodingInfos;
470   // Pattern - Set to the DAG pattern for this instruction, if we know of one,
471   // otherwise, uninitialized.
472   list<dag> Pattern;
474   // The follow state will eventually be inferred automatically from the
475   // instruction pattern.
477   list<Register> Uses = []; // Default to using no non-operand registers
478   list<Register> Defs = []; // Default to modifying no non-operand registers
480   // Predicates - List of predicates which will be turned into isel matching
481   // code.
482   list<Predicate> Predicates = [];
484   // Size - Size of encoded instruction, or zero if the size cannot be determined
485   // from the opcode.
486   int Size = 0;
488   // Code size, for instruction selection.
489   // FIXME: What does this actually mean?
490   int CodeSize = 0;
492   // Added complexity passed onto matching pattern.
493   int AddedComplexity  = 0;
495   // Indicates if this is a pre-isel opcode that should be
496   // legalized/regbankselected/selected.
497   bit isPreISelOpcode = 0;
499   // These bits capture information about the high-level semantics of the
500   // instruction.
501   bit isReturn     = 0;     // Is this instruction a return instruction?
502   bit isBranch     = 0;     // Is this instruction a branch instruction?
503   bit isEHScopeReturn = 0;  // Does this instruction end an EH scope?
504   bit isIndirectBranch = 0; // Is this instruction an indirect branch?
505   bit isCompare    = 0;     // Is this instruction a comparison instruction?
506   bit isMoveImm    = 0;     // Is this instruction a move immediate instruction?
507   bit isMoveReg    = 0;     // Is this instruction a move register instruction?
508   bit isBitcast    = 0;     // Is this instruction a bitcast instruction?
509   bit isSelect     = 0;     // Is this instruction a select instruction?
510   bit isBarrier    = 0;     // Can control flow fall through this instruction?
511   bit isCall       = 0;     // Is this instruction a call instruction?
512   bit isAdd        = 0;     // Is this instruction an add instruction?
513   bit isTrap       = 0;     // Is this instruction a trap instruction?
514   bit canFoldAsLoad = 0;    // Can this be folded as a simple memory operand?
515   bit mayLoad      = ?;     // Is it possible for this inst to read memory?
516   bit mayStore     = ?;     // Is it possible for this inst to write memory?
517   bit mayRaiseFPException = 0; // Can this raise a floating-point exception?
518   bit isConvertibleToThreeAddress = 0;  // Can this 2-addr instruction promote?
519   bit isCommutable = 0;     // Is this 3 operand instruction commutable?
520   bit isTerminator = 0;     // Is this part of the terminator for a basic block?
521   bit isReMaterializable = 0; // Is this instruction re-materializable?
522   bit isPredicable = 0;     // 1 means this instruction is predicable
523                             // even if it does not have any operand
524                             // tablegen can identify as a predicate
525   bit isUnpredicable = 0;   // 1 means this instruction is not predicable
526                             // even if it _does_ have a predicate operand
527   bit hasDelaySlot = 0;     // Does this instruction have an delay slot?
528   bit usesCustomInserter = 0; // Pseudo instr needing special help.
529   bit hasPostISelHook = 0;  // To be *adjusted* after isel by target hook.
530   bit hasCtrlDep   = 0;     // Does this instruction r/w ctrl-flow chains?
531   bit isNotDuplicable = 0;  // Is it unsafe to duplicate this instruction?
532   bit isConvergent = 0;     // Is this instruction convergent?
533   bit isAsCheapAsAMove = 0; // As cheap (or cheaper) than a move instruction.
534   bit hasExtraSrcRegAllocReq = 0; // Sources have special regalloc requirement?
535   bit hasExtraDefRegAllocReq = 0; // Defs have special regalloc requirement?
536   bit isRegSequence = 0;    // Is this instruction a kind of reg sequence?
537                             // If so, make sure to override
538                             // TargetInstrInfo::getRegSequenceLikeInputs.
539   bit isPseudo     = 0;     // Is this instruction a pseudo-instruction?
540                             // If so, won't have encoding information for
541                             // the [MC]CodeEmitter stuff.
542   bit isExtractSubreg = 0;  // Is this instruction a kind of extract subreg?
543                              // If so, make sure to override
544                              // TargetInstrInfo::getExtractSubregLikeInputs.
545   bit isInsertSubreg = 0;   // Is this instruction a kind of insert subreg?
546                             // If so, make sure to override
547                             // TargetInstrInfo::getInsertSubregLikeInputs.
548   bit variadicOpsAreDefs = 0; // Are variadic operands definitions?
550   // Does the instruction have side effects that are not captured by any
551   // operands of the instruction or other flags?
552   bit hasSideEffects = ?;
554   // Is this instruction a "real" instruction (with a distinct machine
555   // encoding), or is it a pseudo instruction used for codegen modeling
556   // purposes.
557   // FIXME: For now this is distinct from isPseudo, above, as code-gen-only
558   // instructions can (and often do) still have encoding information
559   // associated with them. Once we've migrated all of them over to true
560   // pseudo-instructions that are lowered to real instructions prior to
561   // the printer/emitter, we can remove this attribute and just use isPseudo.
562   //
563   // The intended use is:
564   // isPseudo: Does not have encoding information and should be expanded,
565   //   at the latest, during lowering to MCInst.
566   //
567   // isCodeGenOnly: Does have encoding information and can go through to the
568   //   CodeEmitter unchanged, but duplicates a canonical instruction
569   //   definition's encoding and should be ignored when constructing the
570   //   assembler match tables.
571   bit isCodeGenOnly = 0;
573   // Is this instruction a pseudo instruction for use by the assembler parser.
574   bit isAsmParserOnly = 0;
576   // This instruction is not expected to be queried for scheduling latencies
577   // and therefore needs no scheduling information even for a complete
578   // scheduling model.
579   bit hasNoSchedulingInfo = 0;
581   InstrItinClass Itinerary = NoItinerary;// Execution steps used for scheduling.
583   // Scheduling information from TargetSchedule.td.
584   list<SchedReadWrite> SchedRW;
586   string Constraints = "";  // OperandConstraint, e.g. $src = $dst.
588   /// DisableEncoding - List of operand names (e.g. "$op1,$op2") that should not
589   /// be encoded into the output machineinstr.
590   string DisableEncoding = "";
592   string PostEncoderMethod = "";
594   /// Target-specific flags. This becomes the TSFlags field in TargetInstrDesc.
595   bits<64> TSFlags = 0;
597   ///@name Assembler Parser Support
598   ///@{
600   string AsmMatchConverter = "";
602   /// TwoOperandAliasConstraint - Enable TableGen to auto-generate a
603   /// two-operand matcher inst-alias for a three operand instruction.
604   /// For example, the arm instruction "add r3, r3, r5" can be written
605   /// as "add r3, r5". The constraint is of the same form as a tied-operand
606   /// constraint. For example, "$Rn = $Rd".
607   string TwoOperandAliasConstraint = "";
609   /// Assembler variant name to use for this instruction. If specified then
610   /// instruction will be presented only in MatchTable for this variant. If
611   /// not specified then assembler variants will be determined based on
612   /// AsmString
613   string AsmVariantName = "";
615   ///@}
617   /// UseNamedOperandTable - If set, the operand indices of this instruction
618   /// can be queried via the getNamedOperandIdx() function which is generated
619   /// by TableGen.
620   bit UseNamedOperandTable = 0;
622   /// Should FastISel ignore this instruction. For certain ISAs, they have
623   /// instructions which map to the same ISD Opcode, value type operands and
624   /// instruction selection predicates. FastISel cannot handle such cases, but
625   /// SelectionDAG can.
626   bit FastISelShouldIgnore = 0;
629 /// Defines an additional encoding that disassembles to the given instruction
630 /// Like Instruction, the Inst and SoftFail fields are omitted to allow targets
631 // to specify their size.
632 class AdditionalEncoding<Instruction I> : InstructionEncoding {
633   Instruction AliasOf = I;
636 /// PseudoInstExpansion - Expansion information for a pseudo-instruction.
637 /// Which instruction it expands to and how the operands map from the
638 /// pseudo.
639 class PseudoInstExpansion<dag Result> {
640   dag ResultInst = Result;     // The instruction to generate.
641   bit isPseudo = 1;
644 /// Predicates - These are extra conditionals which are turned into instruction
645 /// selector matching code. Currently each predicate is just a string.
646 class Predicate<string cond> {
647   string CondString = cond;
649   /// AssemblerMatcherPredicate - If this feature can be used by the assembler
650   /// matcher, this is true.  Targets should set this by inheriting their
651   /// feature from the AssemblerPredicate class in addition to Predicate.
652   bit AssemblerMatcherPredicate = 0;
654   /// AssemblerCondString - Name of the subtarget feature being tested used
655   /// as alternative condition string used for assembler matcher.
656   /// e.g. "ModeThumb" is translated to "(Bits & ModeThumb) != 0".
657   ///      "!ModeThumb" is translated to "(Bits & ModeThumb) == 0".
658   /// It can also list multiple features separated by ",".
659   /// e.g. "ModeThumb,FeatureThumb2" is translated to
660   ///      "(Bits & ModeThumb) != 0 && (Bits & FeatureThumb2) != 0".
661   string AssemblerCondString = "";
663   /// PredicateName - User-level name to use for the predicate. Mainly for use
664   /// in diagnostics such as missing feature errors in the asm matcher.
665   string PredicateName = "";
667   /// Setting this to '1' indicates that the predicate must be recomputed on
668   /// every function change. Most predicates can leave this at '0'.
669   ///
670   /// Ignored by SelectionDAG, it always recomputes the predicate on every use.
671   bit RecomputePerFunction = 0;
674 /// NoHonorSignDependentRounding - This predicate is true if support for
675 /// sign-dependent-rounding is not enabled.
676 def NoHonorSignDependentRounding
677  : Predicate<"!TM.Options.HonorSignDependentRoundingFPMath()">;
679 class Requires<list<Predicate> preds> {
680   list<Predicate> Predicates = preds;
683 /// ops definition - This is just a simple marker used to identify the operand
684 /// list for an instruction. outs and ins are identical both syntactically and
685 /// semantically; they are used to define def operands and use operands to
686 /// improve readibility. This should be used like this:
687 ///     (outs R32:$dst), (ins R32:$src1, R32:$src2) or something similar.
688 def ops;
689 def outs;
690 def ins;
692 /// variable_ops definition - Mark this instruction as taking a variable number
693 /// of operands.
694 def variable_ops;
697 /// PointerLikeRegClass - Values that are designed to have pointer width are
698 /// derived from this.  TableGen treats the register class as having a symbolic
699 /// type that it doesn't know, and resolves the actual regclass to use by using
700 /// the TargetRegisterInfo::getPointerRegClass() hook at codegen time.
701 class PointerLikeRegClass<int Kind> {
702   int RegClassKind = Kind;
706 /// ptr_rc definition - Mark this operand as being a pointer value whose
707 /// register class is resolved dynamically via a callback to TargetInstrInfo.
708 /// FIXME: We should probably change this to a class which contain a list of
709 /// flags. But currently we have but one flag.
710 def ptr_rc : PointerLikeRegClass<0>;
712 /// unknown definition - Mark this operand as being of unknown type, causing
713 /// it to be resolved by inference in the context it is used.
714 class unknown_class;
715 def unknown : unknown_class;
717 /// AsmOperandClass - Representation for the kinds of operands which the target
718 /// specific parser can create and the assembly matcher may need to distinguish.
720 /// Operand classes are used to define the order in which instructions are
721 /// matched, to ensure that the instruction which gets matched for any
722 /// particular list of operands is deterministic.
724 /// The target specific parser must be able to classify a parsed operand into a
725 /// unique class which does not partially overlap with any other classes. It can
726 /// match a subset of some other class, in which case the super class field
727 /// should be defined.
728 class AsmOperandClass {
729   /// The name to use for this class, which should be usable as an enum value.
730   string Name = ?;
732   /// The super classes of this operand.
733   list<AsmOperandClass> SuperClasses = [];
735   /// The name of the method on the target specific operand to call to test
736   /// whether the operand is an instance of this class. If not set, this will
737   /// default to "isFoo", where Foo is the AsmOperandClass name. The method
738   /// signature should be:
739   ///   bool isFoo() const;
740   string PredicateMethod = ?;
742   /// The name of the method on the target specific operand to call to add the
743   /// target specific operand to an MCInst. If not set, this will default to
744   /// "addFooOperands", where Foo is the AsmOperandClass name. The method
745   /// signature should be:
746   ///   void addFooOperands(MCInst &Inst, unsigned N) const;
747   string RenderMethod = ?;
749   /// The name of the method on the target specific operand to call to custom
750   /// handle the operand parsing. This is useful when the operands do not relate
751   /// to immediates or registers and are very instruction specific (as flags to
752   /// set in a processor register, coprocessor number, ...).
753   string ParserMethod = ?;
755   // The diagnostic type to present when referencing this operand in a
756   // match failure error message. By default, use a generic "invalid operand"
757   // diagnostic. The target AsmParser maps these codes to text.
758   string DiagnosticType = "";
760   /// A diagnostic message to emit when an invalid value is provided for this
761   /// operand.
762   string DiagnosticString = "";
764   /// Set to 1 if this operand is optional and not always required. Typically,
765   /// the AsmParser will emit an error when it finishes parsing an
766   /// instruction if it hasn't matched all the operands yet.  However, this
767   /// error will be suppressed if all of the remaining unmatched operands are
768   /// marked as IsOptional.
769   ///
770   /// Optional arguments must be at the end of the operand list.
771   bit IsOptional = 0;
773   /// The name of the method on the target specific asm parser that returns the
774   /// default operand for this optional operand. This method is only used if
775   /// IsOptional == 1. If not set, this will default to "defaultFooOperands",
776   /// where Foo is the AsmOperandClass name. The method signature should be:
777   ///   std::unique_ptr<MCParsedAsmOperand> defaultFooOperands() const;
778   string DefaultMethod = ?;
781 def ImmAsmOperand : AsmOperandClass {
782   let Name = "Imm";
785 /// Operand Types - These provide the built-in operand types that may be used
786 /// by a target.  Targets can optionally provide their own operand types as
787 /// needed, though this should not be needed for RISC targets.
788 class Operand<ValueType ty> : DAGOperand {
789   ValueType Type = ty;
790   string PrintMethod = "printOperand";
791   string EncoderMethod = "";
792   bit hasCompleteDecoder = 1;
793   string OperandType = "OPERAND_UNKNOWN";
794   dag MIOperandInfo = (ops);
796   // MCOperandPredicate - Optionally, a code fragment operating on
797   // const MCOperand &MCOp, and returning a bool, to indicate if
798   // the value of MCOp is valid for the specific subclass of Operand
799   code MCOperandPredicate;
801   // ParserMatchClass - The "match class" that operands of this type fit
802   // in. Match classes are used to define the order in which instructions are
803   // match, to ensure that which instructions gets matched is deterministic.
804   //
805   // The target specific parser must be able to classify an parsed operand into
806   // a unique class, which does not partially overlap with any other classes. It
807   // can match a subset of some other class, in which case the AsmOperandClass
808   // should declare the other operand as one of its super classes.
809   AsmOperandClass ParserMatchClass = ImmAsmOperand;
812 class RegisterOperand<RegisterClass regclass, string pm = "printOperand">
813   : DAGOperand {
814   // RegClass - The register class of the operand.
815   RegisterClass RegClass = regclass;
816   // PrintMethod - The target method to call to print register operands of
817   // this type. The method normally will just use an alt-name index to look
818   // up the name to print. Default to the generic printOperand().
819   string PrintMethod = pm;
821   // EncoderMethod - The target method name to call to encode this register
822   // operand.
823   string EncoderMethod = "";
825   // ParserMatchClass - The "match class" that operands of this type fit
826   // in. Match classes are used to define the order in which instructions are
827   // match, to ensure that which instructions gets matched is deterministic.
828   //
829   // The target specific parser must be able to classify an parsed operand into
830   // a unique class, which does not partially overlap with any other classes. It
831   // can match a subset of some other class, in which case the AsmOperandClass
832   // should declare the other operand as one of its super classes.
833   AsmOperandClass ParserMatchClass;
835   string OperandType = "OPERAND_REGISTER";
837   // When referenced in the result of a CodeGen pattern, GlobalISel will
838   // normally copy the matched operand to the result. When this is set, it will
839   // emit a special copy that will replace zero-immediates with the specified
840   // zero-register.
841   Register GIZeroRegister = ?;
844 let OperandType = "OPERAND_IMMEDIATE" in {
845 def i1imm  : Operand<i1>;
846 def i8imm  : Operand<i8>;
847 def i16imm : Operand<i16>;
848 def i32imm : Operand<i32>;
849 def i64imm : Operand<i64>;
851 def f32imm : Operand<f32>;
852 def f64imm : Operand<f64>;
855 // Register operands for generic instructions don't have an MVT, but do have
856 // constraints linking the operands (e.g. all operands of a G_ADD must
857 // have the same LLT).
858 class TypedOperand<string Ty> : Operand<untyped> {
859   let OperandType = Ty;
860   bit IsPointer = 0;
861   bit IsImmediate = 0;
864 def type0 : TypedOperand<"OPERAND_GENERIC_0">;
865 def type1 : TypedOperand<"OPERAND_GENERIC_1">;
866 def type2 : TypedOperand<"OPERAND_GENERIC_2">;
867 def type3 : TypedOperand<"OPERAND_GENERIC_3">;
868 def type4 : TypedOperand<"OPERAND_GENERIC_4">;
869 def type5 : TypedOperand<"OPERAND_GENERIC_5">;
871 let IsPointer = 1 in {
872   def ptype0 : TypedOperand<"OPERAND_GENERIC_0">;
873   def ptype1 : TypedOperand<"OPERAND_GENERIC_1">;
874   def ptype2 : TypedOperand<"OPERAND_GENERIC_2">;
875   def ptype3 : TypedOperand<"OPERAND_GENERIC_3">;
876   def ptype4 : TypedOperand<"OPERAND_GENERIC_4">;
877   def ptype5 : TypedOperand<"OPERAND_GENERIC_5">;
880 // untyped_imm is for operands where isImm() will be true. It currently has no
881 // special behaviour and is only used for clarity.
882 def untyped_imm_0 : TypedOperand<"OPERAND_GENERIC_IMM_0"> {
883   let IsImmediate = 1;
886 /// zero_reg definition - Special node to stand for the zero register.
888 def zero_reg;
890 /// All operands which the MC layer classifies as predicates should inherit from
891 /// this class in some manner. This is already handled for the most commonly
892 /// used PredicateOperand, but may be useful in other circumstances.
893 class PredicateOp;
895 /// OperandWithDefaultOps - This Operand class can be used as the parent class
896 /// for an Operand that needs to be initialized with a default value if
897 /// no value is supplied in a pattern.  This class can be used to simplify the
898 /// pattern definitions for instructions that have target specific flags
899 /// encoded as immediate operands.
900 class OperandWithDefaultOps<ValueType ty, dag defaultops>
901   : Operand<ty> {
902   dag DefaultOps = defaultops;
905 /// PredicateOperand - This can be used to define a predicate operand for an
906 /// instruction.  OpTypes specifies the MIOperandInfo for the operand, and
907 /// AlwaysVal specifies the value of this predicate when set to "always
908 /// execute".
909 class PredicateOperand<ValueType ty, dag OpTypes, dag AlwaysVal>
910   : OperandWithDefaultOps<ty, AlwaysVal>, PredicateOp {
911   let MIOperandInfo = OpTypes;
914 /// OptionalDefOperand - This is used to define a optional definition operand
915 /// for an instruction. DefaultOps is the register the operand represents if
916 /// none is supplied, e.g. zero_reg.
917 class OptionalDefOperand<ValueType ty, dag OpTypes, dag defaultops>
918   : OperandWithDefaultOps<ty, defaultops> {
919   let MIOperandInfo = OpTypes;
923 // InstrInfo - This class should only be instantiated once to provide parameters
924 // which are global to the target machine.
926 class InstrInfo {
927   // Target can specify its instructions in either big or little-endian formats.
928   // For instance, while both Sparc and PowerPC are big-endian platforms, the
929   // Sparc manual specifies its instructions in the format [31..0] (big), while
930   // PowerPC specifies them using the format [0..31] (little).
931   bit isLittleEndianEncoding = 0;
933   // The instruction properties mayLoad, mayStore, and hasSideEffects are unset
934   // by default, and TableGen will infer their value from the instruction
935   // pattern when possible.
936   //
937   // Normally, TableGen will issue an error it it can't infer the value of a
938   // property that hasn't been set explicitly. When guessInstructionProperties
939   // is set, it will guess a safe value instead.
940   //
941   // This option is a temporary migration help. It will go away.
942   bit guessInstructionProperties = 1;
944   // TableGen's instruction encoder generator has support for matching operands
945   // to bit-field variables both by name and by position. While matching by
946   // name is preferred, this is currently not possible for complex operands,
947   // and some targets still reply on the positional encoding rules. When
948   // generating a decoder for such targets, the positional encoding rules must
949   // be used by the decoder generator as well.
950   //
951   // This option is temporary; it will go away once the TableGen decoder
952   // generator has better support for complex operands and targets have
953   // migrated away from using positionally encoded operands.
954   bit decodePositionallyEncodedOperands = 0;
956   // When set, this indicates that there will be no overlap between those
957   // operands that are matched by ordering (positional operands) and those
958   // matched by name.
959   //
960   // This option is temporary; it will go away once the TableGen decoder
961   // generator has better support for complex operands and targets have
962   // migrated away from using positionally encoded operands.
963   bit noNamedPositionallyEncodedOperands = 0;
966 // Standard Pseudo Instructions.
967 // This list must match TargetOpcodes.def.
968 // Only these instructions are allowed in the TargetOpcode namespace.
969 // Ensure mayLoad and mayStore have a default value, so as not to break
970 // targets that set guessInstructionProperties=0. Any local definition of
971 // mayLoad/mayStore takes precedence over these default values.
972 class StandardPseudoInstruction : Instruction {
973   let mayLoad = 0;
974   let mayStore = 0;
975   let isCodeGenOnly = 1;
976   let isPseudo = 1;
977   let hasNoSchedulingInfo = 1;
978   let Namespace = "TargetOpcode";
980 def PHI : StandardPseudoInstruction {
981   let OutOperandList = (outs unknown:$dst);
982   let InOperandList = (ins variable_ops);
983   let AsmString = "PHINODE";
984   let hasSideEffects = 0;
986 def INLINEASM : StandardPseudoInstruction {
987   let OutOperandList = (outs);
988   let InOperandList = (ins variable_ops);
989   let AsmString = "";
990   let hasSideEffects = 0;  // Note side effect is encoded in an operand.
992 def INLINEASM_BR : StandardPseudoInstruction {
993   let OutOperandList = (outs);
994   let InOperandList = (ins variable_ops);
995   let AsmString = "";
996   let hasSideEffects = 0;  // Note side effect is encoded in an operand.
997   let isTerminator = 1;
998   let isBranch = 1;
999   let isIndirectBranch = 1;
1001 def CFI_INSTRUCTION : StandardPseudoInstruction {
1002   let OutOperandList = (outs);
1003   let InOperandList = (ins i32imm:$id);
1004   let AsmString = "";
1005   let hasCtrlDep = 1;
1006   let hasSideEffects = 0;
1007   let isNotDuplicable = 1;
1009 def EH_LABEL : StandardPseudoInstruction {
1010   let OutOperandList = (outs);
1011   let InOperandList = (ins i32imm:$id);
1012   let AsmString = "";
1013   let hasCtrlDep = 1;
1014   let hasSideEffects = 0;
1015   let isNotDuplicable = 1;
1017 def GC_LABEL : StandardPseudoInstruction {
1018   let OutOperandList = (outs);
1019   let InOperandList = (ins i32imm:$id);
1020   let AsmString = "";
1021   let hasCtrlDep = 1;
1022   let hasSideEffects = 0;
1023   let isNotDuplicable = 1;
1025 def ANNOTATION_LABEL : StandardPseudoInstruction {
1026   let OutOperandList = (outs);
1027   let InOperandList = (ins i32imm:$id);
1028   let AsmString = "";
1029   let hasCtrlDep = 1;
1030   let hasSideEffects = 0;
1031   let isNotDuplicable = 1;
1033 def KILL : StandardPseudoInstruction {
1034   let OutOperandList = (outs);
1035   let InOperandList = (ins variable_ops);
1036   let AsmString = "";
1037   let hasSideEffects = 0;
1039 def EXTRACT_SUBREG : StandardPseudoInstruction {
1040   let OutOperandList = (outs unknown:$dst);
1041   let InOperandList = (ins unknown:$supersrc, i32imm:$subidx);
1042   let AsmString = "";
1043   let hasSideEffects = 0;
1045 def INSERT_SUBREG : StandardPseudoInstruction {
1046   let OutOperandList = (outs unknown:$dst);
1047   let InOperandList = (ins unknown:$supersrc, unknown:$subsrc, i32imm:$subidx);
1048   let AsmString = "";
1049   let hasSideEffects = 0;
1050   let Constraints = "$supersrc = $dst";
1052 def IMPLICIT_DEF : StandardPseudoInstruction {
1053   let OutOperandList = (outs unknown:$dst);
1054   let InOperandList = (ins);
1055   let AsmString = "";
1056   let hasSideEffects = 0;
1057   let isReMaterializable = 1;
1058   let isAsCheapAsAMove = 1;
1060 def SUBREG_TO_REG : StandardPseudoInstruction {
1061   let OutOperandList = (outs unknown:$dst);
1062   let InOperandList = (ins unknown:$implsrc, unknown:$subsrc, i32imm:$subidx);
1063   let AsmString = "";
1064   let hasSideEffects = 0;
1066 def COPY_TO_REGCLASS : StandardPseudoInstruction {
1067   let OutOperandList = (outs unknown:$dst);
1068   let InOperandList = (ins unknown:$src, i32imm:$regclass);
1069   let AsmString = "";
1070   let hasSideEffects = 0;
1071   let isAsCheapAsAMove = 1;
1073 def DBG_VALUE : StandardPseudoInstruction {
1074   let OutOperandList = (outs);
1075   let InOperandList = (ins variable_ops);
1076   let AsmString = "DBG_VALUE";
1077   let hasSideEffects = 0;
1079 def DBG_LABEL : StandardPseudoInstruction {
1080   let OutOperandList = (outs);
1081   let InOperandList = (ins unknown:$label);
1082   let AsmString = "DBG_LABEL";
1083   let hasSideEffects = 0;
1085 def REG_SEQUENCE : StandardPseudoInstruction {
1086   let OutOperandList = (outs unknown:$dst);
1087   let InOperandList = (ins unknown:$supersrc, variable_ops);
1088   let AsmString = "";
1089   let hasSideEffects = 0;
1090   let isAsCheapAsAMove = 1;
1092 def COPY : StandardPseudoInstruction {
1093   let OutOperandList = (outs unknown:$dst);
1094   let InOperandList = (ins unknown:$src);
1095   let AsmString = "";
1096   let hasSideEffects = 0;
1097   let isAsCheapAsAMove = 1;
1098   let hasNoSchedulingInfo = 0;
1100 def BUNDLE : StandardPseudoInstruction {
1101   let OutOperandList = (outs);
1102   let InOperandList = (ins variable_ops);
1103   let AsmString = "BUNDLE";
1104   let hasSideEffects = 0;
1106 def LIFETIME_START : StandardPseudoInstruction {
1107   let OutOperandList = (outs);
1108   let InOperandList = (ins i32imm:$id);
1109   let AsmString = "LIFETIME_START";
1110   let hasSideEffects = 0;
1112 def LIFETIME_END : StandardPseudoInstruction {
1113   let OutOperandList = (outs);
1114   let InOperandList = (ins i32imm:$id);
1115   let AsmString = "LIFETIME_END";
1116   let hasSideEffects = 0;
1118 def STACKMAP : StandardPseudoInstruction {
1119   let OutOperandList = (outs);
1120   let InOperandList = (ins i64imm:$id, i32imm:$nbytes, variable_ops);
1121   let hasSideEffects = 1;
1122   let isCall = 1;
1123   let mayLoad = 1;
1124   let usesCustomInserter = 1;
1126 def PATCHPOINT : StandardPseudoInstruction {
1127   let OutOperandList = (outs unknown:$dst);
1128   let InOperandList = (ins i64imm:$id, i32imm:$nbytes, unknown:$callee,
1129                        i32imm:$nargs, i32imm:$cc, variable_ops);
1130   let hasSideEffects = 1;
1131   let isCall = 1;
1132   let mayLoad = 1;
1133   let usesCustomInserter = 1;
1135 def STATEPOINT : StandardPseudoInstruction {
1136   let OutOperandList = (outs);
1137   let InOperandList = (ins variable_ops);
1138   let usesCustomInserter = 1;
1139   let mayLoad = 1;
1140   let mayStore = 1;
1141   let hasSideEffects = 1;
1142   let isCall = 1;
1144 def LOAD_STACK_GUARD : StandardPseudoInstruction {
1145   let OutOperandList = (outs ptr_rc:$dst);
1146   let InOperandList = (ins);
1147   let mayLoad = 1;
1148   bit isReMaterializable = 1;
1149   let hasSideEffects = 0;
1150   bit isPseudo = 1;
1152 def LOCAL_ESCAPE : StandardPseudoInstruction {
1153   // This instruction is really just a label. It has to be part of the chain so
1154   // that it doesn't get dropped from the DAG, but it produces nothing and has
1155   // no side effects.
1156   let OutOperandList = (outs);
1157   let InOperandList = (ins ptr_rc:$symbol, i32imm:$id);
1158   let hasSideEffects = 0;
1159   let hasCtrlDep = 1;
1161 def FAULTING_OP : StandardPseudoInstruction {
1162   let OutOperandList = (outs unknown:$dst);
1163   let InOperandList = (ins variable_ops);
1164   let usesCustomInserter = 1;
1165   let hasSideEffects = 1;
1166   let mayLoad = 1;
1167   let mayStore = 1;
1168   let isTerminator = 1;
1169   let isBranch = 1;
1171 def PATCHABLE_OP : StandardPseudoInstruction {
1172   let OutOperandList = (outs);
1173   let InOperandList = (ins variable_ops);
1174   let usesCustomInserter = 1;
1175   let mayLoad = 1;
1176   let mayStore = 1;
1177   let hasSideEffects = 1;
1179 def PATCHABLE_FUNCTION_ENTER : StandardPseudoInstruction {
1180   let OutOperandList = (outs);
1181   let InOperandList = (ins);
1182   let AsmString = "# XRay Function Enter.";
1183   let usesCustomInserter = 1;
1184   let hasSideEffects = 0;
1186 def PATCHABLE_RET : StandardPseudoInstruction {
1187   let OutOperandList = (outs);
1188   let InOperandList = (ins variable_ops);
1189   let AsmString = "# XRay Function Patchable RET.";
1190   let usesCustomInserter = 1;
1191   let hasSideEffects = 1;
1192   let isTerminator = 1;
1193   let isReturn = 1;
1195 def PATCHABLE_FUNCTION_EXIT : StandardPseudoInstruction {
1196   let OutOperandList = (outs);
1197   let InOperandList = (ins);
1198   let AsmString = "# XRay Function Exit.";
1199   let usesCustomInserter = 1;
1200   let hasSideEffects = 0; // FIXME: is this correct?
1201   let isReturn = 0; // Original return instruction will follow
1203 def PATCHABLE_TAIL_CALL : StandardPseudoInstruction {
1204   let OutOperandList = (outs);
1205   let InOperandList = (ins variable_ops);
1206   let AsmString = "# XRay Tail Call Exit.";
1207   let usesCustomInserter = 1;
1208   let hasSideEffects = 1;
1209   let isReturn = 1;
1211 def PATCHABLE_EVENT_CALL : StandardPseudoInstruction {
1212   let OutOperandList = (outs);
1213   let InOperandList = (ins ptr_rc:$event, i8imm:$size);
1214   let AsmString = "# XRay Custom Event Log.";
1215   let usesCustomInserter = 1;
1216   let isCall = 1;
1217   let mayLoad = 1;
1218   let mayStore = 1;
1219   let hasSideEffects = 1;
1221 def PATCHABLE_TYPED_EVENT_CALL : StandardPseudoInstruction {
1222   let OutOperandList = (outs);
1223   let InOperandList = (ins i16imm:$type, ptr_rc:$event, i32imm:$size);
1224   let AsmString = "# XRay Typed Event Log.";
1225   let usesCustomInserter = 1;
1226   let isCall = 1;
1227   let mayLoad = 1;
1228   let mayStore = 1;
1229   let hasSideEffects = 1;
1231 def FENTRY_CALL : StandardPseudoInstruction {
1232   let OutOperandList = (outs);
1233   let InOperandList = (ins);
1234   let AsmString = "# FEntry call";
1235   let usesCustomInserter = 1;
1236   let mayLoad = 1;
1237   let mayStore = 1;
1238   let hasSideEffects = 1;
1240 def ICALL_BRANCH_FUNNEL : StandardPseudoInstruction {
1241   let OutOperandList = (outs);
1242   let InOperandList = (ins variable_ops);
1243   let AsmString = "";
1244   let hasSideEffects = 1;
1247 // Generic opcodes used in GlobalISel.
1248 include "llvm/Target/GenericOpcodes.td"
1250 //===----------------------------------------------------------------------===//
1251 // AsmParser - This class can be implemented by targets that wish to implement
1252 // .s file parsing.
1254 // Subtargets can have multiple different assembly parsers (e.g. AT&T vs Intel
1255 // syntax on X86 for example).
1257 class AsmParser {
1258   // AsmParserClassName - This specifies the suffix to use for the asmparser
1259   // class.  Generated AsmParser classes are always prefixed with the target
1260   // name.
1261   string AsmParserClassName  = "AsmParser";
1263   // AsmParserInstCleanup - If non-empty, this is the name of a custom member
1264   // function of the AsmParser class to call on every matched instruction.
1265   // This can be used to perform target specific instruction post-processing.
1266   string AsmParserInstCleanup  = "";
1268   // ShouldEmitMatchRegisterName - Set to false if the target needs a hand
1269   // written register name matcher
1270   bit ShouldEmitMatchRegisterName = 1;
1272   // Set to true if the target needs a generated 'alternative register name'
1273   // matcher.
1274   //
1275   // This generates a function which can be used to lookup registers from
1276   // their aliases. This function will fail when called on targets where
1277   // several registers share the same alias (i.e. not a 1:1 mapping).
1278   bit ShouldEmitMatchRegisterAltName = 0;
1280   // Set to true if MatchRegisterName and MatchRegisterAltName functions
1281   // should be generated even if there are duplicate register names. The
1282   // target is responsible for coercing aliased registers as necessary
1283   // (e.g. in validateTargetOperandClass), and there are no guarantees about
1284   // which numeric register identifier will be returned in the case of
1285   // multiple matches.
1286   bit AllowDuplicateRegisterNames = 0;
1288   // HasMnemonicFirst - Set to false if target instructions don't always
1289   // start with a mnemonic as the first token.
1290   bit HasMnemonicFirst = 1;
1292   // ReportMultipleNearMisses -
1293   // When 0, the assembly matcher reports an error for one encoding or operand
1294   // that did not match the parsed instruction.
1295   // When 1, the assmebly matcher returns a list of encodings that were close
1296   // to matching the parsed instruction, so to allow more detailed error
1297   // messages.
1298   bit ReportMultipleNearMisses = 0;
1300 def DefaultAsmParser : AsmParser;
1302 //===----------------------------------------------------------------------===//
1303 // AsmParserVariant - Subtargets can have multiple different assembly parsers
1304 // (e.g. AT&T vs Intel syntax on X86 for example). This class can be
1305 // implemented by targets to describe such variants.
1307 class AsmParserVariant {
1308   // Variant - AsmParsers can be of multiple different variants.  Variants are
1309   // used to support targets that need to parser multiple formats for the
1310   // assembly language.
1311   int Variant = 0;
1313   // Name - The AsmParser variant name (e.g., AT&T vs Intel).
1314   string Name = "";
1316   // CommentDelimiter - If given, the delimiter string used to recognize
1317   // comments which are hard coded in the .td assembler strings for individual
1318   // instructions.
1319   string CommentDelimiter = "";
1321   // RegisterPrefix - If given, the token prefix which indicates a register
1322   // token. This is used by the matcher to automatically recognize hard coded
1323   // register tokens as constrained registers, instead of tokens, for the
1324   // purposes of matching.
1325   string RegisterPrefix = "";
1327   // TokenizingCharacters - Characters that are standalone tokens
1328   string TokenizingCharacters = "[]*!";
1330   // SeparatorCharacters - Characters that are not tokens
1331   string SeparatorCharacters = " \t,";
1333   // BreakCharacters - Characters that start new identifiers
1334   string BreakCharacters = "";
1336 def DefaultAsmParserVariant : AsmParserVariant;
1338 /// AssemblerPredicate - This is a Predicate that can be used when the assembler
1339 /// matches instructions and aliases.
1340 class AssemblerPredicate<string cond, string name = ""> {
1341   bit AssemblerMatcherPredicate = 1;
1342   string AssemblerCondString = cond;
1343   string PredicateName = name;
1346 /// TokenAlias - This class allows targets to define assembler token
1347 /// operand aliases. That is, a token literal operand which is equivalent
1348 /// to another, canonical, token literal. For example, ARM allows:
1349 ///   vmov.u32 s4, #0  -> vmov.i32, #0
1350 /// 'u32' is a more specific designator for the 32-bit integer type specifier
1351 /// and is legal for any instruction which accepts 'i32' as a datatype suffix.
1352 ///   def : TokenAlias<".u32", ".i32">;
1354 /// This works by marking the match class of 'From' as a subclass of the
1355 /// match class of 'To'.
1356 class TokenAlias<string From, string To> {
1357   string FromToken = From;
1358   string ToToken = To;
1361 /// MnemonicAlias - This class allows targets to define assembler mnemonic
1362 /// aliases.  This should be used when all forms of one mnemonic are accepted
1363 /// with a different mnemonic.  For example, X86 allows:
1364 ///   sal %al, 1    -> shl %al, 1
1365 ///   sal %ax, %cl  -> shl %ax, %cl
1366 ///   sal %eax, %cl -> shl %eax, %cl
1367 /// etc.  Though "sal" is accepted with many forms, all of them are directly
1368 /// translated to a shl, so it can be handled with (in the case of X86, it
1369 /// actually has one for each suffix as well):
1370 ///   def : MnemonicAlias<"sal", "shl">;
1372 /// Mnemonic aliases are mapped before any other translation in the match phase,
1373 /// and do allow Requires predicates, e.g.:
1375 ///  def : MnemonicAlias<"pushf", "pushfq">, Requires<[In64BitMode]>;
1376 ///  def : MnemonicAlias<"pushf", "pushfl">, Requires<[In32BitMode]>;
1378 /// Mnemonic aliases can also be constrained to specific variants, e.g.:
1380 ///  def : MnemonicAlias<"pushf", "pushfq", "att">, Requires<[In64BitMode]>;
1382 /// If no variant (e.g., "att" or "intel") is specified then the alias is
1383 /// applied unconditionally.
1384 class MnemonicAlias<string From, string To, string VariantName = ""> {
1385   string FromMnemonic = From;
1386   string ToMnemonic = To;
1387   string AsmVariantName = VariantName;
1389   // Predicates - Predicates that must be true for this remapping to happen.
1390   list<Predicate> Predicates = [];
1393 /// InstAlias - This defines an alternate assembly syntax that is allowed to
1394 /// match an instruction that has a different (more canonical) assembly
1395 /// representation.
1396 class InstAlias<string Asm, dag Result, int Emit = 1, string VariantName = ""> {
1397   string AsmString = Asm;      // The .s format to match the instruction with.
1398   dag ResultInst = Result;     // The MCInst to generate.
1400   // This determines which order the InstPrinter detects aliases for
1401   // printing. A larger value makes the alias more likely to be
1402   // emitted. The Instruction's own definition is notionally 0.5, so 0
1403   // disables printing and 1 enables it if there are no conflicting aliases.
1404   int EmitPriority = Emit;
1406   // Predicates - Predicates that must be true for this to match.
1407   list<Predicate> Predicates = [];
1409   // If the instruction specified in Result has defined an AsmMatchConverter
1410   // then setting this to 1 will cause the alias to use the AsmMatchConverter
1411   // function when converting the OperandVector into an MCInst instead of the
1412   // function that is generated by the dag Result.
1413   // Setting this to 0 will cause the alias to ignore the Result instruction's
1414   // defined AsmMatchConverter and instead use the function generated by the
1415   // dag Result.
1416   bit UseInstAsmMatchConverter = 1;
1418   // Assembler variant name to use for this alias. If not specified then
1419   // assembler variants will be determined based on AsmString
1420   string AsmVariantName = VariantName;
1423 //===----------------------------------------------------------------------===//
1424 // AsmWriter - This class can be implemented by targets that need to customize
1425 // the format of the .s file writer.
1427 // Subtargets can have multiple different asmwriters (e.g. AT&T vs Intel syntax
1428 // on X86 for example).
1430 class AsmWriter {
1431   // AsmWriterClassName - This specifies the suffix to use for the asmwriter
1432   // class.  Generated AsmWriter classes are always prefixed with the target
1433   // name.
1434   string AsmWriterClassName  = "InstPrinter";
1436   // PassSubtarget - Determines whether MCSubtargetInfo should be passed to
1437   // the various print methods.
1438   // FIXME: Remove after all ports are updated.
1439   int PassSubtarget = 0;
1441   // Variant - AsmWriters can be of multiple different variants.  Variants are
1442   // used to support targets that need to emit assembly code in ways that are
1443   // mostly the same for different targets, but have minor differences in
1444   // syntax.  If the asmstring contains {|} characters in them, this integer
1445   // will specify which alternative to use.  For example "{x|y|z}" with Variant
1446   // == 1, will expand to "y".
1447   int Variant = 0;
1449 def DefaultAsmWriter : AsmWriter;
1452 //===----------------------------------------------------------------------===//
1453 // Target - This class contains the "global" target information
1455 class Target {
1456   // InstructionSet - Instruction set description for this target.
1457   InstrInfo InstructionSet;
1459   // AssemblyParsers - The AsmParser instances available for this target.
1460   list<AsmParser> AssemblyParsers = [DefaultAsmParser];
1462   /// AssemblyParserVariants - The AsmParserVariant instances available for
1463   /// this target.
1464   list<AsmParserVariant> AssemblyParserVariants = [DefaultAsmParserVariant];
1466   // AssemblyWriters - The AsmWriter instances available for this target.
1467   list<AsmWriter> AssemblyWriters = [DefaultAsmWriter];
1469   // AllowRegisterRenaming - Controls whether this target allows
1470   // post-register-allocation renaming of registers.  This is done by
1471   // setting hasExtraDefRegAllocReq and hasExtraSrcRegAllocReq to 1
1472   // for all opcodes if this flag is set to 0.
1473   int AllowRegisterRenaming = 0;
1476 //===----------------------------------------------------------------------===//
1477 // SubtargetFeature - A characteristic of the chip set.
1479 class SubtargetFeature<string n, string a,  string v, string d,
1480                        list<SubtargetFeature> i = []> {
1481   // Name - Feature name.  Used by command line (-mattr=) to determine the
1482   // appropriate target chip.
1483   //
1484   string Name = n;
1486   // Attribute - Attribute to be set by feature.
1487   //
1488   string Attribute = a;
1490   // Value - Value the attribute to be set to by feature.
1491   //
1492   string Value = v;
1494   // Desc - Feature description.  Used by command line (-mattr=) to display help
1495   // information.
1496   //
1497   string Desc = d;
1499   // Implies - Features that this feature implies are present. If one of those
1500   // features isn't set, then this one shouldn't be set either.
1501   //
1502   list<SubtargetFeature> Implies = i;
1505 /// Specifies a Subtarget feature that this instruction is deprecated on.
1506 class Deprecated<SubtargetFeature dep> {
1507   SubtargetFeature DeprecatedFeatureMask = dep;
1510 /// A custom predicate used to determine if an instruction is
1511 /// deprecated or not.
1512 class ComplexDeprecationPredicate<string dep> {
1513   string ComplexDeprecationPredicate = dep;
1516 //===----------------------------------------------------------------------===//
1517 // Processor chip sets - These values represent each of the chip sets supported
1518 // by the scheduler.  Each Processor definition requires corresponding
1519 // instruction itineraries.
1521 class Processor<string n, ProcessorItineraries pi, list<SubtargetFeature> f> {
1522   // Name - Chip set name.  Used by command line (-mcpu=) to determine the
1523   // appropriate target chip.
1524   //
1525   string Name = n;
1527   // SchedModel - The machine model for scheduling and instruction cost.
1528   //
1529   SchedMachineModel SchedModel = NoSchedModel;
1531   // ProcItin - The scheduling information for the target processor.
1532   //
1533   ProcessorItineraries ProcItin = pi;
1535   // Features - list of
1536   list<SubtargetFeature> Features = f;
1539 // ProcessorModel allows subtargets to specify the more general
1540 // SchedMachineModel instead if a ProcessorItinerary. Subtargets will
1541 // gradually move to this newer form.
1543 // Although this class always passes NoItineraries to the Processor
1544 // class, the SchedMachineModel may still define valid Itineraries.
1545 class ProcessorModel<string n, SchedMachineModel m, list<SubtargetFeature> f>
1546   : Processor<n, NoItineraries, f> {
1547   let SchedModel = m;
1550 //===----------------------------------------------------------------------===//
1551 // InstrMapping - This class is used to create mapping tables to relate
1552 // instructions with each other based on the values specified in RowFields,
1553 // ColFields, KeyCol and ValueCols.
1555 class InstrMapping {
1556   // FilterClass - Used to limit search space only to the instructions that
1557   // define the relationship modeled by this InstrMapping record.
1558   string FilterClass;
1560   // RowFields - List of fields/attributes that should be same for all the
1561   // instructions in a row of the relation table. Think of this as a set of
1562   // properties shared by all the instructions related by this relationship
1563   // model and is used to categorize instructions into subgroups. For instance,
1564   // if we want to define a relation that maps 'Add' instruction to its
1565   // predicated forms, we can define RowFields like this:
1566   //
1567   // let RowFields = BaseOp
1568   // All add instruction predicated/non-predicated will have to set their BaseOp
1569   // to the same value.
1570   //
1571   // def Add: { let BaseOp = 'ADD'; let predSense = 'nopred' }
1572   // def Add_predtrue: { let BaseOp = 'ADD'; let predSense = 'true' }
1573   // def Add_predfalse: { let BaseOp = 'ADD'; let predSense = 'false'  }
1574   list<string> RowFields = [];
1576   // List of fields/attributes that are same for all the instructions
1577   // in a column of the relation table.
1578   // Ex: let ColFields = 'predSense' -- It means that the columns are arranged
1579   // based on the 'predSense' values. All the instruction in a specific
1580   // column have the same value and it is fixed for the column according
1581   // to the values set in 'ValueCols'.
1582   list<string> ColFields = [];
1584   // Values for the fields/attributes listed in 'ColFields'.
1585   // Ex: let KeyCol = 'nopred' -- It means that the key instruction (instruction
1586   // that models this relation) should be non-predicated.
1587   // In the example above, 'Add' is the key instruction.
1588   list<string> KeyCol = [];
1590   // List of values for the fields/attributes listed in 'ColFields', one for
1591   // each column in the relation table.
1592   //
1593   // Ex: let ValueCols = [['true'],['false']] -- It adds two columns in the
1594   // table. First column requires all the instructions to have predSense
1595   // set to 'true' and second column requires it to be 'false'.
1596   list<list<string> > ValueCols = [];
1599 //===----------------------------------------------------------------------===//
1600 // Pull in the common support for calling conventions.
1602 include "llvm/Target/TargetCallingConv.td"
1604 //===----------------------------------------------------------------------===//
1605 // Pull in the common support for DAG isel generation.
1607 include "llvm/Target/TargetSelectionDAG.td"
1609 //===----------------------------------------------------------------------===//
1610 // Pull in the common support for Global ISel register bank info generation.
1612 include "llvm/Target/GlobalISel/RegisterBank.td"
1614 //===----------------------------------------------------------------------===//
1615 // Pull in the common support for DAG isel generation.
1617 include "llvm/Target/GlobalISel/Target.td"
1619 //===----------------------------------------------------------------------===//
1620 // Pull in the common support for the Global ISel DAG-based selector generation.
1622 include "llvm/Target/GlobalISel/SelectionDAGCompat.td"
1624 //===----------------------------------------------------------------------===//
1625 // Pull in the common support for Pfm Counters generation.
1627 include "llvm/Target/TargetPfmCounters.td"