2 class R600Reg <string name, bits<16> encoding> : Register<name> {
3 let Namespace = "AMDGPU";
4 let HWEncoding = encoding;
7 class R600RegWithChan <string name, bits<9> sel, string chan> :
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";
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;
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>;
31 // Indirect addressing offset registers
32 def Addr#Index#_#Chan : R600RegWithChan <"T("#Index#" + AR.x)."#Chan,
34 def TRegMem#Index#_#Chan : R600RegWithChan <"T"#Index#"."#Chan, Index,
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")],
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["#Index#"-128]."#Chan, Index, Chan>;
52 // 128-bit Temporary Registers
53 def KC0_#Index#_XYZW : R600Reg_128 <"KC0["#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")],
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["#Index#"-160]."#Chan, Index, Chan>;
67 // 128-bit Temporary Registers
68 def KC1_#Index#_XYZW : R600Reg_128 <"KC1["#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")],
77 // Array Base Register holding input in FS
78 foreach Index = 448-480 in {
79 def ArrayBase#Index : R600Reg<"ARRAY_BASE", Index>;
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>;
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>;
115 let isAllocatable = 0 in {
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))>;
120 } // End isAllocatable = 0
122 def R600_KC0_X : RegisterClass <"AMDGPU", [f32, i32], 32,
123 (add (sequence "KC0_%u_X", 128, 159))>;
125 def R600_KC0_Y : RegisterClass <"AMDGPU", [f32, i32], 32,
126 (add (sequence "KC0_%u_Y", 128, 159))>;
128 def R600_KC0_Z : RegisterClass <"AMDGPU", [f32, i32], 32,
129 (add (sequence "KC0_%u_Z", 128, 159))>;
131 def R600_KC0_W : RegisterClass <"AMDGPU", [f32, i32], 32,
132 (add (sequence "KC0_%u_W", 128, 159))>;
134 def R600_KC0 : RegisterClass <"AMDGPU", [f32, i32], 32,
135 (interleave R600_KC0_X, R600_KC0_Y,
136 R600_KC0_Z, R600_KC0_W)>;
138 def R600_KC1_X : RegisterClass <"AMDGPU", [f32, i32], 32,
139 (add (sequence "KC1_%u_X", 160, 191))>;
141 def R600_KC1_Y : RegisterClass <"AMDGPU", [f32, i32], 32,
142 (add (sequence "KC1_%u_Y", 160, 191))>;
144 def R600_KC1_Z : RegisterClass <"AMDGPU", [f32, i32], 32,
145 (add (sequence "KC1_%u_Z", 160, 191))>;
147 def R600_KC1_W : RegisterClass <"AMDGPU", [f32, i32], 32,
148 (add (sequence "KC1_%u_W", 160, 191))>;
150 def R600_KC1 : RegisterClass <"AMDGPU", [f32, i32], 32,
151 (interleave R600_KC1_X, R600_KC1_Y,
152 R600_KC1_Z, R600_KC1_W)>;
154 def R600_TReg32_X : RegisterClass <"AMDGPU", [f32, i32], 32,
155 (add (sequence "T%u_X", 0, 127), AR_X)>;
157 def R600_TReg32_Y : RegisterClass <"AMDGPU", [f32, i32], 32,
158 (add (sequence "T%u_Y", 0, 127))>;
160 def R600_TReg32_Z : RegisterClass <"AMDGPU", [f32, i32], 32,
161 (add (sequence "T%u_Z", 0, 127))>;
163 def R600_TReg32_W : RegisterClass <"AMDGPU", [f32, i32], 32,
164 (add (sequence "T%u_W", 0, 127))>;
166 def R600_TReg32 : RegisterClass <"AMDGPU", [f32, i32], 32,
167 (interleave R600_TReg32_X, R600_TReg32_Y,
168 R600_TReg32_Z, R600_TReg32_W)>;
170 def R600_Reg32 : RegisterClass <"AMDGPU", [f32, i32], 32, (add
174 ZERO, HALF, ONE, ONE_INT, PV_X, ALU_LITERAL_X, NEG_ONE, NEG_HALF,
175 ALU_CONST, ALU_PARAM, OQAP
178 def R600_Predicate : RegisterClass <"AMDGPU", [i32], 32, (add
179 PRED_SEL_OFF, PRED_SEL_ZERO, PRED_SEL_ONE)>;
181 def R600_Predicate_Bit: RegisterClass <"AMDGPU", [i32], 32, (add
184 def R600_Reg128 : RegisterClass<"AMDGPU", [v4f32, v4i32], 128,
185 (add (sequence "T%u_XYZW", 0, 127))> {
189 //===----------------------------------------------------------------------===//
190 // Register classes for indirect addressing
191 //===----------------------------------------------------------------------===//
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";
200 [sub0, sub1, sub2, sub3, sub4, sub5, sub6, sub7,
201 sub8, sub9, sub10, sub11, sub12, sub13, sub14, sub15];
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]
210 def IndirectReg : RegisterClass<"AMDGPU", [f32, i32], 32, (add IndirectSuperReg)>;
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))