src/glsl/nir/nir_print.c

   1 /*
   2  * Copyright © 2014 Intel Corporation
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice (including the next
  12  * paragraph) shall be included in all copies or substantial portions of the
  13  * Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  21  * IN THE SOFTWARE.
  22  *
  23  * Authors:
  24  *    Connor Abbott (cwabbott0@gmail.com)
  25  *
  26  */
  27
  28 #include "nir.h"
  29 #include "shader_enums.h"
  30 #include <stdio.h>
  31 #include <stdlib.h>
  32
  33 static void
  34 print_tabs(unsigned num_tabs, FILE *fp)
  35 {
  36    for (unsigned i = 0; i < num_tabs; i++)
  37       fprintf(fp, "\t");
  38 }
  39
  40 typedef struct {
  41    FILE *fp;
  42    nir_shader *shader;
  43    /** map from nir_variable -> printable name */
  44    struct hash_table *ht;
  45
  46    /** set of names used so far for nir_variables */
  47    struct set *syms;
  48
  49    /* an index used to make new non-conflicting names */
  50    unsigned index;
  51 } print_state;
  52
  53 static void
  54 print_register(nir_register *reg, print_state *state)
  55 {
  56    FILE *fp = state->fp;
  57    if (reg->name != NULL)
  58       fprintf(fp, "/* %s */ ", reg->name);
  59    if (reg->is_global)
  60       fprintf(fp, "gr%u", reg->index);
  61    else
  62       fprintf(fp, "r%u", reg->index);
  63 }
  64
  65 static const char *sizes[] = { "error", "vec1", "vec2", "vec3", "vec4" };
  66
  67 static void
  68 print_register_decl(nir_register *reg, print_state *state)
  69 {
  70    FILE *fp = state->fp;
  71    fprintf(fp, "decl_reg %s ", sizes[reg->num_components]);
  72    if (reg->is_packed)
  73       fprintf(fp, "(packed) ");
  74    print_register(reg, state);
  75    if (reg->num_array_elems != 0)
  76       fprintf(fp, "[%u]", reg->num_array_elems);
  77    fprintf(fp, "\n");
  78 }
  79
  80 static void
  81 print_ssa_def(nir_ssa_def *def, print_state *state)
  82 {
  83    FILE *fp = state->fp;
  84    if (def->name != NULL)
  85       fprintf(fp, "/* %s */ ", def->name);
  86    fprintf(fp, "%s ssa_%u", sizes[def->num_components], def->index);
  87 }
  88
  89 static void
  90 print_ssa_use(nir_ssa_def *def, print_state *state)
  91 {
  92    FILE *fp = state->fp;
  93    if (def->name != NULL)
  94       fprintf(fp, "/* %s */ ", def->name);
  95    fprintf(fp, "ssa_%u", def->index);
  96 }
  97
  98 static void print_src(nir_src *src, print_state *state);
  99
 100 static void
 101 print_reg_src(nir_reg_src *src, print_state *state)
 102 {
 103    FILE *fp = state->fp;
 104    print_register(src->reg, state);
 105    if (src->reg->num_array_elems != 0) {
 106       fprintf(fp, "[%u", src->base_offset);
 107       if (src->indirect != NULL) {
 108          fprintf(fp, " + ");
 109          print_src(src->indirect, state);
 110       }
 111       fprintf(fp, "]");
 112    }
 113 }
 114
 115 static void
 116 print_reg_dest(nir_reg_dest *dest, print_state *state)
 117 {
 118    FILE *fp = state->fp;
 119    print_register(dest->reg, state);
 120    if (dest->reg->num_array_elems != 0) {
 121       fprintf(fp, "[%u", dest->base_offset);
 122       if (dest->indirect != NULL) {
 123          fprintf(fp, " + ");
 124          print_src(dest->indirect, state);
 125       }
 126       fprintf(fp, "]");
 127    }
 128 }
 129
 130 static void
 131 print_src(nir_src *src, print_state *state)
 132 {
 133    if (src->is_ssa)
 134       print_ssa_use(src->ssa, state);
 135    else
 136       print_reg_src(&src->reg, state);
 137 }
 138
 139 static void
 140 print_dest(nir_dest *dest, print_state *state)
 141 {
 142    if (dest->is_ssa)
 143       print_ssa_def(&dest->ssa, state);
 144    else
 145       print_reg_dest(&dest->reg, state);
 146 }
 147
 148 static void
 149 print_alu_src(nir_alu_instr *instr, unsigned src, print_state *state)
 150 {
 151    FILE *fp = state->fp;
 152
 153    if (instr->src[src].negate)
 154       fprintf(fp, "-");
 155    if (instr->src[src].abs)
 156       fprintf(fp, "abs(");
 157
 158    print_src(&instr->src[src].src, state);
 159
 160    bool print_swizzle = false;
 161    for (unsigned i = 0; i < 4; i++) {
 162       if (!nir_alu_instr_channel_used(instr, src, i))
 163          continue;
 164
 165       if (instr->src[src].swizzle[i] != i) {
 166          print_swizzle = true;
 167          break;
 168       }
 169    }
 170
 171    if (print_swizzle) {
 172       fprintf(fp, ".");
 173       for (unsigned i = 0; i < 4; i++) {
 174          if (!nir_alu_instr_channel_used(instr, src, i))
 175             continue;
 176
 177          fprintf(fp, "%c", "xyzw"[instr->src[src].swizzle[i]]);
 178       }
 179    }
 180
 181    if (instr->src[src].abs)
 182       fprintf(fp, ")");
 183 }
 184
 185 static void
 186 print_alu_dest(nir_alu_dest *dest, print_state *state)
 187 {
 188    FILE *fp = state->fp;
 189    /* we're going to print the saturate modifier later, after the opcode */
 190
 191    print_dest(&dest->dest, state);
 192
 193    if (!dest->dest.is_ssa &&
 194        dest->write_mask != (1 << dest->dest.reg.reg->num_components) - 1) {
 195       fprintf(fp, ".");
 196       for (unsigned i = 0; i < 4; i++)
 197          if ((dest->write_mask >> i) & 1)
 198             fprintf(fp, "%c", "xyzw"[i]);
 199    }
 200 }
 201
 202 static void
 203 print_alu_instr(nir_alu_instr *instr, print_state *state)
 204 {
 205    FILE *fp = state->fp;
 206
 207    print_alu_dest(&instr->dest, state);
 208
 209    fprintf(fp, " = %s", nir_op_infos[instr->op].name);
 210    if (instr->dest.saturate)
 211       fprintf(fp, ".sat");
 212    fprintf(fp, " ");
 213
 214    for (unsigned i = 0; i < nir_op_infos[instr->op].num_inputs; i++) {
 215       if (i != 0)
 216          fprintf(fp, ", ");
 217
 218       print_alu_src(instr, i, state);
 219    }
 220 }
 221
 222 static void
 223 print_var_decl(nir_variable *var, print_state *state)
 224 {
 225    FILE *fp = state->fp;
 226
 227    fprintf(fp, "decl_var ");
 228
 229    const char *const cent = (var->data.centroid) ? "centroid " : "";
 230    const char *const samp = (var->data.sample) ? "sample " : "";
 231    const char *const inv = (var->data.invariant) ? "invariant " : "";
 232    const char *const mode[] = { "shader_in ", "shader_out ", "", "",
 233                                 "uniform ", "shader_storage", "system " };
 234
 235    fprintf(fp, "%s%s%s%s%s ",
 236       cent, samp, inv, mode[var->data.mode],
 237           glsl_interp_qualifier_name(var->data.interpolation));
 238
 239    glsl_print_type(var->type, fp);
 240
 241    struct set_entry *entry = NULL;
 242    if (state->syms)
 243       entry = _mesa_set_search(state->syms, var->name);
 244
 245    char *name;
 246
 247    if (entry != NULL) {
 248       /* we have a collision with another name, append an @ + a unique index */
 249       name = ralloc_asprintf(state->syms, "%s@%u", var->name, state->index++);
 250    } else {
 251       name = var->name;
 252    }
 253
 254    fprintf(fp, " %s", name);
 255
 256    if (var->data.mode == nir_var_shader_in ||
 257        var->data.mode == nir_var_shader_out ||
 258        var->data.mode == nir_var_uniform ||
 259        var->data.mode == nir_var_shader_storage) {
 260       const char *loc = NULL;
 261       char buf[4];
 262
 263       switch (state->shader->stage) {
 264       case MESA_SHADER_VERTEX:
 265          if (var->data.mode == nir_var_shader_in)
 266             loc = gl_vert_attrib_name(var->data.location);
 267          else if (var->data.mode == nir_var_shader_out)
 268             loc = gl_varying_slot_name(var->data.location);
 269          break;
 270       case MESA_SHADER_GEOMETRY:
 271          if ((var->data.mode == nir_var_shader_in) ||
 272              (var->data.mode == nir_var_shader_out))
 273             loc = gl_varying_slot_name(var->data.location);
 274          break;
 275       case MESA_SHADER_FRAGMENT:
 276          if (var->data.mode == nir_var_shader_in)
 277             loc = gl_varying_slot_name(var->data.location);
 278          else if (var->data.mode == nir_var_shader_out)
 279             loc = gl_frag_result_name(var->data.location);
 280          break;
 281       case MESA_SHADER_TESS_CTRL:
 282       case MESA_SHADER_TESS_EVAL:
 283       case MESA_SHADER_COMPUTE:
 284       default:
 285          /* TODO */
 286          break;
 287       }
 288
 289       if (!loc) {
 290          snprintf(buf, sizeof(buf), "%u", var->data.location);
 291          loc = buf;
 292       }
 293
 294       fprintf(fp, " (%s, %u)", loc, var->data.driver_location);
 295    }
 296
 297    fprintf(fp, "\n");
 298
 299    if (state) {
 300       _mesa_set_add(state->syms, name);
 301       _mesa_hash_table_insert(state->ht, var, name);
 302    }
 303 }
 304
 305 static void
 306 print_var(nir_variable *var, print_state *state)
 307 {
 308    FILE *fp = state->fp;
 309    const char *name;
 310    if (state->ht) {
 311       struct hash_entry *entry = _mesa_hash_table_search(state->ht, var);
 312
 313       assert(entry != NULL);
 314       name = entry->data;
 315    } else {
 316       name = var->name;
 317    }
 318
 319    fprintf(fp, "%s", name);
 320 }
 321
 322 static void
 323 print_deref_var(nir_deref_var *deref, print_state *state)
 324 {
 325    print_var(deref->var, state);
 326 }
 327
 328 static void
 329 print_deref_array(nir_deref_array *deref, print_state *state)
 330 {
 331    FILE *fp = state->fp;
 332    fprintf(fp, "[");
 333    switch (deref->deref_array_type) {
 334    case nir_deref_array_type_direct:
 335       fprintf(fp, "%u", deref->base_offset);
 336       break;
 337    case nir_deref_array_type_indirect:
 338       if (deref->base_offset != 0)
 339          fprintf(fp, "%u + ", deref->base_offset);
 340       print_src(&deref->indirect, state);
 341       break;
 342    case nir_deref_array_type_wildcard:
 343       fprintf(fp, "*");
 344       break;
 345    }
 346    fprintf(fp, "]");
 347 }
 348
 349 static void
 350 print_deref_struct(nir_deref_struct *deref, const struct glsl_type *parent_type,
 351                    print_state *state)
 352 {
 353    FILE *fp = state->fp;
 354    fprintf(fp, ".%s", glsl_get_struct_elem_name(parent_type, deref->index));
 355 }
 356
 357 static void
 358 print_deref(nir_deref_var *deref, print_state *state)
 359 {
 360    nir_deref *tail = &deref->deref;
 361    nir_deref *pretail = NULL;
 362    while (tail != NULL) {
 363       switch (tail->deref_type) {
 364       case nir_deref_type_var:
 365          assert(pretail == NULL);
 366          assert(tail == &deref->deref);
 367          print_deref_var(deref, state);
 368          break;
 369
 370       case nir_deref_type_array:
 371          assert(pretail != NULL);
 372          print_deref_array(nir_deref_as_array(tail), state);
 373          break;
 374
 375       case nir_deref_type_struct:
 376          assert(pretail != NULL);
 377          print_deref_struct(nir_deref_as_struct(tail),
 378                             pretail->type, state);
 379          break;
 380
 381       default:
 382          unreachable("Invalid deref type");
 383       }
 384
 385       pretail = tail;
 386       tail = pretail->child;
 387    }
 388 }
 389
 390 static void
 391 print_intrinsic_instr(nir_intrinsic_instr *instr, print_state *state)
 392 {
 393    unsigned num_srcs = nir_intrinsic_infos[instr->intrinsic].num_srcs;
 394    FILE *fp = state->fp;
 395
 396    if (nir_intrinsic_infos[instr->intrinsic].has_dest) {
 397       print_dest(&instr->dest, state);
 398       fprintf(fp, " = ");
 399    }
 400
 401    fprintf(fp, "intrinsic %s (", nir_intrinsic_infos[instr->intrinsic].name);
 402
 403    for (unsigned i = 0; i < num_srcs; i++) {
 404       if (i != 0)
 405          fprintf(fp, ", ");
 406
 407       print_src(&instr->src[i], state);
 408    }
 409
 410    fprintf(fp, ") (");
 411
 412    unsigned num_vars = nir_intrinsic_infos[instr->intrinsic].num_variables;
 413
 414    for (unsigned i = 0; i < num_vars; i++) {
 415       if (i != 0)
 416          fprintf(fp, ", ");
 417
 418       print_deref(instr->variables[i], state);
 419    }
 420
 421    fprintf(fp, ") (");
 422
 423    unsigned num_indices = nir_intrinsic_infos[instr->intrinsic].num_indices;
 424
 425    for (unsigned i = 0; i < num_indices; i++) {
 426       if (i != 0)
 427          fprintf(fp, ", ");
 428
 429       fprintf(fp, "%u", instr->const_index[i]);
 430    }
 431
 432    fprintf(fp, ")");
 433 }
 434
 435 static void
 436 print_tex_instr(nir_tex_instr *instr, print_state *state)
 437 {
 438    FILE *fp = state->fp;
 439
 440    print_dest(&instr->dest, state);
 441
 442    fprintf(fp, " = ");
 443
 444    switch (instr->op) {
 445    case nir_texop_tex:
 446       fprintf(fp, "tex ");
 447       break;
 448    case nir_texop_txb:
 449       fprintf(fp, "txb ");
 450       break;
 451    case nir_texop_txl:
 452       fprintf(fp, "txl ");
 453       break;
 454    case nir_texop_txd:
 455       fprintf(fp, "txd ");
 456       break;
 457    case nir_texop_txf:
 458       fprintf(fp, "txf ");
 459       break;
 460    case nir_texop_txf_ms:
 461       fprintf(fp, "txf_ms ");
 462       break;
 463    case nir_texop_txs:
 464       fprintf(fp, "txs ");
 465       break;
 466    case nir_texop_lod:
 467       fprintf(fp, "lod ");
 468       break;
 469    case nir_texop_tg4:
 470       fprintf(fp, "tg4 ");
 471       break;
 472    case nir_texop_query_levels:
 473       fprintf(fp, "query_levels ");
 474       break;
 475    case nir_texop_texture_samples:
 476       fprintf(fp, "texture_samples ");
 477       break;
 478
 479    default:
 480       unreachable("Invalid texture operation");
 481       break;
 482    }
 483
 484    for (unsigned i = 0; i < instr->num_srcs; i++) {
 485       print_src(&instr->src[i].src, state);
 486
 487       fprintf(fp, " ");
 488
 489       switch(instr->src[i].src_type) {
 490       case nir_tex_src_coord:
 491          fprintf(fp, "(coord)");
 492          break;
 493       case nir_tex_src_projector:
 494          fprintf(fp, "(projector)");
 495          break;
 496       case nir_tex_src_comparitor:
 497          fprintf(fp, "(comparitor)");
 498          break;
 499       case nir_tex_src_offset:
 500          fprintf(fp, "(offset)");
 501          break;
 502       case nir_tex_src_bias:
 503          fprintf(fp, "(bias)");
 504          break;
 505       case nir_tex_src_lod:
 506          fprintf(fp, "(lod)");
 507          break;
 508       case nir_tex_src_ms_index:
 509          fprintf(fp, "(ms_index)");
 510          break;
 511       case nir_tex_src_ddx:
 512          fprintf(fp, "(ddx)");
 513          break;
 514       case nir_tex_src_ddy:
 515          fprintf(fp, "(ddy)");
 516          break;
 517       case nir_tex_src_sampler_offset:
 518          fprintf(fp, "(sampler_offset)");
 519          break;
 520
 521       default:
 522          unreachable("Invalid texture source type");
 523          break;
 524       }
 525
 526       fprintf(fp, ", ");
 527    }
 528
 529    bool has_nonzero_offset = false;
 530    for (unsigned i = 0; i < 4; i++) {
 531       if (instr->const_offset[i] != 0) {
 532          has_nonzero_offset = true;
 533          break;
 534       }
 535    }
 536
 537    if (has_nonzero_offset) {
 538       fprintf(fp, "[%i %i %i %i] (offset), ",
 539               instr->const_offset[0], instr->const_offset[1],
 540               instr->const_offset[2], instr->const_offset[3]);
 541    }
 542
 543    if (instr->op == nir_texop_tg4) {
 544       fprintf(fp, "%u (gather_component), ", instr->component);
 545    }
 546
 547    if (instr->sampler) {
 548       print_deref(instr->sampler, state);
 549    } else {
 550       fprintf(fp, "%u", instr->sampler_index);
 551    }
 552
 553    fprintf(fp, " (sampler)");
 554 }
 555
 556 static void
 557 print_call_instr(nir_call_instr *instr, print_state *state)
 558 {
 559    FILE *fp = state->fp;
 560
 561    fprintf(fp, "call %s ", instr->callee->function->name);
 562
 563    for (unsigned i = 0; i < instr->num_params; i++) {
 564       if (i != 0)
 565          fprintf(fp, ", ");
 566
 567       print_deref(instr->params[i], state);
 568    }
 569
 570    if (instr->return_deref != NULL) {
 571       if (instr->num_params != 0)
 572          fprintf(fp, ", ");
 573       fprintf(fp, "returning ");
 574       print_deref(instr->return_deref, state);
 575    }
 576 }
 577
 578 static void
 579 print_load_const_instr(nir_load_const_instr *instr, print_state *state)
 580 {
 581    FILE *fp = state->fp;
 582
 583    print_ssa_def(&instr->def, state);
 584
 585    fprintf(fp, " = load_const (");
 586
 587    for (unsigned i = 0; i < instr->def.num_components; i++) {
 588       if (i != 0)
 589          fprintf(fp, ", ");
 590
 591       /*
 592        * we don't really know the type of the constant (if it will be used as a
 593        * float or an int), so just print the raw constant in hex for fidelity
 594        * and then print the float in a comment for readability.
 595        */
 596
 597       fprintf(fp, "0x%08x /* %f */", instr->value.u[i], instr->value.f[i]);
 598    }
 599
 600    fprintf(fp, ")");
 601 }
 602
 603 static void
 604 print_jump_instr(nir_jump_instr *instr, print_state *state)
 605 {
 606    FILE *fp = state->fp;
 607
 608    switch (instr->type) {
 609    case nir_jump_break:
 610       fprintf(fp, "break");
 611       break;
 612
 613    case nir_jump_continue:
 614       fprintf(fp, "continue");
 615       break;
 616
 617    case nir_jump_return:
 618       fprintf(fp, "return");
 619       break;
 620    }
 621 }
 622
 623 static void
 624 print_ssa_undef_instr(nir_ssa_undef_instr* instr, print_state *state)
 625 {
 626    FILE *fp = state->fp;
 627    print_ssa_def(&instr->def, state);
 628    fprintf(fp, " = undefined");
 629 }
 630
 631 static void
 632 print_phi_instr(nir_phi_instr *instr, print_state *state)
 633 {
 634    FILE *fp = state->fp;
 635    print_dest(&instr->dest, state);
 636    fprintf(fp, " = phi ");
 637    nir_foreach_phi_src(instr, src) {
 638       if (&src->node != exec_list_get_head(&instr->srcs))
 639          fprintf(fp, ", ");
 640
 641       fprintf(fp, "block_%u: ", src->pred->index);
 642       print_src(&src->src, state);
 643    }
 644 }
 645
 646 static void
 647 print_parallel_copy_instr(nir_parallel_copy_instr *instr, print_state *state)
 648 {
 649    FILE *fp = state->fp;
 650    nir_foreach_parallel_copy_entry(instr, entry) {
 651       if (&entry->node != exec_list_get_head(&instr->entries))
 652          fprintf(fp, "; ");
 653
 654       print_dest(&entry->dest, state);
 655       fprintf(fp, " = ");
 656       print_src(&entry->src, state);
 657    }
 658 }
 659
 660 static void
 661 print_instr(const nir_instr *instr, print_state *state, unsigned tabs)
 662 {
 663    FILE *fp = state->fp;
 664    print_tabs(tabs, fp);
 665
 666    switch (instr->type) {
 667    case nir_instr_type_alu:
 668       print_alu_instr(nir_instr_as_alu(instr), state);
 669       break;
 670
 671    case nir_instr_type_call:
 672       print_call_instr(nir_instr_as_call(instr), state);
 673       break;
 674
 675    case nir_instr_type_intrinsic:
 676       print_intrinsic_instr(nir_instr_as_intrinsic(instr), state);
 677       break;
 678
 679    case nir_instr_type_tex:
 680       print_tex_instr(nir_instr_as_tex(instr), state);
 681       break;
 682
 683    case nir_instr_type_load_const:
 684       print_load_const_instr(nir_instr_as_load_const(instr), state);
 685       break;
 686
 687    case nir_instr_type_jump:
 688       print_jump_instr(nir_instr_as_jump(instr), state);
 689       break;
 690
 691    case nir_instr_type_ssa_undef:
 692       print_ssa_undef_instr(nir_instr_as_ssa_undef(instr), state);
 693       break;
 694
 695    case nir_instr_type_phi:
 696       print_phi_instr(nir_instr_as_phi(instr), state);
 697       break;
 698
 699    case nir_instr_type_parallel_copy:
 700       print_parallel_copy_instr(nir_instr_as_parallel_copy(instr), state);
 701       break;
 702
 703    default:
 704       unreachable("Invalid instruction type");
 705       break;
 706    }
 707 }
 708
 709 static int
 710 compare_block_index(const void *p1, const void *p2)
 711 {
 712    const nir_block *block1 = *((const nir_block **) p1);
 713    const nir_block *block2 = *((const nir_block **) p2);
 714
 715    return (int) block1->index - (int) block2->index;
 716 }
 717
 718 static void print_cf_node(nir_cf_node *node, print_state *state,
 719                           unsigned tabs);
 720
 721 static void
 722 print_block(nir_block *block, print_state *state, unsigned tabs)
 723 {
 724    FILE *fp = state->fp;
 725
 726    print_tabs(tabs, fp);
 727    fprintf(fp, "block block_%u:\n", block->index);
 728
 729    /* sort the predecessors by index so we consistently print the same thing */
 730
 731    nir_block **preds =
 732       malloc(block->predecessors->entries * sizeof(nir_block *));
 733
 734    struct set_entry *entry;
 735    unsigned i = 0;
 736    set_foreach(block->predecessors, entry) {
 737       preds[i++] = (nir_block *) entry->key;
 738    }
 739
 740    qsort(preds, block->predecessors->entries, sizeof(nir_block *),
 741          compare_block_index);
 742
 743    print_tabs(tabs, fp);
 744    fprintf(fp, "/* preds: ");
 745    for (unsigned i = 0; i < block->predecessors->entries; i++) {
 746       fprintf(fp, "block_%u ", preds[i]->index);
 747    }
 748    fprintf(fp, "*/\n");
 749
 750    free(preds);
 751
 752    nir_foreach_instr(block, instr) {
 753       print_instr(instr, state, tabs);
 754       fprintf(fp, "\n");
 755    }
 756
 757    print_tabs(tabs, fp);
 758    fprintf(fp, "/* succs: ");
 759    for (unsigned i = 0; i < 2; i++)
 760       if (block->successors[i]) {
 761          fprintf(fp, "block_%u ", block->successors[i]->index);
 762       }
 763    fprintf(fp, "*/\n");
 764 }
 765
 766 static void
 767 print_if(nir_if *if_stmt, print_state *state, unsigned tabs)
 768 {
 769    FILE *fp = state->fp;
 770
 771    print_tabs(tabs, fp);
 772    fprintf(fp, "if ");
 773    print_src(&if_stmt->condition, state);
 774    fprintf(fp, " {\n");
 775    foreach_list_typed(nir_cf_node, node, node, &if_stmt->then_list) {
 776       print_cf_node(node, state, tabs + 1);
 777    }
 778    print_tabs(tabs, fp);
 779    fprintf(fp, "} else {\n");
 780    foreach_list_typed(nir_cf_node, node, node, &if_stmt->else_list) {
 781       print_cf_node(node, state, tabs + 1);
 782    }
 783    print_tabs(tabs, fp);
 784    fprintf(fp, "}\n");
 785 }
 786
 787 static void
 788 print_loop(nir_loop *loop, print_state *state, unsigned tabs)
 789 {
 790    FILE *fp = state->fp;
 791
 792    print_tabs(tabs, fp);
 793    fprintf(fp, "loop {\n");
 794    foreach_list_typed(nir_cf_node, node, node, &loop->body) {
 795       print_cf_node(node, state, tabs + 1);
 796    }
 797    print_tabs(tabs, fp);
 798    fprintf(fp, "}\n");
 799 }
 800
 801 static void
 802 print_cf_node(nir_cf_node *node, print_state *state, unsigned int tabs)
 803 {
 804    switch (node->type) {
 805    case nir_cf_node_block:
 806       print_block(nir_cf_node_as_block(node), state, tabs);
 807       break;
 808
 809    case nir_cf_node_if:
 810       print_if(nir_cf_node_as_if(node), state, tabs);
 811       break;
 812
 813    case nir_cf_node_loop:
 814       print_loop(nir_cf_node_as_loop(node), state, tabs);
 815       break;
 816
 817    default:
 818       unreachable("Invalid CFG node type");
 819    }
 820 }
 821
 822 static void
 823 print_function_impl(nir_function_impl *impl, print_state *state)
 824 {
 825    FILE *fp = state->fp;
 826
 827    fprintf(fp, "\nimpl %s ", impl->overload->function->name);
 828
 829    for (unsigned i = 0; i < impl->num_params; i++) {
 830       if (i != 0)
 831          fprintf(fp, ", ");
 832
 833       print_var(impl->params[i], state);
 834    }
 835
 836    if (impl->return_var != NULL) {
 837       if (impl->num_params != 0)
 838          fprintf(fp, ", ");
 839       fprintf(fp, "returning ");
 840       print_var(impl->return_var, state);
 841    }
 842
 843    fprintf(fp, "{\n");
 844
 845    foreach_list_typed(nir_variable, var, node, &impl->locals) {
 846       fprintf(fp, "\t");
 847       print_var_decl(var, state);
 848    }
 849
 850    foreach_list_typed(nir_register, reg, node, &impl->registers) {
 851       fprintf(fp, "\t");
 852       print_register_decl(reg, state);
 853    }
 854
 855    nir_index_blocks(impl);
 856
 857    foreach_list_typed(nir_cf_node, node, node, &impl->body) {
 858       print_cf_node(node, state, 1);
 859    }
 860
 861    fprintf(fp, "\tblock block_%u:\n}\n\n", impl->end_block->index);
 862 }
 863
 864 static void
 865 print_function_overload(nir_function_overload *overload,
 866                         print_state *state)
 867 {
 868    FILE *fp = state->fp;
 869
 870    fprintf(fp, "decl_overload %s ", overload->function->name);
 871
 872    for (unsigned i = 0; i < overload->num_params; i++) {
 873       if (i != 0)
 874          fprintf(fp, ", ");
 875
 876       switch (overload->params[i].param_type) {
 877       case nir_parameter_in:
 878          fprintf(fp, "in ");
 879          break;
 880       case nir_parameter_out:
 881          fprintf(fp, "out ");
 882          break;
 883       case nir_parameter_inout:
 884          fprintf(fp, "inout ");
 885          break;
 886       default:
 887          unreachable("Invalid parameter type");
 888       }
 889
 890       glsl_print_type(overload->params[i].type, fp);
 891    }
 892
 893    if (overload->return_type != NULL) {
 894       if (overload->num_params != 0)
 895          fprintf(fp, ", ");
 896       fprintf(fp, "returning ");
 897       glsl_print_type(overload->return_type, fp);
 898    }
 899
 900    fprintf(fp, "\n");
 901
 902    if (overload->impl != NULL) {
 903       print_function_impl(overload->impl, state);
 904       return;
 905    }
 906 }
 907
 908 static void
 909 print_function(nir_function *func, print_state *state)
 910 {
 911    foreach_list_typed(nir_function_overload, overload, node, &func->overload_list) {
 912       print_function_overload(overload, state);
 913    }
 914 }
 915
 916 static void
 917 init_print_state(print_state *state, nir_shader *shader, FILE *fp)
 918 {
 919    state->fp = fp;
 920    state->shader = shader;
 921    state->ht = _mesa_hash_table_create(NULL, _mesa_hash_pointer,
 922                                        _mesa_key_pointer_equal);
 923    state->syms = _mesa_set_create(NULL, _mesa_key_hash_string,
 924                                   _mesa_key_string_equal);
 925    state->index = 0;
 926 }
 927
 928 static void
 929 destroy_print_state(print_state *state)
 930 {
 931    _mesa_hash_table_destroy(state->ht, NULL);
 932    _mesa_set_destroy(state->syms, NULL);
 933 }
 934
 935 void
 936 nir_print_shader(nir_shader *shader, FILE *fp)
 937 {
 938    print_state state;
 939    init_print_state(&state, shader, fp);
 940
 941    fprintf(fp, "shader: %s\n", gl_shader_stage_name(shader->stage));
 942
 943    foreach_list_typed(nir_variable, var, node, &shader->uniforms) {
 944       print_var_decl(var, &state);
 945    }
 946
 947    foreach_list_typed(nir_variable, var, node, &shader->inputs) {
 948       print_var_decl(var, &state);
 949    }
 950
 951    foreach_list_typed(nir_variable, var, node, &shader->outputs) {
 952       print_var_decl(var, &state);
 953    }
 954
 955    foreach_list_typed(nir_variable, var, node, &shader->globals) {
 956       print_var_decl(var, &state);
 957    }
 958
 959    foreach_list_typed(nir_variable, var, node, &shader->system_values) {
 960       print_var_decl(var, &state);
 961    }
 962
 963    foreach_list_typed(nir_register, reg, node, &shader->registers) {
 964       print_register_decl(reg, &state);
 965    }
 966
 967    foreach_list_typed(nir_function, func, node, &shader->functions) {
 968       print_function(func, &state);
 969    }
 970
 971    destroy_print_state(&state);
 972 }
 973
 974 void
 975 nir_print_instr(const nir_instr *instr, FILE *fp)
 976 {
 977    print_state state = {
 978       .fp = fp,
 979    };
 980    print_instr(instr, &state, 0);
 981
 982 }