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