← Back to branch summary

~mmach/netext73/mesa-haswell

« back to all changes in this revision

Viewing changes to src/amd/compiler/aco_print_ir.cpp

  • Committer: mmach
  • Date: 2022-09-22 19:56:13 UTC
  • Revision ID: netbit73@gmail.com-20220922195613-wtik9mmy20tmor0i
2022-09-22 21:17:09

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/amd/compiler/aco_print_ir.cpp
1
 
/*
2
 
 * Copyright © 2018 Valve Corporation
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
20
 
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
21
 
 * IN THE SOFTWARE.
22
 
 *
23
 
 */
24
 
 
25
 
#include "aco_builder.h"
26
 
#include "aco_ir.h"
27
 
 
28
 
#include "common/ac_shader_util.h"
29
 
#include "common/sid.h"
30
 
 
31
 
#include <array>
32
 
 
33
 
namespace aco {
34
 
 
35
 
const std::array<const char*, num_reduce_ops> reduce_ops = []()
36
 
{
37
 
   std::array<const char*, num_reduce_ops> ret{};
38
 
   ret[iadd8] = "iadd8";
39
 
   ret[iadd16] = "iadd16";
40
 
   ret[iadd32] = "iadd32";
41
 
   ret[iadd64] = "iadd64";
42
 
   ret[imul8] = "imul8";
43
 
   ret[imul16] = "imul16";
44
 
   ret[imul32] = "imul32";
45
 
   ret[imul64] = "imul64";
46
 
   ret[fadd16] = "fadd16";
47
 
   ret[fadd32] = "fadd32";
48
 
   ret[fadd64] = "fadd64";
49
 
   ret[fmul16] = "fmul16";
50
 
   ret[fmul32] = "fmul32";
51
 
   ret[fmul64] = "fmul64";
52
 
   ret[imin8] = "imin8";
53
 
   ret[imin16] = "imin16";
54
 
   ret[imin32] = "imin32";
55
 
   ret[imin64] = "imin64";
56
 
   ret[imax8] = "imax8";
57
 
   ret[imax16] = "imax16";
58
 
   ret[imax32] = "imax32";
59
 
   ret[imax64] = "imax64";
60
 
   ret[umin8] = "umin8";
61
 
   ret[umin16] = "umin16";
62
 
   ret[umin32] = "umin32";
63
 
   ret[umin64] = "umin64";
64
 
   ret[umax8] = "umax8";
65
 
   ret[umax16] = "umax16";
66
 
   ret[umax32] = "umax32";
67
 
   ret[umax64] = "umax64";
68
 
   ret[fmin16] = "fmin16";
69
 
   ret[fmin32] = "fmin32";
70
 
   ret[fmin64] = "fmin64";
71
 
   ret[fmax16] = "fmax16";
72
 
   ret[fmax32] = "fmax32";
73
 
   ret[fmax64] = "fmax64";
74
 
   ret[iand8] = "iand8";
75
 
   ret[iand16] = "iand16";
76
 
   ret[iand32] = "iand32";
77
 
   ret[iand64] = "iand64";
78
 
   ret[ior8] = "ior8";
79
 
   ret[ior16] = "ior16";
80
 
   ret[ior32] = "ior32";
81
 
   ret[ior64] = "ior64";
82
 
   ret[ixor8] = "ixor8";
83
 
   ret[ixor16] = "ixor16";
84
 
   ret[ixor32] = "ixor32";
85
 
   ret[ixor64] = "ixor64";
86
 
   return ret;
87
 
}();
88
 
 
89
 
static void
90
 
print_reg_class(const RegClass rc, FILE* output)
91
 
{
92
 
   if (rc.is_subdword()) {
93
 
      fprintf(output, " v%ub: ", rc.bytes());
94
 
   } else if (rc.type() == RegType::sgpr) {
95
 
      fprintf(output, " s%u: ", rc.size());
96
 
   } else if (rc.is_linear()) {
97
 
      fprintf(output, " lv%u: ", rc.size());
98
 
   } else {
99
 
      fprintf(output, " v%u: ", rc.size());
100
 
   }
101
 
}
102
 
 
103
 
void
104
 
print_physReg(PhysReg reg, unsigned bytes, FILE* output, unsigned flags)
105
 
{
106
 
   if (reg == 124) {
107
 
      fprintf(output, "m0");
108
 
   } else if (reg == 106) {
109
 
      fprintf(output, "vcc");
110
 
   } else if (reg == 253) {
111
 
      fprintf(output, "scc");
112
 
   } else if (reg == 126) {
113
 
      fprintf(output, "exec");
114
 
   } else {
115
 
      bool is_vgpr = reg / 256;
116
 
      unsigned r = reg % 256;
117
 
      unsigned size = DIV_ROUND_UP(bytes, 4);
118
 
      if (size == 1 && (flags & print_no_ssa)) {
119
 
         fprintf(output, "%c%d", is_vgpr ? 'v' : 's', r);
120
 
      } else {
121
 
         fprintf(output, "%c[%d", is_vgpr ? 'v' : 's', r);
122
 
         if (size > 1)
123
 
            fprintf(output, "-%d]", r + size - 1);
124
 
         else
125
 
            fprintf(output, "]");
126
 
      }
127
 
      if (reg.byte() || bytes % 4)
128
 
         fprintf(output, "[%d:%d]", reg.byte() * 8, (reg.byte() + bytes) * 8);
129
 
   }
130
 
}
131
 
 
132
 
static void
133
 
print_constant(uint8_t reg, FILE* output)
134
 
{
135
 
   if (reg >= 128 && reg <= 192) {
136
 
      fprintf(output, "%d", reg - 128);
137
 
      return;
138
 
   } else if (reg >= 192 && reg <= 208) {
139
 
      fprintf(output, "%d", 192 - reg);
140
 
      return;
141
 
   }
142
 
 
143
 
   switch (reg) {
144
 
   case 240: fprintf(output, "0.5"); break;
145
 
   case 241: fprintf(output, "-0.5"); break;
146
 
   case 242: fprintf(output, "1.0"); break;
147
 
   case 243: fprintf(output, "-1.0"); break;
148
 
   case 244: fprintf(output, "2.0"); break;
149
 
   case 245: fprintf(output, "-2.0"); break;
150
 
   case 246: fprintf(output, "4.0"); break;
151
 
   case 247: fprintf(output, "-4.0"); break;
152
 
   case 248: fprintf(output, "1/(2*PI)"); break;
153
 
   }
154
 
}
155
 
 
156
 
void
157
 
aco_print_operand(const Operand* operand, FILE* output, unsigned flags)
158
 
{
159
 
   if (operand->isLiteral() || (operand->isConstant() && operand->bytes() == 1)) {
160
 
      if (operand->bytes() == 1)
161
 
         fprintf(output, "0x%.2x", operand->constantValue());
162
 
      else if (operand->bytes() == 2)
163
 
         fprintf(output, "0x%.4x", operand->constantValue());
164
 
      else
165
 
         fprintf(output, "0x%x", operand->constantValue());
166
 
   } else if (operand->isConstant()) {
167
 
      print_constant(operand->physReg().reg(), output);
168
 
   } else if (operand->isUndefined()) {
169
 
      print_reg_class(operand->regClass(), output);
170
 
      fprintf(output, "undef");
171
 
   } else {
172
 
      if (operand->isLateKill())
173
 
         fprintf(output, "(latekill)");
174
 
      if (operand->is16bit())
175
 
         fprintf(output, "(is16bit)");
176
 
      if (operand->is24bit())
177
 
         fprintf(output, "(is24bit)");
178
 
      if ((flags & print_kill) && operand->isKill())
179
 
         fprintf(output, "(kill)");
180
 
 
181
 
      if (!(flags & print_no_ssa))
182
 
         fprintf(output, "%%%d%s", operand->tempId(), operand->isFixed() ? ":" : "");
183
 
 
184
 
      if (operand->isFixed())
185
 
         print_physReg(operand->physReg(), operand->bytes(), output, flags);
186
 
   }
187
 
}
188
 
 
189
 
static void
190
 
print_definition(const Definition* definition, FILE* output, unsigned flags)
191
 
{
192
 
   if (!(flags & print_no_ssa))
193
 
      print_reg_class(definition->regClass(), output);
194
 
   if (definition->isPrecise())
195
 
      fprintf(output, "(precise)");
196
 
   if (definition->isNUW())
197
 
      fprintf(output, "(nuw)");
198
 
   if (definition->isNoCSE())
199
 
      fprintf(output, "(noCSE)");
200
 
   if ((flags & print_kill) && definition->isKill())
201
 
      fprintf(output, "(kill)");
202
 
   if (!(flags & print_no_ssa))
203
 
      fprintf(output, "%%%d%s", definition->tempId(), definition->isFixed() ? ":" : "");
204
 
 
205
 
   if (definition->isFixed())
206
 
      print_physReg(definition->physReg(), definition->bytes(), output, flags);
207
 
}
208
 
 
209
 
static void
210
 
print_storage(storage_class storage, FILE* output)
211
 
{
212
 
   fprintf(output, " storage:");
213
 
   int printed = 0;
214
 
   if (storage & storage_buffer)
215
 
      printed += fprintf(output, "%sbuffer", printed ? "," : "");
216
 
   if (storage & storage_atomic_counter)
217
 
      printed += fprintf(output, "%satomic_counter", printed ? "," : "");
218
 
   if (storage & storage_image)
219
 
      printed += fprintf(output, "%simage", printed ? "," : "");
220
 
   if (storage & storage_shared)
221
 
      printed += fprintf(output, "%sshared", printed ? "," : "");
222
 
   if (storage & storage_task_payload)
223
 
      printed += fprintf(output, "%stask_payload", printed ? "," : "");
224
 
   if (storage & storage_vmem_output)
225
 
      printed += fprintf(output, "%svmem_output", printed ? "," : "");
226
 
   if (storage & storage_scratch)
227
 
      printed += fprintf(output, "%sscratch", printed ? "," : "");
228
 
   if (storage & storage_vgpr_spill)
229
 
      printed += fprintf(output, "%svgpr_spill", printed ? "," : "");
230
 
}
231
 
 
232
 
static void
233
 
print_semantics(memory_semantics sem, FILE* output)
234
 
{
235
 
   fprintf(output, " semantics:");
236
 
   int printed = 0;
237
 
   if (sem & semantic_acquire)
238
 
      printed += fprintf(output, "%sacquire", printed ? "," : "");
239
 
   if (sem & semantic_release)
240
 
      printed += fprintf(output, "%srelease", printed ? "," : "");
241
 
   if (sem & semantic_volatile)
242
 
      printed += fprintf(output, "%svolatile", printed ? "," : "");
243
 
   if (sem & semantic_private)
244
 
      printed += fprintf(output, "%sprivate", printed ? "," : "");
245
 
   if (sem & semantic_can_reorder)
246
 
      printed += fprintf(output, "%sreorder", printed ? "," : "");
247
 
   if (sem & semantic_atomic)
248
 
      printed += fprintf(output, "%satomic", printed ? "," : "");
249
 
   if (sem & semantic_rmw)
250
 
      printed += fprintf(output, "%srmw", printed ? "," : "");
251
 
}
252
 
 
253
 
static void
254
 
print_scope(sync_scope scope, FILE* output, const char* prefix = "scope")
255
 
{
256
 
   fprintf(output, " %s:", prefix);
257
 
   switch (scope) {
258
 
   case scope_invocation: fprintf(output, "invocation"); break;
259
 
   case scope_subgroup: fprintf(output, "subgroup"); break;
260
 
   case scope_workgroup: fprintf(output, "workgroup"); break;
261
 
   case scope_queuefamily: fprintf(output, "queuefamily"); break;
262
 
   case scope_device: fprintf(output, "device"); break;
263
 
   }
264
 
}
265
 
 
266
 
static void
267
 
print_sync(memory_sync_info sync, FILE* output)
268
 
{
269
 
   print_storage(sync.storage, output);
270
 
   print_semantics(sync.semantics, output);
271
 
   print_scope(sync.scope, output);
272
 
}
273
 
 
274
 
static void
275
 
print_instr_format_specific(const Instruction* instr, FILE* output)
276
 
{
277
 
   switch (instr->format) {
278
 
   case Format::SOPK: {
279
 
      const SOPK_instruction& sopk = instr->sopk();
280
 
      fprintf(output, " imm:%d", sopk.imm & 0x8000 ? (sopk.imm - 65536) : sopk.imm);
281
 
      break;
282
 
   }
283
 
   case Format::SOPP: {
284
 
      uint16_t imm = instr->sopp().imm;
285
 
      switch (instr->opcode) {
286
 
      case aco_opcode::s_waitcnt: {
287
 
         /* we usually should check the chip class for vmcnt/lgkm, but
288
 
          * insert_waitcnt() should fill it in regardless. */
289
 
         unsigned vmcnt = (imm & 0xF) | ((imm & (0x3 << 14)) >> 10);
290
 
         if (vmcnt != 63)
291
 
            fprintf(output, " vmcnt(%d)", vmcnt);
292
 
         if (((imm >> 4) & 0x7) < 0x7)
293
 
            fprintf(output, " expcnt(%d)", (imm >> 4) & 0x7);
294
 
         if (((imm >> 8) & 0x3F) < 0x3F)
295
 
            fprintf(output, " lgkmcnt(%d)", (imm >> 8) & 0x3F);
296
 
         break;
297
 
      }
298
 
      case aco_opcode::s_endpgm:
299
 
      case aco_opcode::s_endpgm_saved:
300
 
      case aco_opcode::s_endpgm_ordered_ps_done:
301
 
      case aco_opcode::s_wakeup:
302
 
      case aco_opcode::s_barrier:
303
 
      case aco_opcode::s_icache_inv:
304
 
      case aco_opcode::s_ttracedata:
305
 
      case aco_opcode::s_set_gpr_idx_off: {
306
 
         break;
307
 
      }
308
 
      case aco_opcode::s_sendmsg: {
309
 
         unsigned id = imm & sendmsg_id_mask;
310
 
         switch (id) {
311
 
         case sendmsg_none: fprintf(output, " sendmsg(MSG_NONE)"); break;
312
 
         case _sendmsg_gs:
313
 
            fprintf(output, " sendmsg(gs%s%s, %u)", imm & 0x10 ? ", cut" : "",
314
 
                    imm & 0x20 ? ", emit" : "", imm >> 8);
315
 
            break;
316
 
         case _sendmsg_gs_done:
317
 
            fprintf(output, " sendmsg(gs_done%s%s, %u)", imm & 0x10 ? ", cut" : "",
318
 
                    imm & 0x20 ? ", emit" : "", imm >> 8);
319
 
            break;
320
 
         case sendmsg_save_wave: fprintf(output, " sendmsg(save_wave)"); break;
321
 
         case sendmsg_stall_wave_gen: fprintf(output, " sendmsg(stall_wave_gen)"); break;
322
 
         case sendmsg_halt_waves: fprintf(output, " sendmsg(halt_waves)"); break;
323
 
         case sendmsg_ordered_ps_done: fprintf(output, " sendmsg(ordered_ps_done)"); break;
324
 
         case sendmsg_early_prim_dealloc: fprintf(output, " sendmsg(early_prim_dealloc)"); break;
325
 
         case sendmsg_gs_alloc_req: fprintf(output, " sendmsg(gs_alloc_req)"); break;
326
 
         }
327
 
         break;
328
 
      }
329
 
      default: {
330
 
         if (imm)
331
 
            fprintf(output, " imm:%u", imm);
332
 
         break;
333
 
      }
334
 
      }
335
 
      if (instr->sopp().block != -1)
336
 
         fprintf(output, " block:BB%d", instr->sopp().block);
337
 
      break;
338
 
   }
339
 
   case Format::SMEM: {
340
 
      const SMEM_instruction& smem = instr->smem();
341
 
      if (smem.glc)
342
 
         fprintf(output, " glc");
343
 
      if (smem.dlc)
344
 
         fprintf(output, " dlc");
345
 
      if (smem.nv)
346
 
         fprintf(output, " nv");
347
 
      print_sync(smem.sync, output);
348
 
      break;
349
 
   }
350
 
   case Format::VINTRP: {
351
 
      const Interp_instruction& vintrp = instr->vintrp();
352
 
      fprintf(output, " attr%d.%c", vintrp.attribute, "xyzw"[vintrp.component]);
353
 
      break;
354
 
   }
355
 
   case Format::DS: {
356
 
      const DS_instruction& ds = instr->ds();
357
 
      if (ds.offset0)
358
 
         fprintf(output, " offset0:%u", ds.offset0);
359
 
      if (ds.offset1)
360
 
         fprintf(output, " offset1:%u", ds.offset1);
361
 
      if (ds.gds)
362
 
         fprintf(output, " gds");
363
 
      print_sync(ds.sync, output);
364
 
      break;
365
 
   }
366
 
   case Format::MUBUF: {
367
 
      const MUBUF_instruction& mubuf = instr->mubuf();
368
 
      if (mubuf.offset)
369
 
         fprintf(output, " offset:%u", mubuf.offset);
370
 
      if (mubuf.offen)
371
 
         fprintf(output, " offen");
372
 
      if (mubuf.idxen)
373
 
         fprintf(output, " idxen");
374
 
      if (mubuf.addr64)
375
 
         fprintf(output, " addr64");
376
 
      if (mubuf.glc)
377
 
         fprintf(output, " glc");
378
 
      if (mubuf.dlc)
379
 
         fprintf(output, " dlc");
380
 
      if (mubuf.slc)
381
 
         fprintf(output, " slc");
382
 
      if (mubuf.tfe)
383
 
         fprintf(output, " tfe");
384
 
      if (mubuf.lds)
385
 
         fprintf(output, " lds");
386
 
      if (mubuf.disable_wqm)
387
 
         fprintf(output, " disable_wqm");
388
 
      print_sync(mubuf.sync, output);
389
 
      break;
390
 
   }
391
 
   case Format::MIMG: {
392
 
      const MIMG_instruction& mimg = instr->mimg();
393
 
      unsigned identity_dmask =
394
 
         !instr->definitions.empty() ? (1 << instr->definitions[0].size()) - 1 : 0xf;
395
 
      if ((mimg.dmask & identity_dmask) != identity_dmask)
396
 
         fprintf(output, " dmask:%s%s%s%s", mimg.dmask & 0x1 ? "x" : "",
397
 
                 mimg.dmask & 0x2 ? "y" : "", mimg.dmask & 0x4 ? "z" : "",
398
 
                 mimg.dmask & 0x8 ? "w" : "");
399
 
      switch (mimg.dim) {
400
 
      case ac_image_1d: fprintf(output, " 1d"); break;
401
 
      case ac_image_2d: fprintf(output, " 2d"); break;
402
 
      case ac_image_3d: fprintf(output, " 3d"); break;
403
 
      case ac_image_cube: fprintf(output, " cube"); break;
404
 
      case ac_image_1darray: fprintf(output, " 1darray"); break;
405
 
      case ac_image_2darray: fprintf(output, " 2darray"); break;
406
 
      case ac_image_2dmsaa: fprintf(output, " 2dmsaa"); break;
407
 
      case ac_image_2darraymsaa: fprintf(output, " 2darraymsaa"); break;
408
 
      }
409
 
      if (mimg.unrm)
410
 
         fprintf(output, " unrm");
411
 
      if (mimg.glc)
412
 
         fprintf(output, " glc");
413
 
      if (mimg.dlc)
414
 
         fprintf(output, " dlc");
415
 
      if (mimg.slc)
416
 
         fprintf(output, " slc");
417
 
      if (mimg.tfe)
418
 
         fprintf(output, " tfe");
419
 
      if (mimg.da)
420
 
         fprintf(output, " da");
421
 
      if (mimg.lwe)
422
 
         fprintf(output, " lwe");
423
 
      if (mimg.r128 || mimg.a16)
424
 
         fprintf(output, " r128/a16");
425
 
      if (mimg.d16)
426
 
         fprintf(output, " d16");
427
 
      if (mimg.disable_wqm)
428
 
         fprintf(output, " disable_wqm");
429
 
      print_sync(mimg.sync, output);
430
 
      break;
431
 
   }
432
 
   case Format::EXP: {
433
 
      const Export_instruction& exp = instr->exp();
434
 
      unsigned identity_mask = exp.compressed ? 0x5 : 0xf;
435
 
      if ((exp.enabled_mask & identity_mask) != identity_mask)
436
 
         fprintf(output, " en:%c%c%c%c", exp.enabled_mask & 0x1 ? 'r' : '*',
437
 
                 exp.enabled_mask & 0x2 ? 'g' : '*', exp.enabled_mask & 0x4 ? 'b' : '*',
438
 
                 exp.enabled_mask & 0x8 ? 'a' : '*');
439
 
      if (exp.compressed)
440
 
         fprintf(output, " compr");
441
 
      if (exp.done)
442
 
         fprintf(output, " done");
443
 
      if (exp.valid_mask)
444
 
         fprintf(output, " vm");
445
 
 
446
 
      if (exp.dest <= V_008DFC_SQ_EXP_MRT + 7)
447
 
         fprintf(output, " mrt%d", exp.dest - V_008DFC_SQ_EXP_MRT);
448
 
      else if (exp.dest == V_008DFC_SQ_EXP_MRTZ)
449
 
         fprintf(output, " mrtz");
450
 
      else if (exp.dest == V_008DFC_SQ_EXP_NULL)
451
 
         fprintf(output, " null");
452
 
      else if (exp.dest >= V_008DFC_SQ_EXP_POS && exp.dest <= V_008DFC_SQ_EXP_POS + 3)
453
 
         fprintf(output, " pos%d", exp.dest - V_008DFC_SQ_EXP_POS);
454
 
      else if (exp.dest >= V_008DFC_SQ_EXP_PARAM && exp.dest <= V_008DFC_SQ_EXP_PARAM + 31)
455
 
         fprintf(output, " param%d", exp.dest - V_008DFC_SQ_EXP_PARAM);
456
 
      break;
457
 
   }
458
 
   case Format::PSEUDO_BRANCH: {
459
 
      const Pseudo_branch_instruction& branch = instr->branch();
460
 
      /* Note: BB0 cannot be a branch target */
461
 
      if (branch.target[0] != 0)
462
 
         fprintf(output, " BB%d", branch.target[0]);
463
 
      if (branch.target[1] != 0)
464
 
         fprintf(output, ", BB%d", branch.target[1]);
465
 
      break;
466
 
   }
467
 
   case Format::PSEUDO_REDUCTION: {
468
 
      const Pseudo_reduction_instruction& reduce = instr->reduction();
469
 
      fprintf(output, " op:%s", reduce_ops[reduce.reduce_op]);
470
 
      if (reduce.cluster_size)
471
 
         fprintf(output, " cluster_size:%u", reduce.cluster_size);
472
 
      break;
473
 
   }
474
 
   case Format::PSEUDO_BARRIER: {
475
 
      const Pseudo_barrier_instruction& barrier = instr->barrier();
476
 
      print_sync(barrier.sync, output);
477
 
      print_scope(barrier.exec_scope, output, "exec_scope");
478
 
      break;
479
 
   }
480
 
   case Format::FLAT:
481
 
   case Format::GLOBAL:
482
 
   case Format::SCRATCH: {
483
 
      const FLAT_instruction& flat = instr->flatlike();
484
 
      if (flat.offset)
485
 
         fprintf(output, " offset:%u", flat.offset);
486
 
      if (flat.glc)
487
 
         fprintf(output, " glc");
488
 
      if (flat.dlc)
489
 
         fprintf(output, " dlc");
490
 
      if (flat.slc)
491
 
         fprintf(output, " slc");
492
 
      if (flat.lds)
493
 
         fprintf(output, " lds");
494
 
      if (flat.nv)
495
 
         fprintf(output, " nv");
496
 
      if (flat.disable_wqm)
497
 
         fprintf(output, " disable_wqm");
498
 
      print_sync(flat.sync, output);
499
 
      break;
500
 
   }
501
 
   case Format::MTBUF: {
502
 
      const MTBUF_instruction& mtbuf = instr->mtbuf();
503
 
      fprintf(output, " dfmt:");
504
 
      switch (mtbuf.dfmt) {
505
 
      case V_008F0C_BUF_DATA_FORMAT_8: fprintf(output, "8"); break;
506
 
      case V_008F0C_BUF_DATA_FORMAT_16: fprintf(output, "16"); break;
507
 
      case V_008F0C_BUF_DATA_FORMAT_8_8: fprintf(output, "8_8"); break;
508
 
      case V_008F0C_BUF_DATA_FORMAT_32: fprintf(output, "32"); break;
509
 
      case V_008F0C_BUF_DATA_FORMAT_16_16: fprintf(output, "16_16"); break;
510
 
      case V_008F0C_BUF_DATA_FORMAT_10_11_11: fprintf(output, "10_11_11"); break;
511
 
      case V_008F0C_BUF_DATA_FORMAT_11_11_10: fprintf(output, "11_11_10"); break;
512
 
      case V_008F0C_BUF_DATA_FORMAT_10_10_10_2: fprintf(output, "10_10_10_2"); break;
513
 
      case V_008F0C_BUF_DATA_FORMAT_2_10_10_10: fprintf(output, "2_10_10_10"); break;
514
 
      case V_008F0C_BUF_DATA_FORMAT_8_8_8_8: fprintf(output, "8_8_8_8"); break;
515
 
      case V_008F0C_BUF_DATA_FORMAT_32_32: fprintf(output, "32_32"); break;
516
 
      case V_008F0C_BUF_DATA_FORMAT_16_16_16_16: fprintf(output, "16_16_16_16"); break;
517
 
      case V_008F0C_BUF_DATA_FORMAT_32_32_32: fprintf(output, "32_32_32"); break;
518
 
      case V_008F0C_BUF_DATA_FORMAT_32_32_32_32: fprintf(output, "32_32_32_32"); break;
519
 
      case V_008F0C_BUF_DATA_FORMAT_RESERVED_15: fprintf(output, "reserved15"); break;
520
 
      }
521
 
      fprintf(output, " nfmt:");
522
 
      switch (mtbuf.nfmt) {
523
 
      case V_008F0C_BUF_NUM_FORMAT_UNORM: fprintf(output, "unorm"); break;
524
 
      case V_008F0C_BUF_NUM_FORMAT_SNORM: fprintf(output, "snorm"); break;
525
 
      case V_008F0C_BUF_NUM_FORMAT_USCALED: fprintf(output, "uscaled"); break;
526
 
      case V_008F0C_BUF_NUM_FORMAT_SSCALED: fprintf(output, "sscaled"); break;
527
 
      case V_008F0C_BUF_NUM_FORMAT_UINT: fprintf(output, "uint"); break;
528
 
      case V_008F0C_BUF_NUM_FORMAT_SINT: fprintf(output, "sint"); break;
529
 
      case V_008F0C_BUF_NUM_FORMAT_SNORM_OGL: fprintf(output, "snorm"); break;
530
 
      case V_008F0C_BUF_NUM_FORMAT_FLOAT: fprintf(output, "float"); break;
531
 
      }
532
 
      if (mtbuf.offset)
533
 
         fprintf(output, " offset:%u", mtbuf.offset);
534
 
      if (mtbuf.offen)
535
 
         fprintf(output, " offen");
536
 
      if (mtbuf.idxen)
537
 
         fprintf(output, " idxen");
538
 
      if (mtbuf.glc)
539
 
         fprintf(output, " glc");
540
 
      if (mtbuf.dlc)
541
 
         fprintf(output, " dlc");
542
 
      if (mtbuf.slc)
543
 
         fprintf(output, " slc");
544
 
      if (mtbuf.tfe)
545
 
         fprintf(output, " tfe");
546
 
      if (mtbuf.disable_wqm)
547
 
         fprintf(output, " disable_wqm");
548
 
      print_sync(mtbuf.sync, output);
549
 
      break;
550
 
   }
551
 
   case Format::VOP3P: {
552
 
      if (instr->vop3p().clamp)
553
 
         fprintf(output, " clamp");
554
 
      break;
555
 
   }
556
 
   default: {
557
 
      break;
558
 
   }
559
 
   }
560
 
   if (instr->isVOP3()) {
561
 
      const VOP3_instruction& vop3 = instr->vop3();
562
 
      switch (vop3.omod) {
563
 
      case 1: fprintf(output, " *2"); break;
564
 
      case 2: fprintf(output, " *4"); break;
565
 
      case 3: fprintf(output, " *0.5"); break;
566
 
      }
567
 
      if (vop3.clamp)
568
 
         fprintf(output, " clamp");
569
 
      if (vop3.opsel & (1 << 3))
570
 
         fprintf(output, " opsel_hi");
571
 
   } else if (instr->isDPP16()) {
572
 
      const DPP16_instruction& dpp = instr->dpp16();
573
 
      if (dpp.dpp_ctrl <= 0xff) {
574
 
         fprintf(output, " quad_perm:[%d,%d,%d,%d]", dpp.dpp_ctrl & 0x3, (dpp.dpp_ctrl >> 2) & 0x3,
575
 
                 (dpp.dpp_ctrl >> 4) & 0x3, (dpp.dpp_ctrl >> 6) & 0x3);
576
 
      } else if (dpp.dpp_ctrl >= 0x101 && dpp.dpp_ctrl <= 0x10f) {
577
 
         fprintf(output, " row_shl:%d", dpp.dpp_ctrl & 0xf);
578
 
      } else if (dpp.dpp_ctrl >= 0x111 && dpp.dpp_ctrl <= 0x11f) {
579
 
         fprintf(output, " row_shr:%d", dpp.dpp_ctrl & 0xf);
580
 
      } else if (dpp.dpp_ctrl >= 0x121 && dpp.dpp_ctrl <= 0x12f) {
581
 
         fprintf(output, " row_ror:%d", dpp.dpp_ctrl & 0xf);
582
 
      } else if (dpp.dpp_ctrl == dpp_wf_sl1) {
583
 
         fprintf(output, " wave_shl:1");
584
 
      } else if (dpp.dpp_ctrl == dpp_wf_rl1) {
585
 
         fprintf(output, " wave_rol:1");
586
 
      } else if (dpp.dpp_ctrl == dpp_wf_sr1) {
587
 
         fprintf(output, " wave_shr:1");
588
 
      } else if (dpp.dpp_ctrl == dpp_wf_rr1) {
589
 
         fprintf(output, " wave_ror:1");
590
 
      } else if (dpp.dpp_ctrl == dpp_row_mirror) {
591
 
         fprintf(output, " row_mirror");
592
 
      } else if (dpp.dpp_ctrl == dpp_row_half_mirror) {
593
 
         fprintf(output, " row_half_mirror");
594
 
      } else if (dpp.dpp_ctrl == dpp_row_bcast15) {
595
 
         fprintf(output, " row_bcast:15");
596
 
      } else if (dpp.dpp_ctrl == dpp_row_bcast31) {
597
 
         fprintf(output, " row_bcast:31");
598
 
      } else {
599
 
         fprintf(output, " dpp_ctrl:0x%.3x", dpp.dpp_ctrl);
600
 
      }
601
 
      if (dpp.row_mask != 0xf)
602
 
         fprintf(output, " row_mask:0x%.1x", dpp.row_mask);
603
 
      if (dpp.bank_mask != 0xf)
604
 
         fprintf(output, " bank_mask:0x%.1x", dpp.bank_mask);
605
 
      if (dpp.bound_ctrl)
606
 
         fprintf(output, " bound_ctrl:1");
607
 
   } else if (instr->isDPP8()) {
608
 
      const DPP8_instruction& dpp = instr->dpp8();
609
 
      fprintf(output, " dpp8:[%d,%d,%d,%d,%d,%d,%d,%d]", dpp.lane_sel[0], dpp.lane_sel[1],
610
 
              dpp.lane_sel[2], dpp.lane_sel[3], dpp.lane_sel[4], dpp.lane_sel[5], dpp.lane_sel[6],
611
 
              dpp.lane_sel[7]);
612
 
   } else if (instr->isSDWA()) {
613
 
      const SDWA_instruction& sdwa = instr->sdwa();
614
 
      switch (sdwa.omod) {
615
 
      case 1: fprintf(output, " *2"); break;
616
 
      case 2: fprintf(output, " *4"); break;
617
 
      case 3: fprintf(output, " *0.5"); break;
618
 
      }
619
 
      if (sdwa.clamp)
620
 
         fprintf(output, " clamp");
621
 
      if (!instr->isVOPC()) {
622
 
         char sext = sdwa.dst_sel.sign_extend() ? 's' : 'u';
623
 
         unsigned offset = sdwa.dst_sel.offset();
624
 
         if (instr->definitions[0].isFixed())
625
 
            offset += instr->definitions[0].physReg().byte();
626
 
         switch (sdwa.dst_sel.size()) {
627
 
         case 1: fprintf(output, " dst_sel:%cbyte%u", sext, offset); break;
628
 
         case 2: fprintf(output, " dst_sel:%cword%u", sext, offset >> 1); break;
629
 
         case 4: fprintf(output, " dst_sel:dword"); break;
630
 
         default: break;
631
 
         }
632
 
         if (instr->definitions[0].bytes() < 4)
633
 
            fprintf(output, " dst_preserve");
634
 
      }
635
 
      for (unsigned i = 0; i < std::min<unsigned>(2, instr->operands.size()); i++) {
636
 
         char sext = sdwa.sel[i].sign_extend() ? 's' : 'u';
637
 
         unsigned offset = sdwa.sel[i].offset();
638
 
         if (instr->operands[i].isFixed())
639
 
            offset += instr->operands[i].physReg().byte();
640
 
         switch (sdwa.sel[i].size()) {
641
 
         case 1: fprintf(output, " src%d_sel:%cbyte%u", i, sext, offset); break;
642
 
         case 2: fprintf(output, " src%d_sel:%cword%u", i, sext, offset >> 1); break;
643
 
         case 4: fprintf(output, " src%d_sel:dword", i); break;
644
 
         default: break;
645
 
         }
646
 
      }
647
 
   }
648
 
}
649
 
 
650
 
void
651
 
aco_print_instr(const Instruction* instr, FILE* output, unsigned flags)
652
 
{
653
 
   if (!instr->definitions.empty()) {
654
 
      for (unsigned i = 0; i < instr->definitions.size(); ++i) {
655
 
         print_definition(&instr->definitions[i], output, flags);
656
 
         if (i + 1 != instr->definitions.size())
657
 
            fprintf(output, ", ");
658
 
      }
659
 
      fprintf(output, " = ");
660
 
   }
661
 
   fprintf(output, "%s", instr_info.name[(int)instr->opcode]);
662
 
   if (instr->operands.size()) {
663
 
      const unsigned num_operands = instr->operands.size();
664
 
      bool* const abs = (bool*)alloca(num_operands * sizeof(bool));
665
 
      bool* const neg = (bool*)alloca(num_operands * sizeof(bool));
666
 
      bool* const opsel = (bool*)alloca(num_operands * sizeof(bool));
667
 
      bool* const f2f32 = (bool*)alloca(num_operands * sizeof(bool));
668
 
      for (unsigned i = 0; i < num_operands; ++i) {
669
 
         abs[i] = false;
670
 
         neg[i] = false;
671
 
         opsel[i] = false;
672
 
         f2f32[i] = false;
673
 
      }
674
 
      bool is_mad_mix = instr->opcode == aco_opcode::v_fma_mix_f32 ||
675
 
                        instr->opcode == aco_opcode::v_fma_mixlo_f16 ||
676
 
                        instr->opcode == aco_opcode::v_fma_mixhi_f16;
677
 
      if (instr->isVOP3()) {
678
 
         const VOP3_instruction& vop3 = instr->vop3();
679
 
         for (unsigned i = 0; i < MIN2(num_operands, 3); ++i) {
680
 
            abs[i] = vop3.abs[i];
681
 
            neg[i] = vop3.neg[i];
682
 
            opsel[i] = vop3.opsel & (1 << i);
683
 
         }
684
 
      } else if (instr->isDPP16()) {
685
 
         const DPP16_instruction& dpp = instr->dpp16();
686
 
         for (unsigned i = 0; i < MIN2(num_operands, 2); ++i) {
687
 
            abs[i] = dpp.abs[i];
688
 
            neg[i] = dpp.neg[i];
689
 
            opsel[i] = false;
690
 
         }
691
 
      } else if (instr->isSDWA()) {
692
 
         const SDWA_instruction& sdwa = instr->sdwa();
693
 
         for (unsigned i = 0; i < MIN2(num_operands, 2); ++i) {
694
 
            abs[i] = sdwa.abs[i];
695
 
            neg[i] = sdwa.neg[i];
696
 
            opsel[i] = false;
697
 
         }
698
 
      } else if (instr->isVOP3P() && is_mad_mix) {
699
 
         const VOP3P_instruction& vop3p = instr->vop3p();
700
 
         for (unsigned i = 0; i < MIN2(num_operands, 3); ++i) {
701
 
            abs[i] = vop3p.neg_hi[i];
702
 
            neg[i] = vop3p.neg_lo[i];
703
 
            f2f32[i] = vop3p.opsel_hi & (1 << i);
704
 
            opsel[i] = f2f32[i] && (vop3p.opsel_lo & (1 << i));
705
 
         }
706
 
      }
707
 
      for (unsigned i = 0; i < num_operands; ++i) {
708
 
         if (i)
709
 
            fprintf(output, ", ");
710
 
         else
711
 
            fprintf(output, " ");
712
 
 
713
 
         if (neg[i])
714
 
            fprintf(output, "-");
715
 
         if (abs[i])
716
 
            fprintf(output, "|");
717
 
         if (opsel[i])
718
 
            fprintf(output, "hi(");
719
 
         else if (f2f32[i])
720
 
            fprintf(output, "lo(");
721
 
         aco_print_operand(&instr->operands[i], output, flags);
722
 
         if (f2f32[i] || opsel[i])
723
 
            fprintf(output, ")");
724
 
         if (abs[i])
725
 
            fprintf(output, "|");
726
 
 
727
 
         if (instr->isVOP3P() && !is_mad_mix) {
728
 
            const VOP3P_instruction& vop3 = instr->vop3p();
729
 
            if ((vop3.opsel_lo & (1 << i)) || !(vop3.opsel_hi & (1 << i))) {
730
 
               fprintf(output, ".%c%c", vop3.opsel_lo & (1 << i) ? 'y' : 'x',
731
 
                       vop3.opsel_hi & (1 << i) ? 'y' : 'x');
732
 
            }
733
 
            if (vop3.neg_lo[i] && vop3.neg_hi[i])
734
 
               fprintf(output, "*[-1,-1]");
735
 
            else if (vop3.neg_lo[i])
736
 
               fprintf(output, "*[-1,1]");
737
 
            else if (vop3.neg_hi[i])
738
 
               fprintf(output, "*[1,-1]");
739
 
         }
740
 
      }
741
 
   }
742
 
   print_instr_format_specific(instr, output);
743
 
}
744
 
 
745
 
static void
746
 
print_block_kind(uint16_t kind, FILE* output)
747
 
{
748
 
   if (kind & block_kind_uniform)
749
 
      fprintf(output, "uniform, ");
750
 
   if (kind & block_kind_top_level)
751
 
      fprintf(output, "top-level, ");
752
 
   if (kind & block_kind_loop_preheader)
753
 
      fprintf(output, "loop-preheader, ");
754
 
   if (kind & block_kind_loop_header)
755
 
      fprintf(output, "loop-header, ");
756
 
   if (kind & block_kind_loop_exit)
757
 
      fprintf(output, "loop-exit, ");
758
 
   if (kind & block_kind_continue)
759
 
      fprintf(output, "continue, ");
760
 
   if (kind & block_kind_break)
761
 
      fprintf(output, "break, ");
762
 
   if (kind & block_kind_continue_or_break)
763
 
      fprintf(output, "continue_or_break, ");
764
 
   if (kind & block_kind_branch)
765
 
      fprintf(output, "branch, ");
766
 
   if (kind & block_kind_merge)
767
 
      fprintf(output, "merge, ");
768
 
   if (kind & block_kind_invert)
769
 
      fprintf(output, "invert, ");
770
 
   if (kind & block_kind_uses_discard)
771
 
      fprintf(output, "discard, ");
772
 
   if (kind & block_kind_needs_lowering)
773
 
      fprintf(output, "needs_lowering, ");
774
 
   if (kind & block_kind_export_end)
775
 
      fprintf(output, "export_end, ");
776
 
}
777
 
 
778
 
static void
779
 
print_stage(Stage stage, FILE* output)
780
 
{
781
 
   fprintf(output, "ACO shader stage: ");
782
 
 
783
 
   if (stage == compute_cs)
784
 
      fprintf(output, "compute_cs");
785
 
   else if (stage == fragment_fs)
786
 
      fprintf(output, "fragment_fs");
787
 
   else if (stage == gs_copy_vs)
788
 
      fprintf(output, "gs_copy_vs");
789
 
   else if (stage == vertex_ls)
790
 
      fprintf(output, "vertex_ls");
791
 
   else if (stage == vertex_es)
792
 
      fprintf(output, "vertex_es");
793
 
   else if (stage == vertex_vs)
794
 
      fprintf(output, "vertex_vs");
795
 
   else if (stage == tess_control_hs)
796
 
      fprintf(output, "tess_control_hs");
797
 
   else if (stage == vertex_tess_control_hs)
798
 
      fprintf(output, "vertex_tess_control_hs");
799
 
   else if (stage == tess_eval_es)
800
 
      fprintf(output, "tess_eval_es");
801
 
   else if (stage == tess_eval_vs)
802
 
      fprintf(output, "tess_eval_vs");
803
 
   else if (stage == geometry_gs)
804
 
      fprintf(output, "geometry_gs");
805
 
   else if (stage == vertex_geometry_gs)
806
 
      fprintf(output, "vertex_geometry_gs");
807
 
   else if (stage == tess_eval_geometry_gs)
808
 
      fprintf(output, "tess_eval_geometry_gs");
809
 
   else if (stage == vertex_ngg)
810
 
      fprintf(output, "vertex_ngg");
811
 
   else if (stage == tess_eval_ngg)
812
 
      fprintf(output, "tess_eval_ngg");
813
 
   else if (stage == vertex_geometry_ngg)
814
 
      fprintf(output, "vertex_geometry_ngg");
815
 
   else if (stage == tess_eval_geometry_ngg)
816
 
      fprintf(output, "tess_eval_geometry_ngg");
817
 
   else if (stage == mesh_ngg)
818
 
      fprintf(output, "mesh_ngg");
819
 
   else if (stage == task_cs)
820
 
      fprintf(output, "task_cs");
821
 
   else
822
 
      fprintf(output, "unknown");
823
 
 
824
 
   fprintf(output, "\n");
825
 
}
826
 
 
827
 
void
828
 
aco_print_block(const Block* block, FILE* output, unsigned flags, const live& live_vars)
829
 
{
830
 
   fprintf(output, "BB%d\n", block->index);
831
 
   fprintf(output, "/* logical preds: ");
832
 
   for (unsigned pred : block->logical_preds)
833
 
      fprintf(output, "BB%d, ", pred);
834
 
   fprintf(output, "/ linear preds: ");
835
 
   for (unsigned pred : block->linear_preds)
836
 
      fprintf(output, "BB%d, ", pred);
837
 
   fprintf(output, "/ kind: ");
838
 
   print_block_kind(block->kind, output);
839
 
   fprintf(output, "*/\n");
840
 
 
841
 
   if (flags & print_live_vars) {
842
 
      fprintf(output, "\tlive out:");
843
 
      for (unsigned id : live_vars.live_out[block->index])
844
 
         fprintf(output, " %%%d", id);
845
 
      fprintf(output, "\n");
846
 
 
847
 
      RegisterDemand demand = block->register_demand;
848
 
      fprintf(output, "\tdemand: %u vgpr, %u sgpr\n", demand.vgpr, demand.sgpr);
849
 
   }
850
 
 
851
 
   unsigned index = 0;
852
 
   for (auto const& instr : block->instructions) {
853
 
      fprintf(output, "\t");
854
 
      if (flags & print_live_vars) {
855
 
         RegisterDemand demand = live_vars.register_demand[block->index][index];
856
 
         fprintf(output, "(%3u vgpr, %3u sgpr)   ", demand.vgpr, demand.sgpr);
857
 
      }
858
 
      if (flags & print_perf_info)
859
 
         fprintf(output, "(%3u clk)   ", instr->pass_flags);
860
 
 
861
 
      aco_print_instr(instr.get(), output, flags);
862
 
      fprintf(output, "\n");
863
 
      index++;
864
 
   }
865
 
}
866
 
 
867
 
void
868
 
aco_print_program(const Program* program, FILE* output, const live& live_vars, unsigned flags)
869
 
{
870
 
   switch (program->progress) {
871
 
   case CompilationProgress::after_isel: fprintf(output, "After Instruction Selection:\n"); break;
872
 
   case CompilationProgress::after_spilling:
873
 
      fprintf(output, "After Spilling:\n");
874
 
      flags |= print_kill;
875
 
      break;
876
 
   case CompilationProgress::after_ra: fprintf(output, "After RA:\n"); break;
877
 
   }
878
 
 
879
 
   print_stage(program->stage, output);
880
 
 
881
 
   for (Block const& block : program->blocks)
882
 
      aco_print_block(&block, output, flags, live_vars);
883
 
 
884
 
   if (program->constant_data.size()) {
885
 
      fprintf(output, "\n/* constant data */\n");
886
 
      for (unsigned i = 0; i < program->constant_data.size(); i += 32) {
887
 
         fprintf(output, "[%06d] ", i);
888
 
         unsigned line_size = std::min<size_t>(program->constant_data.size() - i, 32);
889
 
         for (unsigned j = 0; j < line_size; j += 4) {
890
 
            unsigned size = std::min<size_t>(program->constant_data.size() - (i + j), 4);
891
 
            uint32_t v = 0;
892
 
            memcpy(&v, &program->constant_data[i + j], size);
893
 
            fprintf(output, " %08x", v);
894
 
         }
895
 
         fprintf(output, "\n");
896
 
      }
897
 
   }
898
 
 
899
 
   fprintf(output, "\n");
900
 
}
901
 
 
902
 
void
903
 
aco_print_program(const Program* program, FILE* output, unsigned flags)
904
 
{
905
 
   aco_print_program(program, output, live(), flags);
906
 
}
907
 
 
908
 
} // namespace aco