src/amd/compiler/aco_print_ir.cpp

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