1 /*
2 * Copyright 2009 Nicolai Hähnle <nhaehnle@gmail.com>
3 * SPDX-License-Identifier: MIT
4 */
5
6 #include <stdio.h>
7 #include "r300_tgsi_to_rc.h"
8
9 #include "compiler/radeon_compiler.h"
10
11 #include "tgsi/tgsi_info.h"
12 #include "tgsi/tgsi_parse.h"
13 #include "tgsi/tgsi_scan.h"
14 #include "tgsi/tgsi_util.h"
15
16 #include "util/compiler.h"
17
translate_opcode(unsigned opcode)18 static unsigned translate_opcode(unsigned opcode)
19 {
20 switch(opcode) {
21 case TGSI_OPCODE_ARL: return RC_OPCODE_ARL;
22 case TGSI_OPCODE_MOV: return RC_OPCODE_MOV;
23 case TGSI_OPCODE_LIT: return RC_OPCODE_LIT;
24 case TGSI_OPCODE_RCP: return RC_OPCODE_RCP;
25 case TGSI_OPCODE_RSQ: return RC_OPCODE_RSQ;
26 case TGSI_OPCODE_EXP: return RC_OPCODE_EXP;
27 case TGSI_OPCODE_LOG: return RC_OPCODE_LOG;
28 case TGSI_OPCODE_MUL: return RC_OPCODE_MUL;
29 case TGSI_OPCODE_ADD: return RC_OPCODE_ADD;
30 case TGSI_OPCODE_DP3: return RC_OPCODE_DP3;
31 case TGSI_OPCODE_DP4: return RC_OPCODE_DP4;
32 case TGSI_OPCODE_DST: return RC_OPCODE_DST;
33 case TGSI_OPCODE_MIN: return RC_OPCODE_MIN;
34 case TGSI_OPCODE_MAX: return RC_OPCODE_MAX;
35 case TGSI_OPCODE_SLT: return RC_OPCODE_SLT;
36 case TGSI_OPCODE_SGE: return RC_OPCODE_SGE;
37 case TGSI_OPCODE_MAD: return RC_OPCODE_MAD;
38 case TGSI_OPCODE_FRC: return RC_OPCODE_FRC;
39 case TGSI_OPCODE_ROUND: return RC_OPCODE_ROUND;
40 case TGSI_OPCODE_EX2: return RC_OPCODE_EX2;
41 case TGSI_OPCODE_LG2: return RC_OPCODE_LG2;
42 case TGSI_OPCODE_POW: return RC_OPCODE_POW;
43 case TGSI_OPCODE_COS: return RC_OPCODE_COS;
44 case TGSI_OPCODE_DDX: return RC_OPCODE_DDX;
45 case TGSI_OPCODE_DDY: return RC_OPCODE_DDY;
46 case TGSI_OPCODE_KILL: return RC_OPCODE_KILP;
47 case TGSI_OPCODE_SEQ: return RC_OPCODE_SEQ;
48 case TGSI_OPCODE_SIN: return RC_OPCODE_SIN;
49 case TGSI_OPCODE_SNE: return RC_OPCODE_SNE;
50 case TGSI_OPCODE_TEX: return RC_OPCODE_TEX;
51 case TGSI_OPCODE_TXD: return RC_OPCODE_TXD;
52 case TGSI_OPCODE_TXP: return RC_OPCODE_TXP;
53 case TGSI_OPCODE_ARR: return RC_OPCODE_ARR;
54 case TGSI_OPCODE_CMP: return RC_OPCODE_CMP;
55 case TGSI_OPCODE_TXB: return RC_OPCODE_TXB;
56 case TGSI_OPCODE_DP2: return RC_OPCODE_DP2;
57 case TGSI_OPCODE_TXL: return RC_OPCODE_TXL;
58 case TGSI_OPCODE_BRK: return RC_OPCODE_BRK;
59 case TGSI_OPCODE_IF: return RC_OPCODE_IF;
60 case TGSI_OPCODE_BGNLOOP: return RC_OPCODE_BGNLOOP;
61 case TGSI_OPCODE_ELSE: return RC_OPCODE_ELSE;
62 case TGSI_OPCODE_ENDIF: return RC_OPCODE_ENDIF;
63 case TGSI_OPCODE_ENDLOOP: return RC_OPCODE_ENDLOOP;
64 case TGSI_OPCODE_CONT: return RC_OPCODE_CONT;
65 case TGSI_OPCODE_NOP: return RC_OPCODE_NOP;
66 case TGSI_OPCODE_KILL_IF: return RC_OPCODE_KIL;
67 }
68
69 fprintf(stderr, "r300: Unknown TGSI/RC opcode: %s\n", tgsi_get_opcode_name(opcode));
70 return RC_OPCODE_ILLEGAL_OPCODE;
71 }
72
translate_saturate(unsigned saturate)73 static unsigned translate_saturate(unsigned saturate)
74 {
75 return saturate ? RC_SATURATE_ZERO_ONE : RC_SATURATE_NONE;
76 }
77
translate_register_file(unsigned file)78 static unsigned translate_register_file(unsigned file)
79 {
80 switch(file) {
81 case TGSI_FILE_CONSTANT: return RC_FILE_CONSTANT;
82 case TGSI_FILE_IMMEDIATE: return RC_FILE_CONSTANT;
83 case TGSI_FILE_INPUT: return RC_FILE_INPUT;
84 case TGSI_FILE_OUTPUT: return RC_FILE_OUTPUT;
85 default:
86 fprintf(stderr, "Unhandled register file: %i\n", file);
87 FALLTHROUGH;
88 case TGSI_FILE_TEMPORARY: return RC_FILE_TEMPORARY;
89 case TGSI_FILE_ADDRESS: return RC_FILE_ADDRESS;
90 }
91 }
92
translate_register_index(struct tgsi_to_rc * ttr,unsigned file,int index)93 static int translate_register_index(
94 struct tgsi_to_rc * ttr,
95 unsigned file,
96 int index)
97 {
98 if (file == TGSI_FILE_IMMEDIATE)
99 return ttr->immediate_offset + index;
100
101 return index;
102 }
103
transform_dstreg(struct tgsi_to_rc * ttr,struct rc_dst_register * dst,struct tgsi_full_dst_register * src)104 static void transform_dstreg(
105 struct tgsi_to_rc * ttr,
106 struct rc_dst_register * dst,
107 struct tgsi_full_dst_register * src)
108 {
109 dst->File = translate_register_file(src->Register.File);
110 dst->Index = translate_register_index(ttr, src->Register.File, src->Register.Index);
111 dst->WriteMask = src->Register.WriteMask;
112
113 if (src->Register.Indirect) {
114 ttr->error = true;
115 fprintf(stderr, "r300: Relative addressing of destination operands "
116 "is unsupported.\n");
117 }
118 }
119
transform_srcreg(struct tgsi_to_rc * ttr,struct rc_src_register * dst,struct tgsi_full_src_register * src)120 static void transform_srcreg(
121 struct tgsi_to_rc * ttr,
122 struct rc_src_register * dst,
123 struct tgsi_full_src_register * src)
124 {
125 dst->File = translate_register_file(src->Register.File);
126 int index = translate_register_index(ttr, src->Register.File, src->Register.Index);
127 /* Negative offsets to relative addressing should have been lowered in NIR */
128 assert(index >= 0);
129 /* Also check for overflow */
130 if (index >= RC_REGISTER_MAX_INDEX) {
131 ttr->error = true;
132 fprintf(stderr, "r300: Register index too high.\n");
133 }
134 dst->Index = index;
135 dst->RelAddr = src->Register.Indirect;
136 dst->Swizzle = tgsi_util_get_full_src_register_swizzle(src, 0);
137 dst->Swizzle |= tgsi_util_get_full_src_register_swizzle(src, 1) << 3;
138 dst->Swizzle |= tgsi_util_get_full_src_register_swizzle(src, 2) << 6;
139 dst->Swizzle |= tgsi_util_get_full_src_register_swizzle(src, 3) << 9;
140 dst->Abs = src->Register.Absolute;
141 dst->Negate = src->Register.Negate ? RC_MASK_XYZW : 0;
142 }
143
transform_texture(struct rc_instruction * dst,struct tgsi_instruction_texture src)144 static void transform_texture(struct rc_instruction * dst, struct tgsi_instruction_texture src)
145 {
146 switch(src.Texture) {
147 case TGSI_TEXTURE_1D:
148 dst->U.I.TexSrcTarget = RC_TEXTURE_1D;
149 break;
150 case TGSI_TEXTURE_2D:
151 dst->U.I.TexSrcTarget = RC_TEXTURE_2D;
152 break;
153 case TGSI_TEXTURE_3D:
154 dst->U.I.TexSrcTarget = RC_TEXTURE_3D;
155 break;
156 case TGSI_TEXTURE_CUBE:
157 dst->U.I.TexSrcTarget = RC_TEXTURE_CUBE;
158 break;
159 case TGSI_TEXTURE_RECT:
160 dst->U.I.TexSrcTarget = RC_TEXTURE_RECT;
161 break;
162 case TGSI_TEXTURE_1D_ARRAY:
163 dst->U.I.TexSrcTarget = RC_TEXTURE_1D_ARRAY;
164 break;
165 case TGSI_TEXTURE_2D_ARRAY:
166 dst->U.I.TexSrcTarget = RC_TEXTURE_2D_ARRAY;
167 break;
168 default:
169 unreachable();
170 break;
171 }
172 dst->U.I.TexSwizzle = RC_SWIZZLE_XYZW;
173 }
174
transform_instruction(struct tgsi_to_rc * ttr,struct tgsi_full_instruction * src)175 static void transform_instruction(struct tgsi_to_rc * ttr, struct tgsi_full_instruction * src)
176 {
177 struct rc_instruction * dst;
178 int i;
179
180 dst = rc_insert_new_instruction(ttr->compiler, ttr->compiler->Program.Instructions.Prev);
181 dst->U.I.Opcode = translate_opcode(src->Instruction.Opcode);
182 if (!ttr->compiler->is_r500 && dst->U.I.Opcode == RC_OPCODE_BGNLOOP && ttr->error == false) {
183 ttr->error = true;
184 fprintf(stderr, "r300: Dynamic loops are not supported on R3xx/R4xx.\n");
185 }
186 if (!ttr->compiler->is_r500 && dst->U.I.Opcode == RC_OPCODE_IF && ttr->error == false) {
187 ttr->error = true;
188 fprintf(stderr, "r300: Branches are not supported on R3xx/R4xx.\n");
189 }
190
191 dst->U.I.SaturateMode = translate_saturate(src->Instruction.Saturate);
192
193 if (src->Instruction.NumDstRegs)
194 transform_dstreg(ttr, &dst->U.I.DstReg, &src->Dst[0]);
195
196 for(i = 0; i < src->Instruction.NumSrcRegs; ++i) {
197 if (src->Src[i].Register.File == TGSI_FILE_SAMPLER)
198 dst->U.I.TexSrcUnit = src->Src[i].Register.Index;
199 else
200 transform_srcreg(ttr, &dst->U.I.SrcReg[i], &src->Src[i]);
201 }
202
203 /* Texturing. */
204 if (src->Instruction.Texture)
205 transform_texture(dst, src->Texture);
206 }
207
handle_immediate(struct tgsi_to_rc * ttr,struct tgsi_full_immediate * imm,unsigned index)208 static void handle_immediate(struct tgsi_to_rc * ttr,
209 struct tgsi_full_immediate * imm,
210 unsigned index)
211 {
212 struct rc_constant constant;
213
214 constant.Type = RC_CONSTANT_IMMEDIATE;
215 constant.UseMask = RC_MASK_XYZW;
216 for (unsigned i = 0; i < 4; ++i)
217 constant.u.Immediate[i] = imm->u[i].Float;
218 rc_constants_add(&ttr->compiler->Program.Constants, &constant);
219 }
220
r300_tgsi_to_rc(struct tgsi_to_rc * ttr,const struct tgsi_token * tokens)221 void r300_tgsi_to_rc(struct tgsi_to_rc * ttr,
222 const struct tgsi_token * tokens)
223 {
224 struct tgsi_full_instruction *inst;
225 struct tgsi_parse_context parser;
226 unsigned imm_index = 0;
227 int i;
228
229 ttr->error = false;
230
231 /* Allocate constants placeholders.
232 *
233 * Note: What if declared constants are not contiguous? */
234 for(i = 0; i <= ttr->info->file_max[TGSI_FILE_CONSTANT]; ++i) {
235 struct rc_constant constant;
236 memset(&constant, 0, sizeof(constant));
237 constant.Type = RC_CONSTANT_EXTERNAL;
238 constant.UseMask = RC_MASK_XYZW;
239 constant.u.External = i;
240 rc_constants_add(&ttr->compiler->Program.Constants, &constant);
241 }
242
243 ttr->immediate_offset = ttr->compiler->Program.Constants.Count;
244
245 tgsi_parse_init(&parser, tokens);
246
247 while (!tgsi_parse_end_of_tokens(&parser)) {
248 tgsi_parse_token(&parser);
249
250 switch (parser.FullToken.Token.Type) {
251 case TGSI_TOKEN_TYPE_DECLARATION:
252 break;
253 case TGSI_TOKEN_TYPE_IMMEDIATE:
254 handle_immediate(ttr, &parser.FullToken.FullImmediate, imm_index);
255 imm_index++;
256 break;
257 case TGSI_TOKEN_TYPE_INSTRUCTION:
258 inst = &parser.FullToken.FullInstruction;
259 if (inst->Instruction.Opcode == TGSI_OPCODE_END) {
260 break;
261 }
262
263 transform_instruction(ttr, inst);
264 break;
265 }
266 }
267
268 tgsi_parse_free(&parser);
269
270 rc_calculate_inputs_outputs(ttr->compiler);
271 }
272