1 /*
2 * Copyright (C) 2014 Rob Clark <robclark@freedesktop.org>
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice (including the next
12 * paragraph) shall be included in all copies or substantial portions of the
13 * Software.
14 *
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 * SOFTWARE.
22 *
23 * Authors:
24 * Rob Clark <robclark@freedesktop.org>
25 */
26
27 #include <stdarg.h>
28 #include <stdio.h>
29
30 #include "ir3.h"
31
32 #define PTRID(x) ((unsigned long)(x))
33
34 /* ansi escape sequences: */
35 #define RESET "\x1b[0m"
36 #define RED "\x1b[0;31m"
37 #define GREEN "\x1b[0;32m"
38 #define BLUE "\x1b[0;34m"
39 #define MAGENTA "\x1b[0;35m"
40
41 /* syntax coloring, mostly to make it easier to see different sorts of
42 * srcs (immediate, constant, ssa, array, ...)
43 */
44 #define SYN_REG(x) RED x RESET
45 #define SYN_IMMED(x) GREEN x RESET
46 #define SYN_CONST(x) GREEN x RESET
47 #define SYN_SSA(x) BLUE x RESET
48 #define SYN_ARRAY(x) MAGENTA x RESET
49
50 static const char *
type_name(type_t type)51 type_name(type_t type)
52 {
53 static const char *type_names[] = {
54 [TYPE_F16] = "f16",
55 [TYPE_F32] = "f32",
56 [TYPE_U16] = "u16",
57 [TYPE_U32] = "u32",
58 [TYPE_S16] = "s16",
59 [TYPE_S32] = "s32",
60 [TYPE_U8] = "u8",
61 [TYPE_S8] = "s8",
62 };
63 return type_names[type];
64 }
65
print_instr_name(struct ir3_instruction * instr,bool flags)66 static void print_instr_name(struct ir3_instruction *instr, bool flags)
67 {
68 if (!instr)
69 return;
70 #ifdef DEBUG
71 printf("%04u:", instr->serialno);
72 #endif
73 printf("%04u:", instr->name);
74 printf("%04u:", instr->ip);
75 if (instr->flags & IR3_INSTR_UNUSED) {
76 printf("XXX: ");
77 } else {
78 printf("%03u: ", instr->use_count);
79 }
80
81 if (flags) {
82 printf("\t");
83 if (instr->flags & IR3_INSTR_SY)
84 printf("(sy)");
85 if (instr->flags & IR3_INSTR_SS)
86 printf("(ss)");
87 if (instr->flags & IR3_INSTR_JP)
88 printf("(jp)");
89 if (instr->repeat)
90 printf("(rpt%d)", instr->repeat);
91 if (instr->nop)
92 printf("(nop%d)", instr->nop);
93 if (instr->flags & IR3_INSTR_UL)
94 printf("(ul)");
95 } else {
96 printf(" ");
97 }
98
99 if (is_meta(instr)) {
100 switch (instr->opc) {
101 case OPC_META_INPUT: printf("_meta:in"); break;
102 case OPC_META_SPLIT: printf("_meta:split"); break;
103 case OPC_META_COLLECT: printf("_meta:collect"); break;
104 case OPC_META_TEX_PREFETCH: printf("_meta:tex_prefetch"); break;
105
106 /* shouldn't hit here.. just for debugging: */
107 default: printf("_meta:%d", instr->opc); break;
108 }
109 } else if (instr->opc == OPC_MOV) {
110 if (instr->cat1.src_type == instr->cat1.dst_type)
111 printf("mov");
112 else
113 printf("cov");
114 printf(".%s%s", type_name(instr->cat1.src_type),
115 type_name(instr->cat1.dst_type));
116 } else {
117 printf("%s", disasm_a3xx_instr_name(instr->opc));
118 if (instr->flags & IR3_INSTR_3D)
119 printf(".3d");
120 if (instr->flags & IR3_INSTR_A)
121 printf(".a");
122 if (instr->flags & IR3_INSTR_O)
123 printf(".o");
124 if (instr->flags & IR3_INSTR_P)
125 printf(".p");
126 if (instr->flags & IR3_INSTR_S)
127 printf(".s");
128 if (instr->flags & IR3_INSTR_A1EN)
129 printf(".a1en");
130 if (instr->opc == OPC_LDC)
131 printf(".offset%d", instr->cat6.d);
132 if (instr->flags & IR3_INSTR_B) {
133 printf(".base%d",
134 is_tex(instr) ? instr->cat5.tex_base : instr->cat6.base);
135 }
136 if (instr->flags & IR3_INSTR_S2EN)
137 printf(".s2en");
138
139 static const char *cond[0x7] = {
140 "lt",
141 "le",
142 "gt",
143 "ge",
144 "eq",
145 "ne",
146 };
147
148 switch (instr->opc) {
149 case OPC_CMPS_F:
150 case OPC_CMPS_U:
151 case OPC_CMPS_S:
152 case OPC_CMPV_F:
153 case OPC_CMPV_U:
154 case OPC_CMPV_S:
155 printf(".%s", cond[instr->cat2.condition & 0x7]);
156 break;
157 default:
158 break;
159 }
160 }
161 }
162
print_reg_name(struct ir3_register * reg)163 static void print_reg_name(struct ir3_register *reg)
164 {
165 if ((reg->flags & (IR3_REG_FABS | IR3_REG_SABS)) &&
166 (reg->flags & (IR3_REG_FNEG | IR3_REG_SNEG | IR3_REG_BNOT)))
167 printf("(absneg)");
168 else if (reg->flags & (IR3_REG_FNEG | IR3_REG_SNEG | IR3_REG_BNOT))
169 printf("(neg)");
170 else if (reg->flags & (IR3_REG_FABS | IR3_REG_SABS))
171 printf("(abs)");
172
173 if (reg->flags & IR3_REG_R)
174 printf("(r)");
175
176 if (reg->flags & IR3_REG_HIGH)
177 printf("H");
178 if (reg->flags & IR3_REG_HALF)
179 printf("h");
180
181 if (reg->flags & IR3_REG_IMMED) {
182 printf(SYN_IMMED("imm[%f,%d,0x%x]"), reg->fim_val, reg->iim_val, reg->iim_val);
183 } else if (reg->flags & IR3_REG_ARRAY) {
184 printf(SYN_ARRAY("arr[id=%u, offset=%d, size=%u"), reg->array.id,
185 reg->array.offset, reg->size);
186 /* for ARRAY we could have null src, for example first write
187 * instruction..
188 */
189 if (reg->instr) {
190 printf(SYN_ARRAY(", "));
191 printf(SYN_SSA("_["));
192 print_instr_name(reg->instr, false);
193 printf(SYN_SSA("]"));
194 }
195 printf(SYN_ARRAY("]"));
196 } else if (reg->flags & IR3_REG_SSA) {
197 printf(SYN_SSA("_["));
198 print_instr_name(reg->instr, false);
199 printf(SYN_SSA("]"));
200 } else if (reg->flags & IR3_REG_RELATIV) {
201 if (reg->flags & IR3_REG_CONST)
202 printf(SYN_CONST("c<a0.x + %d>"), reg->array.offset);
203 else
204 printf(SYN_REG("r<a0.x + %d>")" (%u)", reg->array.offset, reg->size);
205 } else {
206 if (reg->flags & IR3_REG_CONST)
207 printf(SYN_CONST("c%u.%c"), reg_num(reg), "xyzw"[reg_comp(reg)]);
208 else
209 printf(SYN_REG("r%u.%c"), reg_num(reg), "xyzw"[reg_comp(reg)]);
210 }
211
212 if (reg->wrmask > 0x1)
213 printf(" (wrmask=0x%x)", reg->wrmask);
214 }
215
216 static void
tab(int lvl)217 tab(int lvl)
218 {
219 for (int i = 0; i < lvl; i++)
220 printf("\t");
221 }
222
223 static void
print_instr(struct ir3_instruction * instr,int lvl)224 print_instr(struct ir3_instruction *instr, int lvl)
225 {
226 unsigned i;
227
228 tab(lvl);
229
230 print_instr_name(instr, true);
231
232 if (is_tex(instr)) {
233 printf(" (%s)(", type_name(instr->cat5.type));
234 for (i = 0; i < 4; i++)
235 if (instr->regs[0]->wrmask & (1 << i))
236 printf("%c", "xyzw"[i]);
237 printf(")");
238 } else if (instr->regs_count > 0) {
239 printf(" ");
240 }
241
242 for (i = 0; i < instr->regs_count; i++) {
243 struct ir3_register *reg = instr->regs[i];
244
245 printf(i ? ", " : "");
246 print_reg_name(reg);
247 }
248
249 if (is_tex(instr) && !(instr->flags & IR3_INSTR_S2EN)) {
250 if (!!(instr->flags & IR3_INSTR_B)) {
251 if (!!(instr->flags & IR3_INSTR_A1EN)) {
252 printf(", s#%d", instr->cat5.samp);
253 } else {
254 printf(", s#%d, t#%d", instr->cat5.samp & 0xf,
255 instr->cat5.samp >> 4);
256 }
257 } else {
258 printf(", s#%d, t#%d", instr->cat5.samp, instr->cat5.tex);
259 }
260 }
261
262 if (instr->address) {
263 printf(", address=_");
264 printf("[");
265 print_instr_name(instr->address, false);
266 printf("]");
267 }
268
269 if (instr->cp.left) {
270 printf(", left=_");
271 printf("[");
272 print_instr_name(instr->cp.left, false);
273 printf("]");
274 }
275
276 if (instr->cp.right) {
277 printf(", right=_");
278 printf("[");
279 print_instr_name(instr->cp.right, false);
280 printf("]");
281 }
282
283 if (instr->opc == OPC_META_SPLIT) {
284 printf(", off=%d", instr->split.off);
285 } else if (instr->opc == OPC_META_TEX_PREFETCH) {
286 printf(", tex=%d, samp=%d, input_offset=%d", instr->prefetch.tex,
287 instr->prefetch.samp, instr->prefetch.input_offset);
288 }
289
290 if (is_flow(instr) && instr->cat0.target) {
291 /* the predicate register src is implied: */
292 if (instr->opc == OPC_B) {
293 printf("r %sp0.x", instr->cat0.inv ? "!" : "");
294 }
295 printf(", target=block%u", block_id(instr->cat0.target));
296 }
297
298 if (instr->deps_count) {
299 printf(", false-deps:");
300 for (unsigned i = 0; i < instr->deps_count; i++) {
301 if (i > 0)
302 printf(", ");
303 printf("_[");
304 print_instr_name(instr->deps[i], false);
305 printf("]");
306 }
307 }
308
309 printf("\n");
310 }
311
ir3_print_instr(struct ir3_instruction * instr)312 void ir3_print_instr(struct ir3_instruction *instr)
313 {
314 print_instr(instr, 0);
315 }
316
317 static void
print_block(struct ir3_block * block,int lvl)318 print_block(struct ir3_block *block, int lvl)
319 {
320 tab(lvl); printf("block%u {\n", block_id(block));
321
322 /* computerator (ir3 assembler) doesn't really use blocks for flow
323 * control, so block->predecessors will be null.
324 */
325 if (block->predecessors && block->predecessors->entries > 0) {
326 unsigned i = 0;
327 tab(lvl+1);
328 printf("pred: ");
329 set_foreach (block->predecessors, entry) {
330 struct ir3_block *pred = (struct ir3_block *)entry->key;
331 if (i++)
332 printf(", ");
333 printf("block%u", block_id(pred));
334 }
335 printf("\n");
336 }
337
338 foreach_instr (instr, &block->instr_list) {
339 print_instr(instr, lvl+1);
340 }
341
342 tab(lvl+1); printf("/* keeps:\n");
343 for (unsigned i = 0; i < block->keeps_count; i++) {
344 print_instr(block->keeps[i], lvl+2);
345 }
346 tab(lvl+1); printf(" */\n");
347
348 if (block->successors[1]) {
349 /* leading into if/else: */
350 tab(lvl+1);
351 printf("/* succs: if _[");
352 print_instr_name(block->condition, false);
353 printf("] block%u; else block%u; */\n",
354 block_id(block->successors[0]),
355 block_id(block->successors[1]));
356 } else if (block->successors[0]) {
357 tab(lvl+1);
358 printf("/* succs: block%u; */\n",
359 block_id(block->successors[0]));
360 }
361 tab(lvl); printf("}\n");
362 }
363
364 void
ir3_print(struct ir3 * ir)365 ir3_print(struct ir3 *ir)
366 {
367 foreach_block (block, &ir->block_list)
368 print_block(block, 0);
369
370 foreach_output_n (out, i, ir) {
371 printf("out%d: ", i);
372 print_instr(out, 0);
373 }
374 }
375