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