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 }
  39
  40 // RegisterAliases - You should define instances of this class to indicate which
  41 // registers in the register file are aliased together.  This allows the code
  42 // generator to be careful not to put two values with overlapping live ranges
  43 // into registers which alias.
  44 //
  45 class RegisterAliases<Register reg, list<Register> aliases> {
  46   Register Reg = reg;
  47   list<Register> Aliases = aliases;
  48 }
  49
  50 // RegisterClass - Now that all of the registers are defined, and aliases
  51 // between registers are defined, specify which registers belong to which
  52 // register classes.  This also defines the default allocation order of
  53 // registers by register allocators.
  54 //
  55 class RegisterClass<ValueType regType, int alignment, list<Register> regList> {
  56   // RegType - Specify the ValueType of the registers in this register class.
  57   // Note that all registers in a register class must have the same ValueType.
  58   //
  59   ValueType RegType = regType;
  60
  61   // Alignment - Specify the alignment required of the registers when they are
  62   // stored or loaded to memory.
  63   //
  64   int Size = RegType.Size;
  65   int Alignment = alignment;
  66
  67   // MemberList - Specify which registers are in this class.  If the
  68   // allocation_order_* method are not specified, this also defines the order of
  69   // allocation used by the register allocator.
  70   //
  71   list<Register> MemberList = regList;
  72
  73   // Methods - This member can be used to insert arbitrary code into a generated
  74   // register class.   The normal usage of this is to overload virtual methods.
  75   code Methods = [{}];
  76 }
  77
  78
  79 //===----------------------------------------------------------------------===//
  80 // Instruction set description - These classes correspond to the C++ classes in
  81 // the Target/TargetInstrInfo.h file.
  82 //
  83
  84 class Instruction {
  85   string Name;          // The opcode string for this instruction
  86   string Namespace = "";
  87
  88   list<Register> Uses = [];  // Default to using no non-operand registers
  89   list<Register> Defs = [];  // Default to modifying no non-operand registers
  90
  91   // These bits capture information about the high-level semantics of the
  92   // instruction.
  93   bit isReturn     = 0;     // Is this instruction a return instruction?
  94   bit isBranch     = 0;     // Is this instruction a branch instruction?
  95   bit isCall       = 0;     // Is this instruction a call instruction?
  96   bit isTwoAddress = 0;     // Is this a two address instruction?
  97   bit isTerminator = 0;     // Is this part of the terminator for a basic block?
  98 }
  99
 100 // InstrInfo - This class should only be instantiated once to provide parameters
 101 // which are global to the the target machine.
 102 //
 103 class InstrInfo {
 104   Instruction PHIInst;
 105   Instruction NOOPInst;
 106
 107   // If the target wants to associate some target-specific information with each
 108   // instruction, it should provide these two lists to indicate how to assemble
 109   // the target specific information into the 32 bits available.
 110   //
 111   list<string> TSFlagsFields = [];
 112   list<int>    TSFlagsShifts = [];
 113 }
 114
 115
 116 //===----------------------------------------------------------------------===//
 117 // Target - This class contains the "global" target information
 118 //
 119 class Target {
 120   // CalleeSavedRegisters - As you might guess, this is a list of the callee
 121   // saved registers for a target.
 122   list<Register> CalleeSavedRegisters = [];
 123
 124   // PointerType - Specify the value type to be used to represent pointers in
 125   // this target.  Typically this is an i32 or i64 type.
 126   ValueType PointerType;
 127
 128   // InstructionSet - Instruction set description for this target
 129   InstrInfo InstructionSet;
 130 }