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    [iadd32] = "iadd32",
  11    [iadd64] = "iadd64",
  12    [imul32] = "imul32",
  13    [imul64] = "imul64",
  14    [fadd32] = "fadd32",
  15    [fadd64] = "fadd64",
  16    [fmul32] = "fmul32",
  17    [fmul64] = "fmul64",
  18    [imin32] = "imin32",
  19    [imin64] = "imin64",
  20    [imax32] = "imax32",
  21    [imax64] = "imax64",
  22    [umin32] = "umin32",
  23    [umin64] = "umin64",
  24    [umax32] = "umax32",
  25    [umax64] = "umax64",
  26    [fmin32] = "fmin32",
  27    [fmin64] = "fmin64",
  28    [fmax32] = "fmax32",
  29    [fmax64] = "fmax64",
  30    [iand32] = "iand32",
  31    [iand64] = "iand64",
  32    [ior32] = "ior32",
  33    [ior64] = "ior64",
  34    [ixor32] = "ixor32",
  35    [ixor64] = "ixor64",
  36 };
  37
  38 static void print_reg_class(const RegClass rc, FILE *output)
  39 {
  40    switch (rc) {
  41       case RegClass::s1: fprintf(output, " s1: "); return;
  42       case RegClass::s2: fprintf(output, " s2: "); return;
  43       case RegClass::s3: fprintf(output, " s3: "); return;
  44       case RegClass::s4: fprintf(output, " s4: "); return;
  45       case RegClass::s6: fprintf(output, " s6: "); return;
  46       case RegClass::s8: fprintf(output, " s8: "); return;
  47       case RegClass::s16: fprintf(output, "s16: "); return;
  48       case RegClass::v1: fprintf(output, " v1: "); return;
  49       case RegClass::v2: fprintf(output, " v2: "); return;
  50       case RegClass::v3: fprintf(output, " v3: "); return;
  51       case RegClass::v4: fprintf(output, " v4: "); return;
  52       case RegClass::v5: fprintf(output, " v5: "); return;
  53       case RegClass::v6: fprintf(output, " v6: "); return;
  54       case RegClass::v7: fprintf(output, " v7: "); return;
  55       case RegClass::v8: fprintf(output, " v8: "); return;
  56       case RegClass::v1_linear: fprintf(output, " v1: "); return;
  57       case RegClass::v2_linear: fprintf(output, " v2: "); return;
  58    }
  59 }
  60
  61 void print_physReg(unsigned reg, unsigned size, FILE *output)
  62 {
  63    if (reg == 124) {
  64       fprintf(output, ":m0");
  65    } else if (reg == 106) {
  66       fprintf(output, ":vcc");
  67    } else if (reg == 253) {
  68       fprintf(output, ":scc");
  69    } else if (reg == 126) {
  70       fprintf(output, ":exec");
  71    } else {
  72       bool is_vgpr = reg / 256;
  73       reg = reg % 256;
  74       fprintf(output, ":%c[%d", is_vgpr ? 'v' : 's', reg);
  75       if (size > 1)
  76          fprintf(output, "-%d]", reg + size -1);
  77       else
  78          fprintf(output, "]");
  79    }
  80 }
  81
  82 static void print_constant(uint8_t reg, FILE *output)
  83 {
  84    if (reg >= 128 && reg <= 192) {
  85       fprintf(output, "%d", reg - 128);
  86       return;
  87    } else if (reg >= 192 && reg <= 208) {
  88       fprintf(output, "%d", 192 - reg);
  89       return;
  90    }
  91
  92    switch (reg) {
  93    case 240:
  94       fprintf(output, "0.5");
  95       break;
  96    case 241:
  97       fprintf(output, "-0.5");
  98       break;
  99    case 242:
 100       fprintf(output, "1.0");
 101       break;
 102    case 243:
 103       fprintf(output, "-1.0");
 104       break;
 105    case 244:
 106       fprintf(output, "2.0");
 107       break;
 108    case 245:
 109       fprintf(output, "-2.0");
 110       break;
 111    case 246:
 112       fprintf(output, "4.0");
 113       break;
 114    case 247:
 115       fprintf(output, "-4.0");
 116       break;
 117    case 248:
 118       fprintf(output, "1/(2*PI)");
 119       break;
 120    }
 121 }
 122
 123 static void print_operand(const Operand *operand, FILE *output)
 124 {
 125    if (operand->isLiteral()) {
 126       fprintf(output, "0x%x", operand->constantValue());
 127    } else if (operand->isConstant()) {
 128       print_constant(operand->physReg().reg, output);
 129    } else if (operand->isUndefined()) {
 130       print_reg_class(operand->regClass(), output);
 131       fprintf(output, "undef");
 132    } else {
 133       fprintf(output, "%%%d", operand->tempId());
 134
 135       if (operand->isFixed())
 136          print_physReg(operand->physReg(), operand->size(), output);
 137    }
 138 }
 139
 140 static void print_definition(const Definition *definition, FILE *output)
 141 {
 142    print_reg_class(definition->regClass(), output);
 143    fprintf(output, "%%%d", definition->tempId());
 144
 145    if (definition->isFixed())
 146       print_physReg(definition->physReg(), definition->size(), output);
 147 }
 148
 149 static void print_barrier_reorder(bool can_reorder, barrier_interaction barrier, FILE *output)
 150 {
 151    if (can_reorder)
 152       fprintf(output, " reorder");
 153
 154    if (barrier & barrier_buffer)
 155       fprintf(output, " buffer");
 156    if (barrier & barrier_image)
 157       fprintf(output, " image");
 158    if (barrier & barrier_atomic)
 159       fprintf(output, " atomic");
 160    if (barrier & barrier_shared)
 161       fprintf(output, " shared");
 162 }
 163
 164 static void print_instr_format_specific(struct Instruction *instr, FILE *output)
 165 {
 166    switch (instr->format) {
 167    case Format::SOPK: {
 168       SOPK_instruction* sopk = static_cast<SOPK_instruction*>(instr);
 169       fprintf(output, " imm:%d", sopk->imm & 0x8000 ? (sopk->imm - 65536) : sopk->imm);
 170       break;
 171    }
 172    case Format::SOPP: {
 173       SOPP_instruction* sopp = static_cast<SOPP_instruction*>(instr);
 174       uint16_t imm = sopp->imm;
 175       switch (instr->opcode) {
 176       case aco_opcode::s_waitcnt: {
 177          /* we usually should check the chip class for vmcnt/lgkm, but
 178           * insert_waitcnt() should fill it in regardless. */
 179          unsigned vmcnt = (imm & 0xF) | ((imm & (0x3 << 14)) >> 10);
 180          if (vmcnt != 63) fprintf(output, " vmcnt(%d)", vmcnt);
 181          if (((imm >> 4) & 0x7) < 0x7) fprintf(output, " expcnt(%d)", (imm >> 4) & 0x7);
 182          if (((imm >> 8) & 0x3F) < 0x3F) fprintf(output, " lgkmcnt(%d)", (imm >> 8) & 0x3F);
 183          break;
 184       }
 185       case aco_opcode::s_endpgm:
 186       case aco_opcode::s_endpgm_saved:
 187       case aco_opcode::s_endpgm_ordered_ps_done:
 188       case aco_opcode::s_wakeup:
 189       case aco_opcode::s_barrier:
 190       case aco_opcode::s_icache_inv:
 191       case aco_opcode::s_ttracedata:
 192       case aco_opcode::s_set_gpr_idx_off: {
 193          break;
 194       }
 195       default: {
 196          if (imm)
 197             fprintf(output, " imm:%u", imm);
 198          break;
 199       }
 200       }
 201       if (sopp->block != -1)
 202          fprintf(output, " block:BB%d", sopp->block);
 203       break;
 204    }
 205    case Format::SMEM: {
 206       SMEM_instruction* smem = static_cast<SMEM_instruction*>(instr);
 207       if (smem->glc)
 208          fprintf(output, " glc");
 209       if (smem->dlc)
 210          fprintf(output, " dlc");
 211       if (smem->nv)
 212          fprintf(output, " nv");
 213       print_barrier_reorder(smem->can_reorder, smem->barrier, output);
 214       break;
 215    }
 216    case Format::VINTRP: {
 217       Interp_instruction* vintrp = static_cast<Interp_instruction*>(instr);
 218       fprintf(output, " attr%d.%c", vintrp->attribute, "xyzw"[vintrp->component]);
 219       break;
 220    }
 221    case Format::DS: {
 222       DS_instruction* ds = static_cast<DS_instruction*>(instr);
 223       if (ds->offset0)
 224          fprintf(output, " offset0:%u", ds->offset0);
 225       if (ds->offset1)
 226          fprintf(output, " offset1:%u", ds->offset1);
 227       if (ds->gds)
 228          fprintf(output, " gds");
 229       break;
 230    }
 231    case Format::MUBUF: {
 232       MUBUF_instruction* mubuf = static_cast<MUBUF_instruction*>(instr);
 233       if (mubuf->offset)
 234          fprintf(output, " offset:%u", mubuf->offset);
 235       if (mubuf->offen)
 236          fprintf(output, " offen");
 237       if (mubuf->idxen)
 238          fprintf(output, " idxen");
 239       if (mubuf->glc)
 240          fprintf(output, " glc");
 241       if (mubuf->dlc)
 242          fprintf(output, " dlc");
 243       if (mubuf->slc)
 244          fprintf(output, " slc");
 245       if (mubuf->tfe)
 246          fprintf(output, " tfe");
 247       if (mubuf->lds)
 248          fprintf(output, " lds");
 249       if (mubuf->disable_wqm)
 250          fprintf(output, " disable_wqm");
 251       print_barrier_reorder(mubuf->can_reorder, mubuf->barrier, output);
 252       break;
 253    }
 254    case Format::MIMG: {
 255       MIMG_instruction* mimg = static_cast<MIMG_instruction*>(instr);
 256       unsigned identity_dmask = !instr->definitions.empty() ?
 257                                 (1 << instr->definitions[0].size()) - 1 :
 258                                 0xf;
 259       if ((mimg->dmask & identity_dmask) != identity_dmask)
 260          fprintf(output, " dmask:%s%s%s%s",
 261                  mimg->dmask & 0x1 ? "x" : "",
 262                  mimg->dmask & 0x2 ? "y" : "",
 263                  mimg->dmask & 0x4 ? "z" : "",
 264                  mimg->dmask & 0x8 ? "w" : "");
 265       switch (mimg->dim) {
 266       case ac_image_1d:
 267          fprintf(output, " 1d");
 268          break;
 269       case ac_image_2d:
 270          fprintf(output, " 2d");
 271          break;
 272       case ac_image_3d:
 273          fprintf(output, " 3d");
 274          break;
 275       case ac_image_cube:
 276          fprintf(output, " cube");
 277          break;
 278       case ac_image_1darray:
 279          fprintf(output, " 1darray");
 280          break;
 281       case ac_image_2darray:
 282          fprintf(output, " 2darray");
 283          break;
 284       case ac_image_2dmsaa:
 285          fprintf(output, " 2dmsaa");
 286          break;
 287       case ac_image_2darraymsaa:
 288          fprintf(output, " 2darraymsaa");
 289          break;
 290       }
 291       if (mimg->unrm)
 292          fprintf(output, " unrm");
 293       if (mimg->glc)
 294          fprintf(output, " glc");
 295       if (mimg->dlc)
 296          fprintf(output, " dlc");
 297       if (mimg->slc)
 298          fprintf(output, " slc");
 299       if (mimg->tfe)
 300          fprintf(output, " tfe");
 301       if (mimg->da)
 302          fprintf(output, " da");
 303       if (mimg->lwe)
 304          fprintf(output, " lwe");
 305       if (mimg->r128 || mimg->a16)
 306          fprintf(output, " r128/a16");
 307       if (mimg->d16)
 308          fprintf(output, " d16");
 309       if (mimg->disable_wqm)
 310          fprintf(output, " disable_wqm");
 311       print_barrier_reorder(mimg->can_reorder, mimg->barrier, output);
 312       break;
 313    }
 314    case Format::EXP: {
 315       Export_instruction* exp = static_cast<Export_instruction*>(instr);
 316       unsigned identity_mask = exp->compressed ? 0x5 : 0xf;
 317       if ((exp->enabled_mask & identity_mask) != identity_mask)
 318          fprintf(output, " en:%c%c%c%c",
 319                  exp->enabled_mask & 0x1 ? 'r' : '*',
 320                  exp->enabled_mask & 0x2 ? 'g' : '*',
 321                  exp->enabled_mask & 0x4 ? 'b' : '*',
 322                  exp->enabled_mask & 0x8 ? 'a' : '*');
 323       if (exp->compressed)
 324          fprintf(output, " compr");
 325       if (exp->done)
 326          fprintf(output, " done");
 327       if (exp->valid_mask)
 328          fprintf(output, " vm");
 329
 330       if (exp->dest <= V_008DFC_SQ_EXP_MRT + 7)
 331          fprintf(output, " mrt%d", exp->dest - V_008DFC_SQ_EXP_MRT);
 332       else if (exp->dest == V_008DFC_SQ_EXP_MRTZ)
 333          fprintf(output, " mrtz");
 334       else if (exp->dest == V_008DFC_SQ_EXP_NULL)
 335          fprintf(output, " null");
 336       else if (exp->dest >= V_008DFC_SQ_EXP_POS && exp->dest <= V_008DFC_SQ_EXP_POS + 3)
 337          fprintf(output, " pos%d", exp->dest - V_008DFC_SQ_EXP_POS);
 338       else if (exp->dest >= V_008DFC_SQ_EXP_PARAM && exp->dest <= V_008DFC_SQ_EXP_PARAM + 31)
 339          fprintf(output, " param%d", exp->dest - V_008DFC_SQ_EXP_PARAM);
 340       break;
 341    }
 342    case Format::PSEUDO_BRANCH: {
 343       Pseudo_branch_instruction* branch = static_cast<Pseudo_branch_instruction*>(instr);
 344       /* Note: BB0 cannot be a branch target */
 345       if (branch->target[0] != 0)
 346          fprintf(output, " BB%d", branch->target[0]);
 347       if (branch->target[1] != 0)
 348          fprintf(output, ", BB%d", branch->target[1]);
 349       break;
 350    }
 351    case Format::PSEUDO_REDUCTION: {
 352       Pseudo_reduction_instruction* reduce = static_cast<Pseudo_reduction_instruction*>(instr);
 353       fprintf(output, " op:%s", reduce_ops[reduce->reduce_op]);
 354       if (reduce->cluster_size)
 355          fprintf(output, " cluster_size:%u", reduce->cluster_size);
 356       break;
 357    }
 358    case Format::FLAT:
 359    case Format::GLOBAL:
 360    case Format::SCRATCH: {
 361       FLAT_instruction* flat = static_cast<FLAT_instruction*>(instr);
 362       if (flat->offset)
 363          fprintf(output, " offset:%u", flat->offset);
 364       if (flat->glc)
 365          fprintf(output, " glc");
 366       if (flat->dlc)
 367          fprintf(output, " dlc");
 368       if (flat->slc)
 369          fprintf(output, " slc");
 370       if (flat->lds)
 371          fprintf(output, " lds");
 372       if (flat->nv)
 373          fprintf(output, " nv");
 374       break;
 375    }
 376    case Format::MTBUF: {
 377       MTBUF_instruction* mtbuf = static_cast<MTBUF_instruction*>(instr);
 378       fprintf(output, " dfmt:");
 379       switch (mtbuf->dfmt) {
 380       case V_008F0C_BUF_DATA_FORMAT_8: fprintf(output, "8"); break;
 381       case V_008F0C_BUF_DATA_FORMAT_16: fprintf(output, "16"); break;
 382       case V_008F0C_BUF_DATA_FORMAT_8_8: fprintf(output, "8_8"); break;
 383       case V_008F0C_BUF_DATA_FORMAT_32: fprintf(output, "32"); break;
 384       case V_008F0C_BUF_DATA_FORMAT_16_16: fprintf(output, "16_16"); break;
 385       case V_008F0C_BUF_DATA_FORMAT_10_11_11: fprintf(output, "10_11_11"); break;
 386       case V_008F0C_BUF_DATA_FORMAT_11_11_10: fprintf(output, "11_11_10"); break;
 387       case V_008F0C_BUF_DATA_FORMAT_10_10_10_2: fprintf(output, "10_10_10_2"); break;
 388       case V_008F0C_BUF_DATA_FORMAT_2_10_10_10: fprintf(output, "2_10_10_10"); break;
 389       case V_008F0C_BUF_DATA_FORMAT_8_8_8_8: fprintf(output, "8_8_8_8"); break;
 390       case V_008F0C_BUF_DATA_FORMAT_32_32: fprintf(output, "32_32"); break;
 391       case V_008F0C_BUF_DATA_FORMAT_16_16_16_16: fprintf(output, "16_16_16_16"); break;
 392       case V_008F0C_BUF_DATA_FORMAT_32_32_32: fprintf(output, "32_32_32"); break;
 393       case V_008F0C_BUF_DATA_FORMAT_32_32_32_32: fprintf(output, "32_32_32_32"); break;
 394       case V_008F0C_BUF_DATA_FORMAT_RESERVED_15: fprintf(output, "reserved15"); break;
 395       }
 396       fprintf(output, " nfmt:");
 397       switch (mtbuf->nfmt) {
 398       case V_008F0C_BUF_NUM_FORMAT_UNORM: fprintf(output, "unorm"); break;
 399       case V_008F0C_BUF_NUM_FORMAT_SNORM: fprintf(output, "snorm"); break;
 400       case V_008F0C_BUF_NUM_FORMAT_USCALED: fprintf(output, "uscaled"); break;
 401       case V_008F0C_BUF_NUM_FORMAT_SSCALED: fprintf(output, "sscaled"); break;
 402       case V_008F0C_BUF_NUM_FORMAT_UINT: fprintf(output, "uint"); break;
 403       case V_008F0C_BUF_NUM_FORMAT_SINT: fprintf(output, "sint"); break;
 404       case V_008F0C_BUF_NUM_FORMAT_SNORM_OGL: fprintf(output, "snorm"); break;
 405       case V_008F0C_BUF_NUM_FORMAT_FLOAT: fprintf(output, "float"); break;
 406       }
 407       if (mtbuf->offset)
 408          fprintf(output, " offset:%u", mtbuf->offset);
 409       if (mtbuf->offen)
 410          fprintf(output, " offen");
 411       if (mtbuf->idxen)
 412          fprintf(output, " idxen");
 413       if (mtbuf->glc)
 414          fprintf(output, " glc");
 415       if (mtbuf->dlc)
 416          fprintf(output, " dlc");
 417       if (mtbuf->slc)
 418          fprintf(output, " slc");
 419       if (mtbuf->tfe)
 420          fprintf(output, " tfe");
 421       if (mtbuf->disable_wqm)
 422          fprintf(output, " disable_wqm");
 423       print_barrier_reorder(mtbuf->can_reorder, mtbuf->barrier, output);
 424       break;
 425    }
 426    default: {
 427       break;
 428    }
 429    }
 430    if (instr->isVOP3()) {
 431       VOP3A_instruction* vop3 = static_cast<VOP3A_instruction*>(instr);
 432       switch (vop3->omod) {
 433       case 1:
 434          fprintf(output, " *2");
 435          break;
 436       case 2:
 437          fprintf(output, " *4");
 438          break;
 439       case 3:
 440          fprintf(output, " *0.5");
 441          break;
 442       }
 443       if (vop3->clamp)
 444          fprintf(output, " clamp");
 445    } else if (instr->isDPP()) {
 446       DPP_instruction* dpp = static_cast<DPP_instruction*>(instr);
 447       if (dpp->dpp_ctrl <= 0xff) {
 448          fprintf(output, " quad_perm:[%d,%d,%d,%d]",
 449                  dpp->dpp_ctrl & 0x3, (dpp->dpp_ctrl >> 2) & 0x3,
 450                  (dpp->dpp_ctrl >> 4) & 0x3, (dpp->dpp_ctrl >> 6) & 0x3);
 451       } else if (dpp->dpp_ctrl >= 0x101 && dpp->dpp_ctrl <= 0x10f) {
 452          fprintf(output, " row_shl:%d", dpp->dpp_ctrl & 0xf);
 453       } else if (dpp->dpp_ctrl >= 0x111 && dpp->dpp_ctrl <= 0x11f) {
 454          fprintf(output, " row_shr:%d", dpp->dpp_ctrl & 0xf);
 455       } else if (dpp->dpp_ctrl >= 0x121 && dpp->dpp_ctrl <= 0x12f) {
 456          fprintf(output, " row_ror:%d", dpp->dpp_ctrl & 0xf);
 457       } else if (dpp->dpp_ctrl == dpp_wf_sl1) {
 458          fprintf(output, " wave_shl:1");
 459       } else if (dpp->dpp_ctrl == dpp_wf_rl1) {
 460          fprintf(output, " wave_rol:1");
 461       } else if (dpp->dpp_ctrl == dpp_wf_sr1) {
 462          fprintf(output, " wave_shr:1");
 463       } else if (dpp->dpp_ctrl == dpp_wf_rr1) {
 464          fprintf(output, " wave_ror:1");
 465       } else if (dpp->dpp_ctrl == dpp_row_mirror) {
 466          fprintf(output, " row_mirror");
 467       } else if (dpp->dpp_ctrl == dpp_row_half_mirror) {
 468          fprintf(output, " row_half_mirror");
 469       } else if (dpp->dpp_ctrl == dpp_row_bcast15) {
 470          fprintf(output, " row_bcast:15");
 471       } else if (dpp->dpp_ctrl == dpp_row_bcast31) {
 472          fprintf(output, " row_bcast:31");
 473       } else {
 474          fprintf(output, " dpp_ctrl:0x%.3x", dpp->dpp_ctrl);
 475       }
 476       if (dpp->row_mask != 0xf)
 477          fprintf(output, " row_mask:0x%.1x", dpp->row_mask);
 478       if (dpp->bank_mask != 0xf)
 479          fprintf(output, " bank_mask:0x%.1x", dpp->bank_mask);
 480       if (dpp->bound_ctrl)
 481          fprintf(output, " bound_ctrl:1");
 482    } else if ((int)instr->format & (int)Format::SDWA) {
 483       fprintf(output, " (printing unimplemented)");
 484    }
 485 }
 486
 487 void aco_print_instr(struct Instruction *instr, FILE *output)
 488 {
 489    if (!instr->definitions.empty()) {
 490       for (unsigned i = 0; i < instr->definitions.size(); ++i) {
 491          print_definition(&instr->definitions[i], output);
 492          if (i + 1 != instr->definitions.size())
 493             fprintf(output, ", ");
 494       }
 495       fprintf(output, " = ");
 496    }
 497    fprintf(output, "%s", instr_info.name[(int)instr->opcode]);
 498    if (instr->operands.size()) {
 499       bool abs[instr->operands.size()];
 500       bool neg[instr->operands.size()];
 501       if ((int)instr->format & (int)Format::VOP3A) {
 502          VOP3A_instruction* vop3 = static_cast<VOP3A_instruction*>(instr);
 503          for (unsigned i = 0; i < instr->operands.size(); ++i) {
 504             abs[i] = vop3->abs[i];
 505             neg[i] = vop3->neg[i];
 506          }
 507       } else if (instr->isDPP()) {
 508          DPP_instruction* dpp = static_cast<DPP_instruction*>(instr);
 509          assert(instr->operands.size() <= 2);
 510          for (unsigned i = 0; i < instr->operands.size(); ++i) {
 511             abs[i] = dpp->abs[i];
 512             neg[i] = dpp->neg[i];
 513          }
 514       } else {
 515          for (unsigned i = 0; i < instr->operands.size(); ++i) {
 516             abs[i] = false;
 517             neg[i] = false;
 518          }
 519       }
 520       for (unsigned i = 0; i < instr->operands.size(); ++i) {
 521          if (i)
 522             fprintf(output, ", ");
 523          else
 524             fprintf(output, " ");
 525
 526          if (neg[i])
 527             fprintf(output, "-");
 528          if (abs[i])
 529             fprintf(output, "|");
 530          print_operand(&instr->operands[i], output);
 531          if (abs[i])
 532             fprintf(output, "|");
 533        }
 534    }
 535    print_instr_format_specific(instr, output);
 536 }
 537
 538 static void print_block_kind(uint16_t kind, FILE *output)
 539 {
 540    if (kind & block_kind_uniform)
 541       fprintf(output, "uniform, ");
 542    if (kind & block_kind_top_level)
 543       fprintf(output, "top-level, ");
 544    if (kind & block_kind_loop_preheader)
 545       fprintf(output, "loop-preheader, ");
 546    if (kind & block_kind_loop_header)
 547       fprintf(output, "loop-header, ");
 548    if (kind & block_kind_loop_exit)
 549       fprintf(output, "loop-exit, ");
 550    if (kind & block_kind_continue)
 551       fprintf(output, "continue, ");
 552    if (kind & block_kind_break)
 553       fprintf(output, "break, ");
 554    if (kind & block_kind_continue_or_break)
 555       fprintf(output, "continue_or_break, ");
 556    if (kind & block_kind_discard)
 557       fprintf(output, "discard, ");
 558    if (kind & block_kind_branch)
 559       fprintf(output, "branch, ");
 560    if (kind & block_kind_merge)
 561       fprintf(output, "merge, ");
 562    if (kind & block_kind_invert)
 563       fprintf(output, "invert, ");
 564    if (kind & block_kind_uses_discard_if)
 565       fprintf(output, "discard_if, ");
 566    if (kind & block_kind_needs_lowering)
 567       fprintf(output, "needs_lowering, ");
 568    if (kind & block_kind_uses_demote)
 569       fprintf(output, "uses_demote, ");
 570 }
 571
 572 void aco_print_block(const struct Block* block, FILE *output)
 573 {
 574    fprintf(output, "BB%d\n", block->index);
 575    fprintf(output, "/* logical preds: ");
 576    for (unsigned pred : block->logical_preds)
 577       fprintf(output, "BB%d, ", pred);
 578    fprintf(output, "/ linear preds: ");
 579    for (unsigned pred : block->linear_preds)
 580       fprintf(output, "BB%d, ", pred);
 581    fprintf(output, "/ kind: ");
 582    print_block_kind(block->kind, output);
 583    fprintf(output, "*/\n");
 584    for (auto const& instr : block->instructions) {
 585       fprintf(output, "\t");
 586       aco_print_instr(instr.get(), output);
 587       fprintf(output, "\n");
 588    }
 589 }
 590
 591 void aco_print_program(Program *program, FILE *output)
 592 {
 593    for (Block const& block : program->blocks)
 594       aco_print_block(&block, output);
 595
 596    if (program->constant_data.size()) {
 597       fprintf(output, "\n/* constant data */\n");
 598       for (unsigned i = 0; i < program->constant_data.size(); i += 32) {
 599          fprintf(output, "[%06d] ", i);
 600          unsigned line_size = std::min<size_t>(program->constant_data.size() - i, 32);
 601          for (unsigned j = 0; j < line_size; j += 4) {
 602             unsigned size = std::min<size_t>(program->constant_data.size() - (i + j), 4);
 603             uint32_t v = 0;
 604             memcpy(&v, &program->constant_data[i + j], size);
 605             fprintf(output, " %08x", v);
 606          }
 607          fprintf(output, "\n");
 608       }
 609    }
 610
 611    fprintf(output, "\n");
 612 }
 613
 614 }