src/compiler/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 "compiler/shader_enums.h"
  30 #include "util/half_float.h"
  31 #include <stdio.h>
  32 #include <stdlib.h>
  33 #include <inttypes.h> /* for PRIx64 macro */
  34
  35 static void
  36 print_tabs(unsigned num_tabs, FILE *fp)
  37 {
  38    for (unsigned i = 0; i < num_tabs; i++)
  39       fprintf(fp, "\t");
  40 }
  41
  42 typedef struct {
  43    FILE *fp;
  44    nir_shader *shader;
  45    /** map from nir_variable -> printable name */
  46    struct hash_table *ht;
  47
  48    /** set of names used so far for nir_variables */
  49    struct set *syms;
  50
  51    /* an index used to make new non-conflicting names */
  52    unsigned index;
  53
  54    /**
  55     * Optional table of annotations mapping nir object
  56     * (such as instr or var) to message to print.
  57     */
  58    struct hash_table *annotations;
  59 } print_state;
  60
  61 static void
  62 print_annotation(print_state *state, void *obj)
  63 {
  64    if (!state->annotations)
  65       return;
  66
  67    struct hash_entry *entry = _mesa_hash_table_search(state->annotations, obj);
  68    if (!entry)
  69       return;
  70
  71    const char *note = entry->data;
  72    _mesa_hash_table_remove(state->annotations, entry);
  73
  74    fprintf(stderr, "%s\n\n", note);
  75 }
  76
  77 static void
  78 print_register(nir_register *reg, print_state *state)
  79 {
  80    FILE *fp = state->fp;
  81    if (reg->name != NULL)
  82       fprintf(fp, "/* %s */ ", reg->name);
  83    if (reg->is_global)
  84       fprintf(fp, "gr%u", reg->index);
  85    else
  86       fprintf(fp, "r%u", reg->index);
  87 }
  88
  89 static const char *sizes[] = { "error", "vec1", "vec2", "vec3", "vec4",
  90                                "error", "error", "error", "vec8",
  91                                "error", "error", "error", "error",
  92                                "error", "error", "error", "vec16"};
  93
  94 static void
  95 print_register_decl(nir_register *reg, print_state *state)
  96 {
  97    FILE *fp = state->fp;
  98    fprintf(fp, "decl_reg %s %u ", sizes[reg->num_components], reg->bit_size);
  99    if (reg->is_packed)
 100       fprintf(fp, "(packed) ");
 101    print_register(reg, state);
 102    if (reg->num_array_elems != 0)
 103       fprintf(fp, "[%u]", reg->num_array_elems);
 104    fprintf(fp, "\n");
 105 }
 106
 107 static void
 108 print_ssa_def(nir_ssa_def *def, print_state *state)
 109 {
 110    FILE *fp = state->fp;
 111    if (def->name != NULL)
 112       fprintf(fp, "/* %s */ ", def->name);
 113    fprintf(fp, "%s %u ssa_%u", sizes[def->num_components], def->bit_size,
 114            def->index);
 115 }
 116
 117 static void
 118 print_ssa_use(nir_ssa_def *def, print_state *state)
 119 {
 120    FILE *fp = state->fp;
 121    if (def->name != NULL)
 122       fprintf(fp, "/* %s */ ", def->name);
 123    fprintf(fp, "ssa_%u", def->index);
 124 }
 125
 126 static void print_src(nir_src *src, print_state *state);
 127
 128 static void
 129 print_reg_src(nir_reg_src *src, print_state *state)
 130 {
 131    FILE *fp = state->fp;
 132    print_register(src->reg, state);
 133    if (src->reg->num_array_elems != 0) {
 134       fprintf(fp, "[%u", src->base_offset);
 135       if (src->indirect != NULL) {
 136          fprintf(fp, " + ");
 137          print_src(src->indirect, state);
 138       }
 139       fprintf(fp, "]");
 140    }
 141 }
 142
 143 static void
 144 print_reg_dest(nir_reg_dest *dest, print_state *state)
 145 {
 146    FILE *fp = state->fp;
 147    print_register(dest->reg, state);
 148    if (dest->reg->num_array_elems != 0) {
 149       fprintf(fp, "[%u", dest->base_offset);
 150       if (dest->indirect != NULL) {
 151          fprintf(fp, " + ");
 152          print_src(dest->indirect, state);
 153       }
 154       fprintf(fp, "]");
 155    }
 156 }
 157
 158 static void
 159 print_src(nir_src *src, print_state *state)
 160 {
 161    if (src->is_ssa)
 162       print_ssa_use(src->ssa, state);
 163    else
 164       print_reg_src(&src->reg, state);
 165 }
 166
 167 static void
 168 print_dest(nir_dest *dest, print_state *state)
 169 {
 170    if (dest->is_ssa)
 171       print_ssa_def(&dest->ssa, state);
 172    else
 173       print_reg_dest(&dest->reg, state);
 174 }
 175
 176 static void
 177 print_alu_src(nir_alu_instr *instr, unsigned src, print_state *state)
 178 {
 179    FILE *fp = state->fp;
 180
 181    if (instr->src[src].negate)
 182       fprintf(fp, "-");
 183    if (instr->src[src].abs)
 184       fprintf(fp, "abs(");
 185
 186    print_src(&instr->src[src].src, state);
 187
 188    bool print_swizzle = false;
 189    nir_component_mask_t used_channels = 0;
 190
 191    for (unsigned i = 0; i < NIR_MAX_VEC_COMPONENTS; i++) {
 192       if (!nir_alu_instr_channel_used(instr, src, i))
 193          continue;
 194
 195       used_channels++;
 196
 197       if (instr->src[src].swizzle[i] != i) {
 198          print_swizzle = true;
 199          break;
 200       }
 201    }
 202
 203    unsigned live_channels = nir_src_num_components(instr->src[src].src);
 204
 205    if (print_swizzle || used_channels != live_channels) {
 206       fprintf(fp, ".");
 207       for (unsigned i = 0; i < NIR_MAX_VEC_COMPONENTS; i++) {
 208          if (!nir_alu_instr_channel_used(instr, src, i))
 209             continue;
 210
 211          fprintf(fp, "%c", "xyzw"[instr->src[src].swizzle[i]]);
 212       }
 213    }
 214
 215    if (instr->src[src].abs)
 216       fprintf(fp, ")");
 217 }
 218
 219 static void
 220 print_alu_dest(nir_alu_dest *dest, print_state *state)
 221 {
 222    FILE *fp = state->fp;
 223    /* we're going to print the saturate modifier later, after the opcode */
 224
 225    print_dest(&dest->dest, state);
 226
 227    if (!dest->dest.is_ssa &&
 228        dest->write_mask != (1 << dest->dest.reg.reg->num_components) - 1) {
 229       fprintf(fp, ".");
 230       for (unsigned i = 0; i < NIR_MAX_VEC_COMPONENTS; i++)
 231          if ((dest->write_mask >> i) & 1)
 232             fprintf(fp, "%c", "xyzw"[i]);
 233    }
 234 }
 235
 236 static void
 237 print_alu_instr(nir_alu_instr *instr, print_state *state)
 238 {
 239    FILE *fp = state->fp;
 240
 241    print_alu_dest(&instr->dest, state);
 242
 243    fprintf(fp, " = %s", nir_op_infos[instr->op].name);
 244    if (instr->exact)
 245       fprintf(fp, "!");
 246    if (instr->dest.saturate)
 247       fprintf(fp, ".sat");
 248    fprintf(fp, " ");
 249
 250    for (unsigned i = 0; i < nir_op_infos[instr->op].num_inputs; i++) {
 251       if (i != 0)
 252          fprintf(fp, ", ");
 253
 254       print_alu_src(instr, i, state);
 255    }
 256 }
 257
 258 static const char *
 259 get_var_name(nir_variable *var, print_state *state)
 260 {
 261    if (state->ht == NULL)
 262       return var->name ? var->name : "unnamed";
 263
 264    assert(state->syms);
 265
 266    struct hash_entry *entry = _mesa_hash_table_search(state->ht, var);
 267    if (entry)
 268       return entry->data;
 269
 270    char *name;
 271    if (var->name == NULL) {
 272       name = ralloc_asprintf(state->syms, "@%u", state->index++);
 273    } else {
 274       struct set_entry *set_entry = _mesa_set_search(state->syms, var->name);
 275       if (set_entry != NULL) {
 276          /* we have a collision with another name, append an @ + a unique
 277           * index */
 278          name = ralloc_asprintf(state->syms, "%s@%u", var->name,
 279                                 state->index++);
 280       } else {
 281          /* Mark this one as seen */
 282          _mesa_set_add(state->syms, var->name);
 283          name = var->name;
 284       }
 285    }
 286
 287    _mesa_hash_table_insert(state->ht, var, name);
 288
 289    return name;
 290 }
 291
 292 static void
 293 print_constant(nir_constant *c, const struct glsl_type *type, print_state *state)
 294 {
 295    FILE *fp = state->fp;
 296    const unsigned rows = glsl_get_vector_elements(type);
 297    const unsigned cols = glsl_get_matrix_columns(type);
 298    unsigned i, j;
 299
 300    switch (glsl_get_base_type(type)) {
 301    case GLSL_TYPE_BOOL:
 302       /* Only float base types can be matrices. */
 303       assert(cols == 1);
 304
 305       for (i = 0; i < rows; i++) {
 306          if (i > 0) fprintf(fp, ", ");
 307          fprintf(fp, "%s", c->values[0].b[i] ? "true" : "false");
 308       }
 309       break;
 310
 311    case GLSL_TYPE_UINT8:
 312    case GLSL_TYPE_INT8:
 313       /* Only float base types can be matrices. */
 314       assert(cols == 1);
 315
 316       for (i = 0; i < rows; i++) {
 317          if (i > 0) fprintf(fp, ", ");
 318          fprintf(fp, "0x%02x", c->values[0].u8[i]);
 319       }
 320       break;
 321
 322    case GLSL_TYPE_UINT16:
 323    case GLSL_TYPE_INT16:
 324       /* Only float base types can be matrices. */
 325       assert(cols == 1);
 326
 327       for (i = 0; i < rows; i++) {
 328          if (i > 0) fprintf(fp, ", ");
 329          fprintf(fp, "0x%04x", c->values[0].u16[i]);
 330       }
 331       break;
 332
 333    case GLSL_TYPE_UINT:
 334    case GLSL_TYPE_INT:
 335       /* Only float base types can be matrices. */
 336       assert(cols == 1);
 337
 338       for (i = 0; i < rows; i++) {
 339          if (i > 0) fprintf(fp, ", ");
 340          fprintf(fp, "0x%08x", c->values[0].u32[i]);
 341       }
 342       break;
 343
 344    case GLSL_TYPE_FLOAT16:
 345       for (i = 0; i < cols; i++) {
 346          for (j = 0; j < rows; j++) {
 347             if (i + j > 0) fprintf(fp, ", ");
 348             fprintf(fp, "%f", _mesa_half_to_float(c->values[i].u16[j]));
 349          }
 350       }
 351       break;
 352
 353    case GLSL_TYPE_FLOAT:
 354       for (i = 0; i < cols; i++) {
 355          for (j = 0; j < rows; j++) {
 356             if (i + j > 0) fprintf(fp, ", ");
 357             fprintf(fp, "%f", c->values[i].f32[j]);
 358          }
 359       }
 360       break;
 361
 362    case GLSL_TYPE_DOUBLE:
 363       for (i = 0; i < cols; i++) {
 364          for (j = 0; j < rows; j++) {
 365             if (i + j > 0) fprintf(fp, ", ");
 366             fprintf(fp, "%f", c->values[i].f64[j]);
 367          }
 368       }
 369       break;
 370
 371    case GLSL_TYPE_UINT64:
 372    case GLSL_TYPE_INT64:
 373       /* Only float base types can be matrices. */
 374       assert(cols == 1);
 375
 376       for (i = 0; i < cols; i++) {
 377          if (i > 0) fprintf(fp, ", ");
 378          fprintf(fp, "0x%08" PRIx64, c->values[0].u64[i]);
 379       }
 380       break;
 381
 382    case GLSL_TYPE_STRUCT:
 383       for (i = 0; i < c->num_elements; i++) {
 384          if (i > 0) fprintf(fp, ", ");
 385          fprintf(fp, "{ ");
 386          print_constant(c->elements[i], glsl_get_struct_field(type, i), state);
 387          fprintf(fp, " }");
 388       }
 389       break;
 390
 391    case GLSL_TYPE_ARRAY:
 392       for (i = 0; i < c->num_elements; i++) {
 393          if (i > 0) fprintf(fp, ", ");
 394          fprintf(fp, "{ ");
 395          print_constant(c->elements[i], glsl_get_array_element(type), state);
 396          fprintf(fp, " }");
 397       }
 398       break;
 399
 400    default:
 401       unreachable("not reached");
 402    }
 403 }
 404
 405 static const char *
 406 get_variable_mode_str(nir_variable_mode mode, bool want_local_global_mode)
 407 {
 408    switch (mode) {
 409    case nir_var_shader_in:
 410       return "shader_in";
 411    case nir_var_shader_out:
 412       return "shader_out";
 413    case nir_var_uniform:
 414       return "uniform";
 415    case nir_var_shader_storage:
 416       return "shader_storage";
 417    case nir_var_system_value:
 418       return "system";
 419    case nir_var_shared:
 420       return "shared";
 421    case nir_var_global:
 422       return want_local_global_mode ? "global" : "";
 423    case nir_var_local:
 424       return want_local_global_mode ? "local" : "";
 425    default:
 426       return "";
 427    }
 428 }
 429
 430 static void
 431 print_var_decl(nir_variable *var, print_state *state)
 432 {
 433    FILE *fp = state->fp;
 434
 435    fprintf(fp, "decl_var ");
 436
 437    const char *const cent = (var->data.centroid) ? "centroid " : "";
 438    const char *const samp = (var->data.sample) ? "sample " : "";
 439    const char *const patch = (var->data.patch) ? "patch " : "";
 440    const char *const inv = (var->data.invariant) ? "invariant " : "";
 441    fprintf(fp, "%s%s%s%s%s %s ",
 442            cent, samp, patch, inv, get_variable_mode_str(var->data.mode, false),
 443            glsl_interp_mode_name(var->data.interpolation));
 444
 445    enum gl_access_qualifier access = var->data.image.access;
 446    const char *const coher = (access & ACCESS_COHERENT) ? "coherent " : "";
 447    const char *const volat = (access & ACCESS_VOLATILE) ? "volatile " : "";
 448    const char *const restr = (access & ACCESS_RESTRICT) ? "restrict " : "";
 449    const char *const ronly = (access & ACCESS_NON_WRITEABLE) ? "readonly " : "";
 450    const char *const wonly = (access & ACCESS_NON_READABLE) ? "writeonly " : "";
 451    fprintf(fp, "%s%s%s%s%s", coher, volat, restr, ronly, wonly);
 452
 453 #define FORMAT_CASE(x) case x: fprintf(stderr, #x " "); break
 454    switch (var->data.image.format) {
 455    FORMAT_CASE(GL_RGBA32F);
 456    FORMAT_CASE(GL_RGBA32UI);
 457    FORMAT_CASE(GL_RGBA32I);
 458    FORMAT_CASE(GL_R32F);
 459    FORMAT_CASE(GL_R32UI);
 460    FORMAT_CASE(GL_R32I);
 461    FORMAT_CASE(GL_RG32F);
 462    FORMAT_CASE(GL_RG32UI);
 463    FORMAT_CASE(GL_RG32I);
 464    FORMAT_CASE(GL_R8);
 465    FORMAT_CASE(GL_RG8);
 466    FORMAT_CASE(GL_RGBA8);
 467    FORMAT_CASE(GL_R8_SNORM);
 468    FORMAT_CASE(GL_RG8_SNORM);
 469    FORMAT_CASE(GL_RGBA8_SNORM);
 470    FORMAT_CASE(GL_R16);
 471    FORMAT_CASE(GL_RG16);
 472    FORMAT_CASE(GL_RGBA16);
 473    FORMAT_CASE(GL_R16_SNORM);
 474    FORMAT_CASE(GL_RG16_SNORM);
 475    FORMAT_CASE(GL_RGBA16_SNORM);
 476    FORMAT_CASE(GL_R16F);
 477    FORMAT_CASE(GL_RG16F);
 478    FORMAT_CASE(GL_RGBA16F);
 479    FORMAT_CASE(GL_R8UI);
 480    FORMAT_CASE(GL_R8I);
 481    FORMAT_CASE(GL_RG8UI);
 482    FORMAT_CASE(GL_RG8I);
 483    FORMAT_CASE(GL_RGBA8UI);
 484    FORMAT_CASE(GL_RGBA8I);
 485    FORMAT_CASE(GL_R16UI);
 486    FORMAT_CASE(GL_R16I);
 487    FORMAT_CASE(GL_RG16UI);
 488    FORMAT_CASE(GL_RG16I);
 489    FORMAT_CASE(GL_RGBA16UI);
 490    FORMAT_CASE(GL_RGBA16I);
 491    FORMAT_CASE(GL_R11F_G11F_B10F);
 492    FORMAT_CASE(GL_RGB9_E5);
 493    FORMAT_CASE(GL_RGB10_A2);
 494    FORMAT_CASE(GL_RGB10_A2UI);
 495    default: /* Including the normal GL_NONE */
 496       break;
 497    }
 498 #undef FORMAT_CASE
 499
 500    fprintf(fp, "%s %s", glsl_get_type_name(var->type),
 501            get_var_name(var, state));
 502
 503    if (var->data.mode == nir_var_shader_in ||
 504        var->data.mode == nir_var_shader_out ||
 505        var->data.mode == nir_var_uniform ||
 506        var->data.mode == nir_var_shader_storage) {
 507       const char *loc = NULL;
 508       char buf[4];
 509
 510       switch (state->shader->info.stage) {
 511       case MESA_SHADER_VERTEX:
 512          if (var->data.mode == nir_var_shader_in)
 513             loc = gl_vert_attrib_name(var->data.location);
 514          else if (var->data.mode == nir_var_shader_out)
 515             loc = gl_varying_slot_name(var->data.location);
 516          break;
 517       case MESA_SHADER_GEOMETRY:
 518          if ((var->data.mode == nir_var_shader_in) ||
 519              (var->data.mode == nir_var_shader_out))
 520             loc = gl_varying_slot_name(var->data.location);
 521          break;
 522       case MESA_SHADER_FRAGMENT:
 523          if (var->data.mode == nir_var_shader_in)
 524             loc = gl_varying_slot_name(var->data.location);
 525          else if (var->data.mode == nir_var_shader_out)
 526             loc = gl_frag_result_name(var->data.location);
 527          break;
 528       case MESA_SHADER_TESS_CTRL:
 529       case MESA_SHADER_TESS_EVAL:
 530       case MESA_SHADER_COMPUTE:
 531       default:
 532          /* TODO */
 533          break;
 534       }
 535
 536       if (!loc) {
 537          snprintf(buf, sizeof(buf), "%u", var->data.location);
 538          loc = buf;
 539       }
 540
 541       /* For shader I/O vars that have been split to components or packed,
 542        * print the fractional location within the input/output.
 543        */
 544       unsigned int num_components =
 545          glsl_get_components(glsl_without_array(var->type));
 546       const char *components = NULL;
 547       char components_local[6] = {'.' /* the rest is 0-filled */};
 548       switch (var->data.mode) {
 549       case nir_var_shader_in:
 550       case nir_var_shader_out:
 551          if (num_components < 4 && num_components != 0) {
 552             const char *xyzw = "xyzw";
 553             for (int i = 0; i < num_components; i++)
 554                components_local[i + 1] = xyzw[i + var->data.location_frac];
 555
 556             components = components_local;
 557          }
 558          break;
 559       default:
 560          break;
 561       }
 562
 563       fprintf(fp, " (%s%s, %u, %u)%s", loc,
 564               components ? components : "",
 565               var->data.driver_location, var->data.binding,
 566               var->data.compact ? " compact" : "");
 567    }
 568
 569    if (var->constant_initializer) {
 570       fprintf(fp, " = { ");
 571       print_constant(var->constant_initializer, var->type, state);
 572       fprintf(fp, " }");
 573    }
 574
 575    fprintf(fp, "\n");
 576    print_annotation(state, var);
 577 }
 578
 579 static void
 580 print_deref_link(nir_deref_instr *instr, bool whole_chain, print_state *state)
 581 {
 582    FILE *fp = state->fp;
 583
 584    if (instr->deref_type == nir_deref_type_var) {
 585       fprintf(fp, "%s", get_var_name(instr->var, state));
 586       return;
 587    } else if (instr->deref_type == nir_deref_type_cast) {
 588       fprintf(fp, "(%s *)", glsl_get_type_name(instr->type));
 589       print_src(&instr->parent, state);
 590       return;
 591    }
 592
 593    assert(instr->parent.is_ssa);
 594    nir_deref_instr *parent =
 595       nir_instr_as_deref(instr->parent.ssa->parent_instr);
 596
 597    /* Is the parent we're going to print a bare cast? */
 598    const bool is_parent_cast =
 599       whole_chain && parent->deref_type == nir_deref_type_cast;
 600
 601    /* If we're not printing the whole chain, the parent we print will be a SSA
 602     * value that represents a pointer.  The only deref type that naturally
 603     * gives a pointer is a cast.
 604     */
 605    const bool is_parent_pointer =
 606       !whole_chain || parent->deref_type == nir_deref_type_cast;
 607
 608    /* Struct derefs have a nice syntax that works on pointers, arrays derefs
 609     * do not.
 610     */
 611    const bool need_deref =
 612       is_parent_pointer && instr->deref_type != nir_deref_type_struct;
 613
 614    /* Cast need extra parens and so * dereferences */
 615    if (is_parent_cast || need_deref)
 616       fprintf(fp, "(");
 617
 618    if (need_deref)
 619       fprintf(fp, "*");
 620
 621    if (whole_chain) {
 622       print_deref_link(parent, whole_chain, state);
 623    } else {
 624       print_src(&instr->parent, state);
 625    }
 626
 627    if (is_parent_cast || need_deref)
 628       fprintf(fp, ")");
 629
 630    switch (instr->deref_type) {
 631    case nir_deref_type_struct:
 632       fprintf(fp, "%s%s", is_parent_pointer ? "->" : ".",
 633               glsl_get_struct_elem_name(parent->type, instr->strct.index));
 634       break;
 635
 636    case nir_deref_type_array: {
 637       nir_const_value *const_index = nir_src_as_const_value(instr->arr.index);
 638       if (const_index) {
 639          fprintf(fp, "[%u]", const_index->u32[0]);
 640       } else {
 641          fprintf(fp, "[");
 642          print_src(&instr->arr.index, state);
 643          fprintf(fp, "]");
 644       }
 645       break;
 646    }
 647
 648    case nir_deref_type_array_wildcard:
 649       fprintf(fp, "[*]");
 650       break;
 651
 652    default:
 653       unreachable("Invalid deref instruction type");
 654    }
 655 }
 656
 657 static void
 658 print_deref_instr(nir_deref_instr *instr, print_state *state)
 659 {
 660    FILE *fp = state->fp;
 661
 662    print_dest(&instr->dest, state);
 663
 664    switch (instr->deref_type) {
 665    case nir_deref_type_var:
 666       fprintf(fp, " = deref_var ");
 667       break;
 668    case nir_deref_type_array:
 669    case nir_deref_type_array_wildcard:
 670       fprintf(fp, " = deref_array ");
 671       break;
 672    case nir_deref_type_struct:
 673       fprintf(fp, " = deref_struct ");
 674       break;
 675    case nir_deref_type_cast:
 676       fprintf(fp, " = deref_cast ");
 677       break;
 678    default:
 679       unreachable("Invalid deref instruction type");
 680    }
 681
 682    /* Only casts naturally return a pointer type */
 683    if (instr->deref_type != nir_deref_type_cast)
 684       fprintf(fp, "&");
 685
 686    print_deref_link(instr, false, state);
 687
 688    fprintf(fp, " (%s %s) ",
 689            get_variable_mode_str(instr->mode, true),
 690            glsl_get_type_name(instr->type));
 691
 692    if (instr->deref_type != nir_deref_type_var &&
 693        instr->deref_type != nir_deref_type_cast) {
 694       /* Print the entire chain as a comment */
 695       fprintf(fp, "/* &");
 696       print_deref_link(instr, true, state);
 697       fprintf(fp, " */");
 698    }
 699 }
 700
 701 static void
 702 print_intrinsic_instr(nir_intrinsic_instr *instr, print_state *state)
 703 {
 704    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
 705    unsigned num_srcs = info->num_srcs;
 706    FILE *fp = state->fp;
 707
 708    if (info->has_dest) {
 709       print_dest(&instr->dest, state);
 710       fprintf(fp, " = ");
 711    }
 712
 713    fprintf(fp, "intrinsic %s (", info->name);
 714
 715    for (unsigned i = 0; i < num_srcs; i++) {
 716       if (i != 0)
 717          fprintf(fp, ", ");
 718
 719       print_src(&instr->src[i], state);
 720    }
 721
 722    fprintf(fp, ") (");
 723
 724    for (unsigned i = 0; i < info->num_indices; i++) {
 725       if (i != 0)
 726          fprintf(fp, ", ");
 727
 728       fprintf(fp, "%d", instr->const_index[i]);
 729    }
 730
 731    fprintf(fp, ")");
 732
 733    static const char *index_name[NIR_INTRINSIC_NUM_INDEX_FLAGS] = {
 734       [NIR_INTRINSIC_BASE] = "base",
 735       [NIR_INTRINSIC_WRMASK] = "wrmask",
 736       [NIR_INTRINSIC_STREAM_ID] = "stream-id",
 737       [NIR_INTRINSIC_UCP_ID] = "ucp-id",
 738       [NIR_INTRINSIC_RANGE] = "range",
 739       [NIR_INTRINSIC_DESC_SET] = "desc-set",
 740       [NIR_INTRINSIC_BINDING] = "binding",
 741       [NIR_INTRINSIC_COMPONENT] = "component",
 742       [NIR_INTRINSIC_INTERP_MODE] = "interp_mode",
 743       [NIR_INTRINSIC_REDUCTION_OP] = "reduction_op",
 744       [NIR_INTRINSIC_CLUSTER_SIZE] = "cluster_size",
 745       [NIR_INTRINSIC_PARAM_IDX] = "param_idx",
 746       [NIR_INTRINSIC_IMAGE_DIM] = "image_dim",
 747       [NIR_INTRINSIC_IMAGE_ARRAY] = "image_array",
 748       [NIR_INTRINSIC_ACCESS] = "access",
 749       [NIR_INTRINSIC_FORMAT] = "format",
 750       [NIR_INTRINSIC_ALIGN_MUL] = "align_mul",
 751       [NIR_INTRINSIC_ALIGN_OFFSET] = "align_offset",
 752    };
 753    for (unsigned idx = 1; idx < NIR_INTRINSIC_NUM_INDEX_FLAGS; idx++) {
 754       if (!info->index_map[idx])
 755          continue;
 756       fprintf(fp, " /*");
 757       if (idx == NIR_INTRINSIC_WRMASK) {
 758          /* special case wrmask to show it as a writemask.. */
 759          unsigned wrmask = nir_intrinsic_write_mask(instr);
 760          fprintf(fp, " wrmask=");
 761          for (unsigned i = 0; i < 4; i++)
 762             if ((wrmask >> i) & 1)
 763                fprintf(fp, "%c", "xyzw"[i]);
 764       } else if (idx == NIR_INTRINSIC_REDUCTION_OP) {
 765          nir_op reduction_op = nir_intrinsic_reduction_op(instr);
 766          fprintf(fp, " reduction_op=%s", nir_op_infos[reduction_op].name);
 767       } else if (idx == NIR_INTRINSIC_IMAGE_DIM) {
 768          static const char *dim_name[] = {
 769             [GLSL_SAMPLER_DIM_1D] = "1D",
 770             [GLSL_SAMPLER_DIM_2D] = "2D",
 771             [GLSL_SAMPLER_DIM_3D] = "3D",
 772             [GLSL_SAMPLER_DIM_CUBE] = "Cube",
 773             [GLSL_SAMPLER_DIM_RECT] = "Rect",
 774             [GLSL_SAMPLER_DIM_BUF] = "Buf",
 775             [GLSL_SAMPLER_DIM_MS] = "2D-MSAA",
 776             [GLSL_SAMPLER_DIM_SUBPASS] = "Subpass",
 777             [GLSL_SAMPLER_DIM_SUBPASS_MS] = "Subpass-MSAA",
 778          };
 779          enum glsl_sampler_dim dim = nir_intrinsic_image_dim(instr);
 780          assert(dim < ARRAY_SIZE(dim_name) && dim_name[dim]);
 781          fprintf(fp, " image_dim=%s", dim_name[dim]);
 782       } else if (idx == NIR_INTRINSIC_IMAGE_ARRAY) {
 783          bool array = nir_intrinsic_image_dim(instr);
 784          fprintf(fp, " image_dim=%s", array ? "true" : "false");
 785       } else {
 786          unsigned off = info->index_map[idx] - 1;
 787          assert(index_name[idx]);  /* forgot to update index_name table? */
 788          fprintf(fp, " %s=%d", index_name[idx], instr->const_index[off]);
 789       }
 790       fprintf(fp, " */");
 791    }
 792
 793    if (!state->shader)
 794       return;
 795
 796    struct exec_list *var_list = NULL;
 797
 798    switch (instr->intrinsic) {
 799    case nir_intrinsic_load_uniform:
 800       var_list = &state->shader->uniforms;
 801       break;
 802    case nir_intrinsic_load_input:
 803    case nir_intrinsic_load_per_vertex_input:
 804       var_list = &state->shader->inputs;
 805       break;
 806    case nir_intrinsic_load_output:
 807    case nir_intrinsic_store_output:
 808    case nir_intrinsic_store_per_vertex_output:
 809       var_list = &state->shader->outputs;
 810       break;
 811    default:
 812       return;
 813    }
 814
 815    nir_foreach_variable(var, var_list) {
 816       if ((var->data.driver_location == nir_intrinsic_base(instr)) &&
 817           (instr->intrinsic == nir_intrinsic_load_uniform ||
 818            var->data.location_frac == nir_intrinsic_component(instr)) &&
 819           var->name) {
 820          fprintf(fp, "\t/* %s */", var->name);
 821          break;
 822       }
 823    }
 824 }
 825
 826 static void
 827 print_tex_instr(nir_tex_instr *instr, print_state *state)
 828 {
 829    FILE *fp = state->fp;
 830
 831    print_dest(&instr->dest, state);
 832
 833    fprintf(fp, " = ");
 834
 835    switch (instr->op) {
 836    case nir_texop_tex:
 837       fprintf(fp, "tex ");
 838       break;
 839    case nir_texop_txb:
 840       fprintf(fp, "txb ");
 841       break;
 842    case nir_texop_txl:
 843       fprintf(fp, "txl ");
 844       break;
 845    case nir_texop_txd:
 846       fprintf(fp, "txd ");
 847       break;
 848    case nir_texop_txf:
 849       fprintf(fp, "txf ");
 850       break;
 851    case nir_texop_txf_ms:
 852       fprintf(fp, "txf_ms ");
 853       break;
 854    case nir_texop_txf_ms_mcs:
 855       fprintf(fp, "txf_ms_mcs ");
 856       break;
 857    case nir_texop_txs:
 858       fprintf(fp, "txs ");
 859       break;
 860    case nir_texop_lod:
 861       fprintf(fp, "lod ");
 862       break;
 863    case nir_texop_tg4:
 864       fprintf(fp, "tg4 ");
 865       break;
 866    case nir_texop_query_levels:
 867       fprintf(fp, "query_levels ");
 868       break;
 869    case nir_texop_texture_samples:
 870       fprintf(fp, "texture_samples ");
 871       break;
 872    case nir_texop_samples_identical:
 873       fprintf(fp, "samples_identical ");
 874       break;
 875    default:
 876       unreachable("Invalid texture operation");
 877       break;
 878    }
 879
 880    bool has_texture_deref = false, has_sampler_deref = false;
 881    for (unsigned i = 0; i < instr->num_srcs; i++) {
 882       print_src(&instr->src[i].src, state);
 883
 884       fprintf(fp, " ");
 885
 886       switch(instr->src[i].src_type) {
 887       case nir_tex_src_coord:
 888          fprintf(fp, "(coord)");
 889          break;
 890       case nir_tex_src_projector:
 891          fprintf(fp, "(projector)");
 892          break;
 893       case nir_tex_src_comparator:
 894          fprintf(fp, "(comparator)");
 895          break;
 896       case nir_tex_src_offset:
 897          fprintf(fp, "(offset)");
 898          break;
 899       case nir_tex_src_bias:
 900          fprintf(fp, "(bias)");
 901          break;
 902       case nir_tex_src_lod:
 903          fprintf(fp, "(lod)");
 904          break;
 905       case nir_tex_src_min_lod:
 906          fprintf(fp, "(min_lod)");
 907          break;
 908       case nir_tex_src_ms_index:
 909          fprintf(fp, "(ms_index)");
 910          break;
 911       case nir_tex_src_ms_mcs:
 912          fprintf(fp, "(ms_mcs)");
 913          break;
 914       case nir_tex_src_ddx:
 915          fprintf(fp, "(ddx)");
 916          break;
 917       case nir_tex_src_ddy:
 918          fprintf(fp, "(ddy)");
 919          break;
 920       case nir_tex_src_texture_deref:
 921          has_texture_deref = true;
 922          fprintf(fp, "(texture_deref)");
 923          break;
 924       case nir_tex_src_sampler_deref:
 925          has_sampler_deref = true;
 926          fprintf(fp, "(sampler_deref)");
 927          break;
 928       case nir_tex_src_texture_offset:
 929          fprintf(fp, "(texture_offset)");
 930          break;
 931       case nir_tex_src_sampler_offset:
 932          fprintf(fp, "(sampler_offset)");
 933          break;
 934       case nir_tex_src_plane:
 935          fprintf(fp, "(plane)");
 936          break;
 937
 938       default:
 939          unreachable("Invalid texture source type");
 940          break;
 941       }
 942
 943       fprintf(fp, ", ");
 944    }
 945
 946    if (instr->op == nir_texop_tg4) {
 947       fprintf(fp, "%u (gather_component), ", instr->component);
 948    }
 949
 950    if (!has_texture_deref) {
 951       fprintf(fp, "%u (texture), ", instr->texture_index);
 952    }
 953
 954    if (!has_sampler_deref) {
 955       fprintf(fp, "%u (sampler), ", instr->sampler_index);
 956    }
 957 }
 958
 959 static void
 960 print_call_instr(nir_call_instr *instr, print_state *state)
 961 {
 962    FILE *fp = state->fp;
 963
 964    fprintf(fp, "call %s ", instr->callee->name);
 965
 966    for (unsigned i = 0; i < instr->num_params; i++) {
 967       if (i != 0)
 968          fprintf(fp, ", ");
 969
 970       print_src(&instr->params[i], state);
 971    }
 972 }
 973
 974 static void
 975 print_load_const_instr(nir_load_const_instr *instr, print_state *state)
 976 {
 977    FILE *fp = state->fp;
 978
 979    print_ssa_def(&instr->def, state);
 980
 981    fprintf(fp, " = load_const (");
 982
 983    for (unsigned i = 0; i < instr->def.num_components; i++) {
 984       if (i != 0)
 985          fprintf(fp, ", ");
 986
 987       /*
 988        * we don't really know the type of the constant (if it will be used as a
 989        * float or an int), so just print the raw constant in hex for fidelity
 990        * and then print the float in a comment for readability.
 991        */
 992
 993       switch (instr->def.bit_size) {
 994       case 64:
 995          fprintf(fp, "0x%16" PRIx64 " /* %f */", instr->value.u64[i],
 996                  instr->value.f64[i]);
 997          break;
 998       case 32:
 999          fprintf(fp, "0x%08x /* %f */", instr->value.u32[i], instr->value.f32[i]);
1000          break;
1001       case 16:
1002          fprintf(fp, "0x%04x /* %f */", instr->value.u16[i],
1003                  _mesa_half_to_float(instr->value.u16[i]));
1004          break;
1005       case 8:
1006          fprintf(fp, "0x%02x", instr->value.u8[i]);
1007          break;
1008       case 1:
1009          fprintf(fp, "%s", instr->value.b[i] ? "true" : "false");
1010          break;
1011       }
1012    }
1013
1014    fprintf(fp, ")");
1015 }
1016
1017 static void
1018 print_jump_instr(nir_jump_instr *instr, print_state *state)
1019 {
1020    FILE *fp = state->fp;
1021
1022    switch (instr->type) {
1023    case nir_jump_break:
1024       fprintf(fp, "break");
1025       break;
1026
1027    case nir_jump_continue:
1028       fprintf(fp, "continue");
1029       break;
1030
1031    case nir_jump_return:
1032       fprintf(fp, "return");
1033       break;
1034    }
1035 }
1036
1037 static void
1038 print_ssa_undef_instr(nir_ssa_undef_instr* instr, print_state *state)
1039 {
1040    FILE *fp = state->fp;
1041    print_ssa_def(&instr->def, state);
1042    fprintf(fp, " = undefined");
1043 }
1044
1045 static void
1046 print_phi_instr(nir_phi_instr *instr, print_state *state)
1047 {
1048    FILE *fp = state->fp;
1049    print_dest(&instr->dest, state);
1050    fprintf(fp, " = phi ");
1051    nir_foreach_phi_src(src, instr) {
1052       if (&src->node != exec_list_get_head(&instr->srcs))
1053          fprintf(fp, ", ");
1054
1055       fprintf(fp, "block_%u: ", src->pred->index);
1056       print_src(&src->src, state);
1057    }
1058 }
1059
1060 static void
1061 print_parallel_copy_instr(nir_parallel_copy_instr *instr, print_state *state)
1062 {
1063    FILE *fp = state->fp;
1064    nir_foreach_parallel_copy_entry(entry, instr) {
1065       if (&entry->node != exec_list_get_head(&instr->entries))
1066          fprintf(fp, "; ");
1067
1068       print_dest(&entry->dest, state);
1069       fprintf(fp, " = ");
1070       print_src(&entry->src, state);
1071    }
1072 }
1073
1074 static void
1075 print_instr(const nir_instr *instr, print_state *state, unsigned tabs)
1076 {
1077    FILE *fp = state->fp;
1078    print_tabs(tabs, fp);
1079
1080    switch (instr->type) {
1081    case nir_instr_type_alu:
1082       print_alu_instr(nir_instr_as_alu(instr), state);
1083       break;
1084
1085    case nir_instr_type_deref:
1086       print_deref_instr(nir_instr_as_deref(instr), state);
1087       break;
1088
1089    case nir_instr_type_call:
1090       print_call_instr(nir_instr_as_call(instr), state);
1091       break;
1092
1093    case nir_instr_type_intrinsic:
1094       print_intrinsic_instr(nir_instr_as_intrinsic(instr), state);
1095       break;
1096
1097    case nir_instr_type_tex:
1098       print_tex_instr(nir_instr_as_tex(instr), state);
1099       break;
1100
1101    case nir_instr_type_load_const:
1102       print_load_const_instr(nir_instr_as_load_const(instr), state);
1103       break;
1104
1105    case nir_instr_type_jump:
1106       print_jump_instr(nir_instr_as_jump(instr), state);
1107       break;
1108
1109    case nir_instr_type_ssa_undef:
1110       print_ssa_undef_instr(nir_instr_as_ssa_undef(instr), state);
1111       break;
1112
1113    case nir_instr_type_phi:
1114       print_phi_instr(nir_instr_as_phi(instr), state);
1115       break;
1116
1117    case nir_instr_type_parallel_copy:
1118       print_parallel_copy_instr(nir_instr_as_parallel_copy(instr), state);
1119       break;
1120
1121    default:
1122       unreachable("Invalid instruction type");
1123       break;
1124    }
1125 }
1126
1127 static int
1128 compare_block_index(const void *p1, const void *p2)
1129 {
1130    const nir_block *block1 = *((const nir_block **) p1);
1131    const nir_block *block2 = *((const nir_block **) p2);
1132
1133    return (int) block1->index - (int) block2->index;
1134 }
1135
1136 static void print_cf_node(nir_cf_node *node, print_state *state,
1137                           unsigned tabs);
1138
1139 static void
1140 print_block(nir_block *block, print_state *state, unsigned tabs)
1141 {
1142    FILE *fp = state->fp;
1143
1144    print_tabs(tabs, fp);
1145    fprintf(fp, "block block_%u:\n", block->index);
1146
1147    /* sort the predecessors by index so we consistently print the same thing */
1148
1149    nir_block **preds =
1150       malloc(block->predecessors->entries * sizeof(nir_block *));
1151
1152    unsigned i = 0;
1153    set_foreach(block->predecessors, entry) {
1154       preds[i++] = (nir_block *) entry->key;
1155    }
1156
1157    qsort(preds, block->predecessors->entries, sizeof(nir_block *),
1158          compare_block_index);
1159
1160    print_tabs(tabs, fp);
1161    fprintf(fp, "/* preds: ");
1162    for (unsigned i = 0; i < block->predecessors->entries; i++) {
1163       fprintf(fp, "block_%u ", preds[i]->index);
1164    }
1165    fprintf(fp, "*/\n");
1166
1167    free(preds);
1168
1169    nir_foreach_instr(instr, block) {
1170       print_instr(instr, state, tabs);
1171       fprintf(fp, "\n");
1172       print_annotation(state, instr);
1173    }
1174
1175    print_tabs(tabs, fp);
1176    fprintf(fp, "/* succs: ");
1177    for (unsigned i = 0; i < 2; i++)
1178       if (block->successors[i]) {
1179          fprintf(fp, "block_%u ", block->successors[i]->index);
1180       }
1181    fprintf(fp, "*/\n");
1182 }
1183
1184 static void
1185 print_if(nir_if *if_stmt, print_state *state, unsigned tabs)
1186 {
1187    FILE *fp = state->fp;
1188
1189    print_tabs(tabs, fp);
1190    fprintf(fp, "if ");
1191    print_src(&if_stmt->condition, state);
1192    fprintf(fp, " {\n");
1193    foreach_list_typed(nir_cf_node, node, node, &if_stmt->then_list) {
1194       print_cf_node(node, state, tabs + 1);
1195    }
1196    print_tabs(tabs, fp);
1197    fprintf(fp, "} else {\n");
1198    foreach_list_typed(nir_cf_node, node, node, &if_stmt->else_list) {
1199       print_cf_node(node, state, tabs + 1);
1200    }
1201    print_tabs(tabs, fp);
1202    fprintf(fp, "}\n");
1203 }
1204
1205 static void
1206 print_loop(nir_loop *loop, print_state *state, unsigned tabs)
1207 {
1208    FILE *fp = state->fp;
1209
1210    print_tabs(tabs, fp);
1211    fprintf(fp, "loop {\n");
1212    foreach_list_typed(nir_cf_node, node, node, &loop->body) {
1213       print_cf_node(node, state, tabs + 1);
1214    }
1215    print_tabs(tabs, fp);
1216    fprintf(fp, "}\n");
1217 }
1218
1219 static void
1220 print_cf_node(nir_cf_node *node, print_state *state, unsigned int tabs)
1221 {
1222    switch (node->type) {
1223    case nir_cf_node_block:
1224       print_block(nir_cf_node_as_block(node), state, tabs);
1225       break;
1226
1227    case nir_cf_node_if:
1228       print_if(nir_cf_node_as_if(node), state, tabs);
1229       break;
1230
1231    case nir_cf_node_loop:
1232       print_loop(nir_cf_node_as_loop(node), state, tabs);
1233       break;
1234
1235    default:
1236       unreachable("Invalid CFG node type");
1237    }
1238 }
1239
1240 static void
1241 print_function_impl(nir_function_impl *impl, print_state *state)
1242 {
1243    FILE *fp = state->fp;
1244
1245    fprintf(fp, "\nimpl %s ", impl->function->name);
1246
1247    fprintf(fp, "{\n");
1248
1249    nir_foreach_variable(var, &impl->locals) {
1250       fprintf(fp, "\t");
1251       print_var_decl(var, state);
1252    }
1253
1254    foreach_list_typed(nir_register, reg, node, &impl->registers) {
1255       fprintf(fp, "\t");
1256       print_register_decl(reg, state);
1257    }
1258
1259    nir_index_blocks(impl);
1260
1261    foreach_list_typed(nir_cf_node, node, node, &impl->body) {
1262       print_cf_node(node, state, 1);
1263    }
1264
1265    fprintf(fp, "\tblock block_%u:\n}\n\n", impl->end_block->index);
1266 }
1267
1268 static void
1269 print_function(nir_function *function, print_state *state)
1270 {
1271    FILE *fp = state->fp;
1272
1273    fprintf(fp, "decl_function %s (%d params)", function->name,
1274            function->num_params);
1275
1276    fprintf(fp, "\n");
1277
1278    if (function->impl != NULL) {
1279       print_function_impl(function->impl, state);
1280       return;
1281    }
1282 }
1283
1284 static void
1285 init_print_state(print_state *state, nir_shader *shader, FILE *fp)
1286 {
1287    state->fp = fp;
1288    state->shader = shader;
1289    state->ht = _mesa_hash_table_create(NULL, _mesa_hash_pointer,
1290                                        _mesa_key_pointer_equal);
1291    state->syms = _mesa_set_create(NULL, _mesa_key_hash_string,
1292                                   _mesa_key_string_equal);
1293    state->index = 0;
1294 }
1295
1296 static void
1297 destroy_print_state(print_state *state)
1298 {
1299    _mesa_hash_table_destroy(state->ht, NULL);
1300    _mesa_set_destroy(state->syms, NULL);
1301 }
1302
1303 void
1304 nir_print_shader_annotated(nir_shader *shader, FILE *fp,
1305                            struct hash_table *annotations)
1306 {
1307    print_state state;
1308    init_print_state(&state, shader, fp);
1309
1310    state.annotations = annotations;
1311
1312    fprintf(fp, "shader: %s\n", gl_shader_stage_name(shader->info.stage));
1313
1314    if (shader->info.name)
1315       fprintf(fp, "name: %s\n", shader->info.name);
1316
1317    if (shader->info.label)
1318       fprintf(fp, "label: %s\n", shader->info.label);
1319
1320    switch (shader->info.stage) {
1321    case MESA_SHADER_COMPUTE:
1322       fprintf(fp, "local-size: %u, %u, %u%s\n",
1323               shader->info.cs.local_size[0],
1324               shader->info.cs.local_size[1],
1325               shader->info.cs.local_size[2],
1326               shader->info.cs.local_size_variable ? " (variable)" : "");
1327       fprintf(fp, "shared-size: %u\n", shader->info.cs.shared_size);
1328       break;
1329    default:
1330       break;
1331    }
1332
1333    fprintf(fp, "inputs: %u\n", shader->num_inputs);
1334    fprintf(fp, "outputs: %u\n", shader->num_outputs);
1335    fprintf(fp, "uniforms: %u\n", shader->num_uniforms);
1336    fprintf(fp, "shared: %u\n", shader->num_shared);
1337
1338    nir_foreach_variable(var, &shader->uniforms) {
1339       print_var_decl(var, &state);
1340    }
1341
1342    nir_foreach_variable(var, &shader->inputs) {
1343       print_var_decl(var, &state);
1344    }
1345
1346    nir_foreach_variable(var, &shader->outputs) {
1347       print_var_decl(var, &state);
1348    }
1349
1350    nir_foreach_variable(var, &shader->shared) {
1351       print_var_decl(var, &state);
1352    }
1353
1354    nir_foreach_variable(var, &shader->globals) {
1355       print_var_decl(var, &state);
1356    }
1357
1358    nir_foreach_variable(var, &shader->system_values) {
1359       print_var_decl(var, &state);
1360    }
1361
1362    foreach_list_typed(nir_register, reg, node, &shader->registers) {
1363       print_register_decl(reg, &state);
1364    }
1365
1366    foreach_list_typed(nir_function, func, node, &shader->functions) {
1367       print_function(func, &state);
1368    }
1369
1370    destroy_print_state(&state);
1371 }
1372
1373 void
1374 nir_print_shader(nir_shader *shader, FILE *fp)
1375 {
1376    nir_print_shader_annotated(shader, fp, NULL);
1377    fflush(fp);
1378 }
1379
1380 void
1381 nir_print_instr(const nir_instr *instr, FILE *fp)
1382 {
1383    print_state state = {
1384       .fp = fp,
1385    };
1386    print_instr(instr, &state, 0);
1387
1388 }