src/amd/compiler/aco_print_ir.cpp

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