lib/Target/R600/SIRegisterInfo.td

   1
   2 let Namespace = "AMDGPU" in {
   3   def low : SubRegIndex;
   4   def high : SubRegIndex;
   5
   6   def sub0 : SubRegIndex;
   7   def sub1 : SubRegIndex;
   8   def sub2 : SubRegIndex;
   9   def sub3 : SubRegIndex;
  10   def sub4 : SubRegIndex;
  11   def sub5 : SubRegIndex;
  12   def sub6 : SubRegIndex;
  13   def sub7 : SubRegIndex;
  14 }
  15
  16 class SIReg <string n, bits<16> encoding = 0> : Register<n> {
  17   let Namespace = "AMDGPU";
  18   let HWEncoding = encoding;
  19 }
  20
  21 class SI_64 <string n, list<Register> subregs, bits<16> encoding> : RegisterWithSubRegs<n, subregs> {
  22   let Namespace = "AMDGPU";
  23   let SubRegIndices = [low, high];
  24   let HWEncoding = encoding;
  25 }
  26
  27 class SGPR_32 <bits<16> num, string name> : SIReg<name, num>;
  28
  29 class VGPR_32 <bits<16> num, string name> : SIReg<name, num>;
  30
  31 // Special Registers
  32 def VCC : SIReg<"VCC", 106>;
  33 def EXEC_LO : SIReg <"EXEC LO", 126>;
  34 def EXEC_HI : SIReg <"EXEC HI", 127>;
  35 def EXEC : SI_64<"EXEC", [EXEC_LO, EXEC_HI], 126>;
  36 def SCC : SIReg<"SCC", 253>;
  37 def SREG_LIT_0 : SIReg <"S LIT 0", 128>;
  38 def SI_LITERAL_CONSTANT : SIReg<"LITERAL CONSTANT", 255>;
  39 def M0 : SIReg <"M0", 124>;
  40
  41 //Interpolation registers
  42 def PERSP_SAMPLE_I : SIReg <"PERSP_SAMPLE_I">;
  43 def PERSP_SAMPLE_J : SIReg <"PERSP_SAMPLE_J">;
  44 def PERSP_CENTER_I : SIReg <"PERSP_CENTER_I">;
  45 def PERSP_CENTER_J : SIReg <"PERSP_CENTER_J">;
  46 def PERSP_CENTROID_I : SIReg <"PERSP_CENTROID_I">;
  47 def PERSP_CENTROID_J : SIReg <"PERP_CENTROID_J">;
  48 def PERSP_I_W : SIReg <"PERSP_I_W">;
  49 def PERSP_J_W : SIReg <"PERSP_J_W">;
  50 def PERSP_1_W : SIReg <"PERSP_1_W">;
  51 def LINEAR_SAMPLE_I : SIReg <"LINEAR_SAMPLE_I">;
  52 def LINEAR_SAMPLE_J : SIReg <"LINEAR_SAMPLE_J">;
  53 def LINEAR_CENTER_I : SIReg <"LINEAR_CENTER_I">;
  54 def LINEAR_CENTER_J : SIReg <"LINEAR_CENTER_J">;
  55 def LINEAR_CENTROID_I : SIReg <"LINEAR_CENTROID_I">;
  56 def LINEAR_CENTROID_J : SIReg <"LINEAR_CENTROID_J">;
  57 def LINE_STIPPLE_TEX_COORD : SIReg <"LINE_STIPPLE_TEX_COORD">;
  58 def POS_X_FLOAT : SIReg <"POS_X_FLOAT">;
  59 def POS_Y_FLOAT : SIReg <"POS_Y_FLOAT">;
  60 def POS_Z_FLOAT : SIReg <"POS_Z_FLOAT">;
  61 def POS_W_FLOAT : SIReg <"POS_W_FLOAT">;
  62 def FRONT_FACE : SIReg <"FRONT_FACE">;
  63 def ANCILLARY : SIReg <"ANCILLARY">;
  64 def SAMPLE_COVERAGE : SIReg <"SAMPLE_COVERAGE">;
  65 def POS_FIXED_PT : SIReg <"POS_FIXED_PT">;
  66
  67 // SGPR 32-bit registers
  68 foreach Index = 0-101 in {
  69   def SGPR#Index : SGPR_32 <Index, "SGPR"#Index>;
  70 }
  71
  72 def SGPR_32 : RegisterClass<"AMDGPU", [f32, i32], 32,
  73                             (add (sequence "SGPR%u", 0, 101))>;
  74
  75 // SGPR 64-bit registers
  76 def SGPR_64 : RegisterTuples<[low, high],
  77                              [(add (decimate SGPR_32, 2)),
  78                               (add(decimate (rotl SGPR_32, 1), 2))]>;
  79
  80 // SGPR 128-bit registers
  81 def SGPR_128 : RegisterTuples<[sel_x, sel_y, sel_z, sel_w],
  82                               [(add (decimate SGPR_32, 4)),
  83                                (add (decimate (rotl SGPR_32, 1), 4)),
  84                                (add (decimate (rotl SGPR_32, 2), 4)),
  85                                (add (decimate (rotl SGPR_32, 3), 4))]>;
  86
  87 // SGPR 256-bit registers
  88 def SGPR_256 : RegisterTuples<[sub0, sub1, sub2, sub3, sub4, sub5, sub6, sub7],
  89                               [(add (decimate SGPR_32, 8)),
  90                                (add (decimate (rotl SGPR_32, 1), 8)),
  91                                (add (decimate (rotl SGPR_32, 2), 8)),
  92                                (add (decimate (rotl SGPR_32, 3), 8)),
  93                                (add (decimate (rotl SGPR_32, 4), 8)),
  94                                (add (decimate (rotl SGPR_32, 5), 8)),
  95                                (add (decimate (rotl SGPR_32, 6), 8)),
  96                                (add (decimate (rotl SGPR_32, 7), 8))]>;
  97
  98 // VGPR 32-bit registers
  99 foreach Index = 0-255 in {
 100   def VGPR#Index : VGPR_32 <Index, "VGPR"#Index>;
 101 }
 102
 103 def VGPR_32 : RegisterClass<"AMDGPU", [f32, i32], 32,
 104                             (add (sequence "VGPR%u", 0, 255))>;
 105
 106 // VGPR 64-bit registers
 107 def VGPR_64 : RegisterTuples<[low, high],
 108                              [(add VGPR_32),
 109                               (add (rotl VGPR_32, 1))]>;
 110
 111 // VGPR 128-bit registers
 112 def VGPR_128 : RegisterTuples<[sel_x, sel_y, sel_z, sel_w],
 113                               [(add VGPR_32),
 114                                (add (rotl VGPR_32, 1)),
 115                                (add (rotl VGPR_32, 2)),
 116                                (add (rotl VGPR_32, 3))]>;
 117
 118 // Register class for all scalar registers (SGPRs + Special Registers)
 119 def SReg_32 : RegisterClass<"AMDGPU", [f32, i32], 32,
 120     (add SGPR_32,  SREG_LIT_0, M0, EXEC_LO, EXEC_HI)
 121 >;
 122
 123 def SReg_64 : RegisterClass<"AMDGPU", [i64], 64, (add SGPR_64, VCC, EXEC)>;
 124
 125 def SReg_1 : RegisterClass<"AMDGPU", [i1], 1, (add VCC, SGPR_64, EXEC)>;
 126
 127 def SReg_128 : RegisterClass<"AMDGPU", [v4f32, v4i32], 128, (add SGPR_128)>;
 128
 129 def SReg_256 : RegisterClass<"AMDGPU", [v8i32], 256, (add SGPR_256)>;
 130
 131 // Register class for all vector registers (VGPRs + Interploation Registers)
 132 def VReg_32 : RegisterClass<"AMDGPU", [f32, i32], 32,
 133     (add VGPR_32,
 134     PERSP_SAMPLE_I, PERSP_SAMPLE_J,
 135     PERSP_CENTER_I, PERSP_CENTER_J,
 136     PERSP_CENTROID_I, PERSP_CENTROID_J,
 137     PERSP_I_W, PERSP_J_W, PERSP_1_W,
 138     LINEAR_SAMPLE_I, LINEAR_SAMPLE_J,
 139     LINEAR_CENTER_I, LINEAR_CENTER_J,
 140     LINEAR_CENTROID_I, LINEAR_CENTROID_J,
 141     LINE_STIPPLE_TEX_COORD,
 142     POS_X_FLOAT,
 143     POS_Y_FLOAT,
 144     POS_Z_FLOAT,
 145     POS_W_FLOAT,
 146     FRONT_FACE,
 147     ANCILLARY,
 148     SAMPLE_COVERAGE,
 149     POS_FIXED_PT
 150     )
 151 >;
 152
 153 def VReg_64 : RegisterClass<"AMDGPU", [i64], 64, (add VGPR_64)>;
 154
 155 def VReg_128 : RegisterClass<"AMDGPU", [v4f32], 128, (add VGPR_128)>;
 156
 157 // AllReg_* - A set of all scalar and vector registers of a given width.
 158 def AllReg_32 : RegisterClass<"AMDGPU", [f32, i32], 32, (add VReg_32, SReg_32)>;
 159
 160 def AllReg_64 : RegisterClass<"AMDGPU", [f64, i64], 64, (add SReg_64, VReg_64)>;
 161
 162 // Special register classes for predicates and the M0 register
 163 def SCCReg : RegisterClass<"AMDGPU", [i1], 1, (add SCC)>;
 164 def VCCReg : RegisterClass<"AMDGPU", [i1], 1, (add VCC)>;
 165 def EXECReg : RegisterClass<"AMDGPU", [i1], 1, (add EXEC)>;
 166 def M0Reg : RegisterClass<"AMDGPU", [i32], 32, (add M0)>;
 167