lib/Target/R600/R600RegisterInfo.td

   1
   2 class R600Reg <string name, bits<16> encoding> : Register<name> {
   3   let Namespace = "AMDGPU";
   4   let HWEncoding = encoding;
   5 }
   6
   7 class R600RegWithChan <string name, bits<9> sel, string chan> :
   8     Register <name> {
   9
  10   field bits<2> chan_encoding = !if(!eq(chan, "X"), 0,
  11                                 !if(!eq(chan, "Y"), 1,
  12                                 !if(!eq(chan, "Z"), 2,
  13                                 !if(!eq(chan, "W"), 3, 0))));
  14   let HWEncoding{8-0}  = sel;
  15   let HWEncoding{10-9} = chan_encoding;
  16   let Namespace = "AMDGPU";
  17 }
  18
  19 class R600Reg_128<string n, list<Register> subregs, bits<16> encoding> :
  20     RegisterWithSubRegs<n, subregs> {
  21   let Namespace = "AMDGPU";
  22   let SubRegIndices = [sub0, sub1, sub2, sub3];
  23   let HWEncoding = encoding;
  24 }
  25
  26 foreach Index = 0-127 in {
  27   foreach Chan = [ "X", "Y", "Z", "W" ] in {
  28     // 32-bit Temporary Registers
  29     def T#Index#_#Chan : R600RegWithChan <"T"#Index#"."#Chan, Index, Chan>;
  30
  31     // Indirect addressing offset registers
  32     def Addr#Index#_#Chan : R600RegWithChan <"T("#Index#" + AR.x)."#Chan,
  33                                               Index, Chan>;
  34     def TRegMem#Index#_#Chan : R600RegWithChan <"T"#Index#"."#Chan, Index,
  35                                                 Chan>;
  36   }
  37   // 128-bit Temporary Registers
  38   def T#Index#_XYZW : R600Reg_128 <"T"#Index#"",
  39                                    [!cast<Register>("T"#Index#"_X"),
  40                                     !cast<Register>("T"#Index#"_Y"),
  41                                     !cast<Register>("T"#Index#"_Z"),
  42                                     !cast<Register>("T"#Index#"_W")],
  43                                    Index>;
  44 }
  45
  46 // KCACHE_BANK0
  47 foreach Index = 159-128 in {
  48   foreach Chan = [ "X", "Y", "Z", "W" ] in {
  49     // 32-bit Temporary Registers
  50     def KC0_#Index#_#Chan : R600RegWithChan <"KC0["#!add(Index,-128)#"]."#Chan, Index, Chan>;
  51   }
  52   // 128-bit Temporary Registers
  53   def KC0_#Index#_XYZW : R600Reg_128 <"KC0["#!add(Index, -128)#"].XYZW",
  54                                  [!cast<Register>("KC0_"#Index#"_X"),
  55                                   !cast<Register>("KC0_"#Index#"_Y"),
  56                                   !cast<Register>("KC0_"#Index#"_Z"),
  57                                   !cast<Register>("KC0_"#Index#"_W")],
  58                                  Index>;
  59 }
  60
  61 // KCACHE_BANK1
  62 foreach Index = 191-160 in {
  63   foreach Chan = [ "X", "Y", "Z", "W" ] in {
  64     // 32-bit Temporary Registers
  65     def KC1_#Index#_#Chan : R600RegWithChan <"KC1["#!add(Index,-160)#"]."#Chan, Index, Chan>;
  66   }
  67   // 128-bit Temporary Registers
  68   def KC1_#Index#_XYZW : R600Reg_128 <"KC1["#!add(Index, -160)#"].XYZW",
  69                                  [!cast<Register>("KC1_"#Index#"_X"),
  70                                   !cast<Register>("KC1_"#Index#"_Y"),
  71                                   !cast<Register>("KC1_"#Index#"_Z"),
  72                                   !cast<Register>("KC1_"#Index#"_W")],
  73                                  Index>;
  74 }
  75
  76
  77 // Array Base Register holding input in FS
  78 foreach Index = 448-480 in {
  79   def ArrayBase#Index :  R600Reg<"ARRAY_BASE", Index>;
  80 }
  81
  82
  83 // Special Registers
  84
  85 def ZERO : R600Reg<"0.0", 248>;
  86 def ONE : R600Reg<"1.0", 249>;
  87 def NEG_ONE : R600Reg<"-1.0", 249>;
  88 def ONE_INT : R600Reg<"1", 250>;
  89 def HALF : R600Reg<"0.5", 252>;
  90 def NEG_HALF : R600Reg<"-0.5", 252>;
  91 def ALU_LITERAL_X : R600RegWithChan<"literal.x", 253, "X">;
  92 def ALU_LITERAL_Y : R600RegWithChan<"literal.y", 253, "Y">;
  93 def ALU_LITERAL_Z : R600RegWithChan<"literal.z", 253, "Z">;
  94 def ALU_LITERAL_W : R600RegWithChan<"literal.w", 253, "W">;
  95 def PV_X : R600RegWithChan<"PV.X", 254, "X">;
  96 def PV_Y : R600RegWithChan<"PV.Y", 254, "Y">;
  97 def PV_Z : R600RegWithChan<"PV.Z", 254, "Z">;
  98 def PV_W : R600RegWithChan<"PV.W", 254, "W">;
  99 def PS: R600Reg<"PS", 255>;
 100 def PREDICATE_BIT : R600Reg<"PredicateBit", 0>;
 101 def PRED_SEL_OFF: R600Reg<"Pred_sel_off", 0>;
 102 def PRED_SEL_ZERO : R600Reg<"Pred_sel_zero", 2>;
 103 def PRED_SEL_ONE : R600Reg<"Pred_sel_one", 3>;
 104 def AR_X : R600Reg<"AR.x", 0>;
 105 def OQAP : R600Reg<"OQAP", 221>;
 106
 107 def R600_ArrayBase : RegisterClass <"AMDGPU", [f32, i32], 32,
 108                           (add (sequence "ArrayBase%u", 448, 480))>;
 109 // special registers for ALU src operands
 110 // const buffer reference, SRCx_SEL contains index
 111 def ALU_CONST : R600Reg<"CBuf", 0>;
 112 // interpolation param reference, SRCx_SEL contains index
 113 def ALU_PARAM : R600Reg<"Param", 0>;
 114
 115 let isAllocatable = 0 in {
 116
 117 // XXX: Only use the X channel, until we support wider stack widths
 118 def R600_Addr : RegisterClass <"AMDGPU", [i32], 127, (add (sequence "Addr%u_X", 0, 127))>;
 119
 120 } // End isAllocatable = 0
 121
 122 def R600_KC0_X : RegisterClass <"AMDGPU", [f32, i32], 32,
 123                               (add (sequence "KC0_%u_X", 128, 159))>;
 124
 125 def R600_KC0_Y : RegisterClass <"AMDGPU", [f32, i32], 32,
 126                               (add (sequence "KC0_%u_Y", 128, 159))>;
 127
 128 def R600_KC0_Z : RegisterClass <"AMDGPU", [f32, i32], 32,
 129                               (add (sequence "KC0_%u_Z", 128, 159))>;
 130
 131 def R600_KC0_W : RegisterClass <"AMDGPU", [f32, i32], 32,
 132                               (add (sequence "KC0_%u_W", 128, 159))>;
 133
 134 def R600_KC0 : RegisterClass <"AMDGPU", [f32, i32], 32,
 135                                    (interleave R600_KC0_X, R600_KC0_Y,
 136                                                R600_KC0_Z, R600_KC0_W)>;
 137
 138 def R600_KC1_X : RegisterClass <"AMDGPU", [f32, i32], 32,
 139                               (add (sequence "KC1_%u_X", 160, 191))>;
 140
 141 def R600_KC1_Y : RegisterClass <"AMDGPU", [f32, i32], 32,
 142                               (add (sequence "KC1_%u_Y", 160, 191))>;
 143
 144 def R600_KC1_Z : RegisterClass <"AMDGPU", [f32, i32], 32,
 145                               (add (sequence "KC1_%u_Z", 160, 191))>;
 146
 147 def R600_KC1_W : RegisterClass <"AMDGPU", [f32, i32], 32,
 148                               (add (sequence "KC1_%u_W", 160, 191))>;
 149
 150 def R600_KC1 : RegisterClass <"AMDGPU", [f32, i32], 32,
 151                                    (interleave R600_KC1_X, R600_KC1_Y,
 152                                                R600_KC1_Z, R600_KC1_W)>;
 153
 154 def R600_TReg32_X : RegisterClass <"AMDGPU", [f32, i32], 32,
 155                                    (add (sequence "T%u_X", 0, 127), AR_X)>;
 156
 157 def R600_TReg32_Y : RegisterClass <"AMDGPU", [f32, i32], 32,
 158                                    (add (sequence "T%u_Y", 0, 127))>;
 159
 160 def R600_TReg32_Z : RegisterClass <"AMDGPU", [f32, i32], 32,
 161                                    (add (sequence "T%u_Z", 0, 127))>;
 162
 163 def R600_TReg32_W : RegisterClass <"AMDGPU", [f32, i32], 32,
 164                                    (add (sequence "T%u_W", 0, 127))>;
 165
 166 def R600_TReg32 : RegisterClass <"AMDGPU", [f32, i32], 32,
 167                                    (interleave R600_TReg32_X, R600_TReg32_Y,
 168                                                R600_TReg32_Z, R600_TReg32_W)>;
 169
 170 def R600_Reg32 : RegisterClass <"AMDGPU", [f32, i32], 32, (add
 171     R600_TReg32,
 172     R600_ArrayBase,
 173     R600_Addr,
 174     ZERO, HALF, ONE, ONE_INT, PV_X, ALU_LITERAL_X, NEG_ONE, NEG_HALF,
 175     ALU_CONST, ALU_PARAM, OQAP
 176     )>;
 177
 178 def R600_Predicate : RegisterClass <"AMDGPU", [i32], 32, (add
 179     PRED_SEL_OFF, PRED_SEL_ZERO, PRED_SEL_ONE)>;
 180
 181 def R600_Predicate_Bit: RegisterClass <"AMDGPU", [i32], 32, (add
 182     PREDICATE_BIT)>;
 183
 184 def R600_Reg128 : RegisterClass<"AMDGPU", [v4f32, v4i32], 128,
 185                                 (add (sequence "T%u_XYZW", 0, 127))> {
 186   let CopyCost = -1;
 187 }
 188
 189 //===----------------------------------------------------------------------===//
 190 // Register classes for indirect addressing
 191 //===----------------------------------------------------------------------===//
 192
 193 // Super register for all the Indirect Registers.  This register class is used
 194 // by the REG_SEQUENCE instruction to specify the registers to use for direct
 195 // reads / writes which may be written / read by an indirect address.
 196 class IndirectSuper<string n, list<Register> subregs> :
 197     RegisterWithSubRegs<n, subregs> {
 198   let Namespace = "AMDGPU";
 199   let SubRegIndices =
 200  [sub0, sub1, sub2, sub3, sub4, sub5, sub6, sub7,
 201   sub8, sub9, sub10, sub11, sub12, sub13, sub14, sub15];
 202 }
 203
 204 def IndirectSuperReg : IndirectSuper<"Indirect",
 205   [TRegMem0_X, TRegMem1_X, TRegMem2_X, TRegMem3_X, TRegMem4_X, TRegMem5_X,
 206    TRegMem6_X, TRegMem7_X, TRegMem8_X, TRegMem9_X, TRegMem10_X, TRegMem11_X,
 207    TRegMem12_X, TRegMem13_X, TRegMem14_X, TRegMem15_X]
 208 >;
 209
 210 def IndirectReg : RegisterClass<"AMDGPU", [f32, i32], 32, (add IndirectSuperReg)>;
 211
 212 // This register class defines the registers that are the storage units for
 213 // the "Indirect Addressing" pseudo memory space.
 214 // XXX: Only use the X channel, until we support wider stack widths
 215 def TRegMem : RegisterClass<"AMDGPU", [f32, i32], 32,
 216   (add (sequence "TRegMem%u_X", 0, 16))
 217 >;