lib/Target/Target.td

   1 //===- Target.td - Target Independent TableGen interface --------*- C++ -*-===//
   2 //
   3 // This file defines the target-independent interfaces which should be
   4 // implemented by each target which is using a TableGen based code generator.
   5 //
   6 //===----------------------------------------------------------------------===//
   7
   8
   9 //===----------------------------------------------------------------------===//
  10 //
  11 // Value types - These values correspond to the register types defined in the
  12 // ValueTypes.h file.
  13 //
  14 class ValueType<int size> { string Namespace = "MVT"; int Size = size; }
  15
  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
  26
  27
  28 //===----------------------------------------------------------------------===//
  29 // Register file description - These classes are used to fill in the target
  30 // description classes in llvm/Target/MRegisterInfo.h
  31
  32
  33 // Register - You should define one instance of this class for each register in
  34 // the target machine.
  35 //
  36 class Register {
  37   string Namespace = "";
  38   string Name = "";
  39 }
  40
  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.
  43 //
  44 class NamedReg<string n> : Register {
  45   let Name = n;
  46 }
  47
  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.
  52 //
  53 class RegisterAliases<Register reg, list<Register> aliases> {
  54   Register Reg = reg;
  55   list<Register> Aliases = aliases;
  56 }
  57
  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.
  62 //
  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.
  66   //
  67   ValueType RegType = regType;
  68
  69   // Alignment - Specify the alignment required of the registers when they are
  70   // stored or loaded to memory.
  71   //
  72   int Size = RegType.Size;
  73   int Alignment = alignment;
  74
  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.
  78   //
  79   list<Register> MemberList = regList;
  80
  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.
  83   code Methods = [{}];
  84 }
  85
  86
  87 //===----------------------------------------------------------------------===//
  88 // Instruction set description - These classes correspond to the C++ classes in
  89 // the Target/TargetInstrInfo.h file.
  90 //
  91
  92 class Instruction {
  93   string Name;          // The opcode string for this instruction
  94   string Namespace = "";
  95
  96   list<Register> Uses = [];  // Default to using no non-operand registers
  97   list<Register> Defs = [];  // Default to modifying no non-operand registers
  98
  99   // These bits capture information about the high-level semantics of the
 100   // instruction.
 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?
 106 }
 107
 108 // InstrInfo - This class should only be instantiated once to provide parameters
 109 // which are global to the the target machine.
 110 //
 111 class InstrInfo {
 112   Instruction PHIInst;
 113
 114   // If the target wants to associate some target-specific information with each
 115   // instruction, it should provide these two lists to indicate how to assemble
 116   // the target specific information into the 32 bits available.
 117   //
 118   list<string> TSFlagsFields = [];
 119   list<int>    TSFlagsShifts = [];
 120 }
 121
 122
 123 //===----------------------------------------------------------------------===//
 124 // Target - This class contains the "global" target information
 125 //
 126 class Target {
 127   // CalleeSavedRegisters - As you might guess, this is a list of the callee
 128   // saved registers for a target.
 129   list<Register> CalleeSavedRegisters = [];
 130
 131   // PointerType - Specify the value type to be used to represent pointers in
 132   // this target.  Typically this is an i32 or i64 type.
 133   ValueType PointerType;
 134
 135   // InstructionSet - Instruction set description for this target
 136   InstrInfo InstructionSet;
 137 }