1 //===- Target.td - Target Independent TableGen interface --------*- C++ -*-===//
3 // This file defines the target-independent interfaces which should be
4 // implemented by each target which is using a TableGen based code generator.
6 //===----------------------------------------------------------------------===//
9 //===----------------------------------------------------------------------===//
11 // Value types - These values correspond to the register types defined in the
14 class ValueType<int size> { string Namespace = "MVT"; int Size = size; }
16 def i1 : ValueType<1>; // One bit boolean value
17 def i8 : ValueType<8>; // 8-bit integer value
18 def i16 : ValueType<16>; // 16-bit integer value
19 def i32 : ValueType<32>; // 32-bit integer value
20 def i64 : ValueType<64>; // 64-bit integer value
21 def i128 : ValueType<128>; // 128-bit integer value
22 def f32 : ValueType<32>; // 32-bit floating point value
23 def f64 : ValueType<64>; // 64-bit floating point value
24 def f80 : ValueType<80>; // 80-bit floating point value
25 def f128 : ValueType<128>; // 128-bit floating point value
28 //===----------------------------------------------------------------------===//
29 // Register file description - These classes are used to fill in the target
30 // description classes in llvm/Target/MRegisterInfo.h
33 // Register - You should define one instance of this class for each register in
34 // the target machine.
37 string Namespace = "";
41 // NamedReg - If the name for the 'def' of the register should not become the
42 // "name" of the register, you can use this to specify a custom name instead.
44 class NamedReg<string n> : Register {
48 // RegisterAliases - You should define instances of this class to indicate which
49 // registers in the register file are aliased together. This allows the code
50 // generator to be careful not to put two values with overlapping live ranges
51 // into registers which alias.
53 class RegisterAliases<Register reg, list<Register> aliases> {
55 list<Register> Aliases = aliases;
58 // RegisterClass - Now that all of the registers are defined, and aliases
59 // between registers are defined, specify which registers belong to which
60 // register classes. This also defines the default allocation order of
61 // registers by register allocators.
63 class RegisterClass<ValueType regType, int alignment, list<Register> regList> {
64 // RegType - Specify the ValueType of the registers in this register class.
65 // Note that all registers in a register class must have the same ValueType.
67 ValueType RegType = regType;
69 // Alignment - Specify the alignment required of the registers when they are
70 // stored or loaded to memory.
72 int Size = RegType.Size;
73 int Alignment = alignment;
75 // MemberList - Specify which registers are in this class. If the
76 // allocation_order_* method are not specified, this also defines the order of
77 // allocation used by the register allocator.
79 list<Register> MemberList = regList;
81 // Methods - This member can be used to insert arbitrary code into a generated
82 // register class. The normal usage of this is to overload virtual methods.
87 //===----------------------------------------------------------------------===//
88 // Instruction set description - These classes correspond to the C++ classes in
89 // the Target/TargetInstrInfo.h file.
93 string Name; // The opcode string for this instruction
94 string Namespace = "";
96 list<Register> Uses = []; // Default to using no non-operand registers
97 list<Register> Defs = []; // Default to modifying no non-operand registers
99 // These bits capture information about the high-level semantics of the
101 bit isReturn = 0; // Is this instruction a return instruction?
102 bit isBranch = 0; // Is this instruction a branch instruction?
103 bit isCall = 0; // Is this instruction a call instruction?
104 bit isTwoAddress = 0; // Is this a two address instruction?
105 bit isTerminator = 0; // Is this part of the terminator for a basic block?
108 // InstrInfo - This class should only be instantiated once to provide parameters
109 // which are global to the the target machine.
113 Instruction NOOPInst;
115 // If the target wants to associate some target-specific information with each
116 // instruction, it should provide these two lists to indicate how to assemble
117 // the target specific information into the 32 bits available.
119 list<string> TSFlagsFields = [];
120 list<int> TSFlagsShifts = [];
124 //===----------------------------------------------------------------------===//
125 // Target - This class contains the "global" target information
128 // CalleeSavedRegisters - As you might guess, this is a list of the callee
129 // saved registers for a target.
130 list<Register> CalleeSavedRegisters = [];
132 // PointerType - Specify the value type to be used to represent pointers in
133 // this target. Typically this is an i32 or i64 type.
134 ValueType PointerType;
136 // InstructionSet - Instruction set description for this target
137 InstrInfo InstructionSet;