X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fglsl%2Fnir%2Fnir_print.c;h=30220c5e48d8758b7593f56fee523e0ad74e5cf6;hb=77f58c04cc287b72e2b859d71591da158db6830a;hp=21d5dde254899c48e6c1adc6673dd4a4eca0db87;hpb=2561aea6b306c4438defeb4ec96be05f6aadd12e;p=mesa.git

diff --git a/src/glsl/nir/nir_print.c b/src/glsl/nir/nir_print.c
index 21d5dde2548..30220c5e48d 100644
--- a/src/glsl/nir/nir_print.c
+++ b/src/glsl/nir/nir_print.c
@@ -26,6 +26,7 @@
  */
 
 #include "nir.h"
+#include "shader_enums.h"
 #include <stdio.h>
 #include <stdlib.h>
 
@@ -37,6 +38,8 @@ print_tabs(unsigned num_tabs, FILE *fp)
 }
 
 typedef struct {
+   FILE *fp;
+   nir_shader *shader;
    /** map from nir_variable -> printable name */
    struct hash_table *ht;
 
@@ -45,11 +48,12 @@ typedef struct {
 
    /* an index used to make new non-conflicting names */
    unsigned index;
-} print_var_state;
+} print_state;
 
 static void
-print_register(nir_register *reg, FILE *fp)
+print_register(nir_register *reg, print_state *state)
 {
+   FILE *fp = state->fp;
    if (reg->name != NULL)
       fprintf(fp, "/* %s */ ", reg->name);
    if (reg->is_global)
@@ -61,110 +65,130 @@ print_register(nir_register *reg, FILE *fp)
 static const char *sizes[] = { "error", "vec1", "vec2", "vec3", "vec4" };
 
 static void
-print_register_decl(nir_register *reg, FILE *fp)
+print_register_decl(nir_register *reg, print_state *state)
 {
+   FILE *fp = state->fp;
    fprintf(fp, "decl_reg %s ", sizes[reg->num_components]);
    if (reg->is_packed)
       fprintf(fp, "(packed) ");
-   print_register(reg, fp);
+   print_register(reg, state);
    if (reg->num_array_elems != 0)
       fprintf(fp, "[%u]", reg->num_array_elems);
    fprintf(fp, "\n");
 }
 
 static void
-print_ssa_def(nir_ssa_def *def, FILE *fp)
+print_ssa_def(nir_ssa_def *def, print_state *state)
 {
+   FILE *fp = state->fp;
    if (def->name != NULL)
       fprintf(fp, "/* %s */ ", def->name);
    fprintf(fp, "%s ssa_%u", sizes[def->num_components], def->index);
 }
 
 static void
-print_ssa_use(nir_ssa_def *def, FILE *fp)
+print_ssa_use(nir_ssa_def *def, print_state *state)
 {
+   FILE *fp = state->fp;
    if (def->name != NULL)
       fprintf(fp, "/* %s */ ", def->name);
    fprintf(fp, "ssa_%u", def->index);
 }
 
-static void print_src(nir_src *src, FILE *fp);
+static void print_src(nir_src *src, print_state *state);
 
 static void
-print_reg_src(nir_reg_src *src, FILE *fp)
+print_reg_src(nir_reg_src *src, print_state *state)
 {
-   print_register(src->reg, fp);
+   FILE *fp = state->fp;
+   print_register(src->reg, state);
    if (src->reg->num_array_elems != 0) {
       fprintf(fp, "[%u", src->base_offset);
       if (src->indirect != NULL) {
          fprintf(fp, " + ");
-         print_src(src->indirect, fp);
+         print_src(src->indirect, state);
       }
       fprintf(fp, "]");
    }
 }
 
 static void
-print_reg_dest(nir_reg_dest *dest, FILE *fp)
+print_reg_dest(nir_reg_dest *dest, print_state *state)
 {
-   print_register(dest->reg, fp);
+   FILE *fp = state->fp;
+   print_register(dest->reg, state);
    if (dest->reg->num_array_elems != 0) {
       fprintf(fp, "[%u", dest->base_offset);
       if (dest->indirect != NULL) {
          fprintf(fp, " + ");
-         print_src(dest->indirect, fp);
+         print_src(dest->indirect, state);
       }
       fprintf(fp, "]");
    }
 }
 
 static void
-print_src(nir_src *src, FILE *fp)
+print_src(nir_src *src, print_state *state)
 {
    if (src->is_ssa)
-      print_ssa_use(src->ssa, fp);
+      print_ssa_use(src->ssa, state);
    else
-      print_reg_src(&src->reg, fp);
+      print_reg_src(&src->reg, state);
 }
 
 static void
-print_dest(nir_dest *dest, FILE *fp)
+print_dest(nir_dest *dest, print_state *state)
 {
    if (dest->is_ssa)
-      print_ssa_def(&dest->ssa, fp);
+      print_ssa_def(&dest->ssa, state);
    else
-      print_reg_dest(&dest->reg, fp);
+      print_reg_dest(&dest->reg, state);
 }
 
 static void
-print_alu_src(nir_alu_src *src, FILE *fp)
+print_alu_src(nir_alu_instr *instr, unsigned src, print_state *state)
 {
-   if (src->negate)
+   FILE *fp = state->fp;
+
+   if (instr->src[src].negate)
       fprintf(fp, "-");
-   if (src->abs)
+   if (instr->src[src].abs)
       fprintf(fp, "abs(");
 
-   print_src(&src->src, fp);
+   print_src(&instr->src[src].src, state);
+
+   bool print_swizzle = false;
+   for (unsigned i = 0; i < 4; i++) {
+      if (!nir_alu_instr_channel_used(instr, src, i))
+         continue;
+
+      if (instr->src[src].swizzle[i] != i) {
+         print_swizzle = true;
+         break;
+      }
+   }
 
-   if (src->swizzle[0] != 0 ||
-       src->swizzle[1] != 1 ||
-       src->swizzle[2] != 2 ||
-       src->swizzle[3] != 3) {
+   if (print_swizzle) {
       fprintf(fp, ".");
-      for (unsigned i = 0; i < 4; i++)
-         fprintf(fp, "%c", "xyzw"[src->swizzle[i]]);
+      for (unsigned i = 0; i < 4; i++) {
+         if (!nir_alu_instr_channel_used(instr, src, i))
+            continue;
+
+         fprintf(fp, "%c", "xyzw"[instr->src[src].swizzle[i]]);
+      }
    }
 
-   if (src->abs)
+   if (instr->src[src].abs)
       fprintf(fp, ")");
 }
 
 static void
-print_alu_dest(nir_alu_dest *dest, FILE *fp)
+print_alu_dest(nir_alu_dest *dest, print_state *state)
 {
+   FILE *fp = state->fp;
    /* we're going to print the saturate modifier later, after the opcode */
 
-   print_dest(&dest->dest, fp);
+   print_dest(&dest->dest, state);
 
    if (!dest->dest.is_ssa &&
        dest->write_mask != (1 << dest->dest.reg.reg->num_components) - 1) {
@@ -176,9 +200,11 @@ print_alu_dest(nir_alu_dest *dest, FILE *fp)
 }
 
 static void
-print_alu_instr(nir_alu_instr *instr, FILE *fp)
+print_alu_instr(nir_alu_instr *instr, print_state *state)
 {
-   print_alu_dest(&instr->dest, fp);
+   FILE *fp = state->fp;
+
+   print_alu_dest(&instr->dest, state);
 
    fprintf(fp, " = %s", nir_op_infos[instr->op].name);
    if (instr->dest.saturate)
@@ -189,29 +215,32 @@ print_alu_instr(nir_alu_instr *instr, FILE *fp)
       if (i != 0)
          fprintf(fp, ", ");
 
-      print_alu_src(&instr->src[i], fp);
+      print_alu_src(instr, i, state);
    }
 }
 
 static void
-print_var_decl(nir_variable *var, print_var_state *state, FILE *fp)
+print_var_decl(nir_variable *var, print_state *state)
 {
+   FILE *fp = state->fp;
+
    fprintf(fp, "decl_var ");
 
    const char *const cent = (var->data.centroid) ? "centroid " : "";
    const char *const samp = (var->data.sample) ? "sample " : "";
+   const char *const patch = (var->data.patch) ? "patch " : "";
    const char *const inv = (var->data.invariant) ? "invariant " : "";
    const char *const mode[] = { "shader_in ", "shader_out ", "", "",
-                                "uniform ", "system " };
-   const char *const interp[] = { "", "smooth", "flat", "noperspective" };
+                                "uniform ", "shader_storage", "system " };
 
-   fprintf(fp, "%s%s%s%s%s ",
-      cent, samp, inv, mode[var->data.mode], interp[var->data.interpolation]);
+   fprintf(fp, "%s%s%s%s%s%s ",
+      cent, samp, patch, inv, mode[var->data.mode],
+	  glsl_interp_qualifier_name(var->data.interpolation));
 
    glsl_print_type(var->type, fp);
 
    struct set_entry *entry = NULL;
-   if (state)
+   if (state->syms)
       entry = _mesa_set_search(state->syms, var->name);
 
    char *name;
@@ -227,23 +256,59 @@ print_var_decl(nir_variable *var, print_var_state *state, FILE *fp)
 
    if (var->data.mode == nir_var_shader_in ||
        var->data.mode == nir_var_shader_out ||
-       var->data.mode == nir_var_uniform) {
-      fprintf(fp, " (%u)", var->data.driver_location);
+       var->data.mode == nir_var_uniform ||
+       var->data.mode == nir_var_shader_storage) {
+      const char *loc = NULL;
+      char buf[4];
+
+      switch (state->shader->stage) {
+      case MESA_SHADER_VERTEX:
+         if (var->data.mode == nir_var_shader_in)
+            loc = gl_vert_attrib_name(var->data.location);
+         else if (var->data.mode == nir_var_shader_out)
+            loc = gl_varying_slot_name(var->data.location);
+         break;
+      case MESA_SHADER_GEOMETRY:
+         if ((var->data.mode == nir_var_shader_in) ||
+             (var->data.mode == nir_var_shader_out))
+            loc = gl_varying_slot_name(var->data.location);
+         break;
+      case MESA_SHADER_FRAGMENT:
+         if (var->data.mode == nir_var_shader_in)
+            loc = gl_varying_slot_name(var->data.location);
+         else if (var->data.mode == nir_var_shader_out)
+            loc = gl_frag_result_name(var->data.location);
+         break;
+      case MESA_SHADER_TESS_CTRL:
+      case MESA_SHADER_TESS_EVAL:
+      case MESA_SHADER_COMPUTE:
+      default:
+         /* TODO */
+         break;
+      }
+
+      if (!loc) {
+         snprintf(buf, sizeof(buf), "%u", var->data.location);
+         loc = buf;
+      }
+
+      fprintf(fp, " (%s, %u)", loc, var->data.driver_location);
    }
 
    fprintf(fp, "\n");
 
-   if (state) {
+   if (state->syms) {
       _mesa_set_add(state->syms, name);
       _mesa_hash_table_insert(state->ht, var, name);
    }
 }
 
 static void
-print_var(nir_variable *var, print_var_state *state, FILE *fp)
+print_var(nir_variable *var, print_state *state)
 {
+   FILE *fp = state->fp;
    const char *name;
-   if (state) {
+   if (state->ht) {
       struct hash_entry *entry = _mesa_hash_table_search(state->ht, var);
 
       assert(entry != NULL);
@@ -256,14 +321,15 @@ print_var(nir_variable *var, print_var_state *state, FILE *fp)
 }
 
 static void
-print_deref_var(nir_deref_var *deref, print_var_state *state, FILE *fp)
+print_deref_var(nir_deref_var *deref, print_state *state)
 {
-   print_var(deref->var, state, fp);
+   print_var(deref->var, state);
 }
 
 static void
-print_deref_array(nir_deref_array *deref, print_var_state *state, FILE *fp)
+print_deref_array(nir_deref_array *deref, print_state *state)
 {
+   FILE *fp = state->fp;
    fprintf(fp, "[");
    switch (deref->deref_array_type) {
    case nir_deref_array_type_direct:
@@ -272,7 +338,7 @@ print_deref_array(nir_deref_array *deref, print_var_state *state, FILE *fp)
    case nir_deref_array_type_indirect:
       if (deref->base_offset != 0)
          fprintf(fp, "%u + ", deref->base_offset);
-      print_src(&deref->indirect, fp);
+      print_src(&deref->indirect, state);
       break;
    case nir_deref_array_type_wildcard:
       fprintf(fp, "*");
@@ -283,13 +349,14 @@ print_deref_array(nir_deref_array *deref, print_var_state *state, FILE *fp)
 
 static void
 print_deref_struct(nir_deref_struct *deref, const struct glsl_type *parent_type,
-                   print_var_state *state, FILE *fp)
+                   print_state *state)
 {
+   FILE *fp = state->fp;
    fprintf(fp, ".%s", glsl_get_struct_elem_name(parent_type, deref->index));
 }
 
 static void
-print_deref(nir_deref_var *deref, print_var_state *state, FILE *fp)
+print_deref(nir_deref_var *deref, print_state *state)
 {
    nir_deref *tail = &deref->deref;
    nir_deref *pretail = NULL;
@@ -298,18 +365,18 @@ print_deref(nir_deref_var *deref, print_var_state *state, FILE *fp)
       case nir_deref_type_var:
          assert(pretail == NULL);
          assert(tail == &deref->deref);
-         print_deref_var(deref, state, fp);
+         print_deref_var(deref, state);
          break;
 
       case nir_deref_type_array:
          assert(pretail != NULL);
-         print_deref_array(nir_deref_as_array(tail), state, fp);
+         print_deref_array(nir_deref_as_array(tail), state);
          break;
 
       case nir_deref_type_struct:
          assert(pretail != NULL);
          print_deref_struct(nir_deref_as_struct(tail),
-                            pretail->type, state, fp);
+                            pretail->type, state);
          break;
 
       default:
@@ -322,13 +389,13 @@ print_deref(nir_deref_var *deref, print_var_state *state, FILE *fp)
 }
 
 static void
-print_intrinsic_instr(nir_intrinsic_instr *instr, print_var_state *state,
-                      FILE *fp)
+print_intrinsic_instr(nir_intrinsic_instr *instr, print_state *state)
 {
    unsigned num_srcs = nir_intrinsic_infos[instr->intrinsic].num_srcs;
+   FILE *fp = state->fp;
 
    if (nir_intrinsic_infos[instr->intrinsic].has_dest) {
-      print_dest(&instr->dest, fp);
+      print_dest(&instr->dest, state);
       fprintf(fp, " = ");
    }
 
@@ -338,7 +405,7 @@ print_intrinsic_instr(nir_intrinsic_instr *instr, print_var_state *state,
       if (i != 0)
          fprintf(fp, ", ");
 
-      print_src(&instr->src[i], fp);
+      print_src(&instr->src[i], state);
    }
 
    fprintf(fp, ") (");
@@ -349,7 +416,7 @@ print_intrinsic_instr(nir_intrinsic_instr *instr, print_var_state *state,
       if (i != 0)
          fprintf(fp, ", ");
 
-      print_deref(instr->variables[i], state, fp);
+      print_deref(instr->variables[i], state);
    }
 
    fprintf(fp, ") (");
@@ -364,12 +431,46 @@ print_intrinsic_instr(nir_intrinsic_instr *instr, print_var_state *state,
    }
 
    fprintf(fp, ")");
+
+   if (!state->shader)
+      return;
+
+   struct exec_list *var_list = NULL;
+
+   switch (instr->intrinsic) {
+   case nir_intrinsic_load_uniform:
+   case nir_intrinsic_load_uniform_indirect:
+      var_list = &state->shader->uniforms;
+      break;
+   case nir_intrinsic_load_input:
+   case nir_intrinsic_load_input_indirect:
+   case nir_intrinsic_load_per_vertex_input:
+   case nir_intrinsic_load_per_vertex_input_indirect:
+      var_list = &state->shader->inputs;
+      break;
+   case nir_intrinsic_store_output:
+   case nir_intrinsic_store_output_indirect:
+      var_list = &state->shader->outputs;
+      break;
+   default:
+      return;
+   }
+
+   nir_foreach_variable(var, var_list) {
+      if ((var->data.driver_location == instr->const_index[0]) &&
+          var->name) {
+         fprintf(fp, "\t/* %s */", var->name);
+         break;
+      }
+   }
 }
 
 static void
-print_tex_instr(nir_tex_instr *instr, print_var_state *state, FILE *fp)
+print_tex_instr(nir_tex_instr *instr, print_state *state)
 {
-   print_dest(&instr->dest, fp);
+   FILE *fp = state->fp;
+
+   print_dest(&instr->dest, state);
 
    fprintf(fp, " = ");
 
@@ -404,6 +505,9 @@ print_tex_instr(nir_tex_instr *instr, print_var_state *state, FILE *fp)
    case nir_texop_query_levels:
       fprintf(fp, "query_levels ");
       break;
+   case nir_texop_texture_samples:
+      fprintf(fp, "texture_samples ");
+      break;
 
    default:
       unreachable("Invalid texture operation");
@@ -411,7 +515,7 @@ print_tex_instr(nir_tex_instr *instr, print_var_state *state, FILE *fp)
    }
 
    for (unsigned i = 0; i < instr->num_srcs; i++) {
-      print_src(&instr->src[i].src, fp);
+      print_src(&instr->src[i].src, state);
 
       fprintf(fp, " ");
 
@@ -474,7 +578,7 @@ print_tex_instr(nir_tex_instr *instr, print_var_state *state, FILE *fp)
    }
 
    if (instr->sampler) {
-      print_deref(instr->sampler, state, fp);
+      print_deref(instr->sampler, state);
    } else {
       fprintf(fp, "%u", instr->sampler_index);
    }
@@ -483,29 +587,33 @@ print_tex_instr(nir_tex_instr *instr, print_var_state *state, FILE *fp)
 }
 
 static void
-print_call_instr(nir_call_instr *instr, print_var_state *state, FILE *fp)
+print_call_instr(nir_call_instr *instr, print_state *state)
 {
+   FILE *fp = state->fp;
+
    fprintf(fp, "call %s ", instr->callee->function->name);
 
    for (unsigned i = 0; i < instr->num_params; i++) {
       if (i != 0)
          fprintf(fp, ", ");
 
-      print_deref(instr->params[i], state, fp);
+      print_deref(instr->params[i], state);
    }
 
    if (instr->return_deref != NULL) {
       if (instr->num_params != 0)
          fprintf(fp, ", ");
       fprintf(fp, "returning ");
-      print_deref(instr->return_deref, state, fp);
+      print_deref(instr->return_deref, state);
    }
 }
 
 static void
-print_load_const_instr(nir_load_const_instr *instr, unsigned tabs, FILE *fp)
+print_load_const_instr(nir_load_const_instr *instr, print_state *state)
 {
-   print_ssa_def(&instr->def, fp);
+   FILE *fp = state->fp;
+
+   print_ssa_def(&instr->def, state);
 
    fprintf(fp, " = load_const (");
 
@@ -521,11 +629,15 @@ print_load_const_instr(nir_load_const_instr *instr, unsigned tabs, FILE *fp)
 
       fprintf(fp, "0x%08x /* %f */", instr->value.u[i], instr->value.f[i]);
    }
+
+   fprintf(fp, ")");
 }
 
 static void
-print_jump_instr(nir_jump_instr *instr, FILE *fp)
+print_jump_instr(nir_jump_instr *instr, print_state *state)
 {
+   FILE *fp = state->fp;
+
    switch (instr->type) {
    case nir_jump_break:
       fprintf(fp, "break");
@@ -542,79 +654,83 @@ print_jump_instr(nir_jump_instr *instr, FILE *fp)
 }
 
 static void
-print_ssa_undef_instr(nir_ssa_undef_instr* instr, FILE *fp)
+print_ssa_undef_instr(nir_ssa_undef_instr* instr, print_state *state)
 {
-   print_ssa_def(&instr->def, fp);
+   FILE *fp = state->fp;
+   print_ssa_def(&instr->def, state);
    fprintf(fp, " = undefined");
 }
 
 static void
-print_phi_instr(nir_phi_instr *instr, FILE *fp)
+print_phi_instr(nir_phi_instr *instr, print_state *state)
 {
-   print_dest(&instr->dest, fp);
+   FILE *fp = state->fp;
+   print_dest(&instr->dest, state);
    fprintf(fp, " = phi ");
    nir_foreach_phi_src(instr, src) {
       if (&src->node != exec_list_get_head(&instr->srcs))
          fprintf(fp, ", ");
 
       fprintf(fp, "block_%u: ", src->pred->index);
-      print_src(&src->src, fp);
+      print_src(&src->src, state);
    }
 }
 
 static void
-print_parallel_copy_instr(nir_parallel_copy_instr *instr, FILE *fp)
+print_parallel_copy_instr(nir_parallel_copy_instr *instr, print_state *state)
 {
+   FILE *fp = state->fp;
    nir_foreach_parallel_copy_entry(instr, entry) {
       if (&entry->node != exec_list_get_head(&instr->entries))
          fprintf(fp, "; ");
 
-      print_dest(&entry->dest, fp);
+      print_dest(&entry->dest, state);
       fprintf(fp, " = ");
-      print_src(&entry->src, fp);
+      print_src(&entry->src, state);
    }
 }
 
 static void
-print_instr(const nir_instr *instr, print_var_state *state, unsigned tabs, FILE *fp)
+print_instr(const nir_instr *instr, print_state *state, unsigned tabs)
 {
+   FILE *fp = state->fp;
    print_tabs(tabs, fp);
 
    switch (instr->type) {
    case nir_instr_type_alu:
-      print_alu_instr(nir_instr_as_alu(instr), fp);
+      print_alu_instr(nir_instr_as_alu(instr), state);
       break;
 
    case nir_instr_type_call:
-      print_call_instr(nir_instr_as_call(instr), state, fp);
+      print_call_instr(nir_instr_as_call(instr), state);
       break;
 
    case nir_instr_type_intrinsic:
-      print_intrinsic_instr(nir_instr_as_intrinsic(instr), state, fp);
+      print_intrinsic_instr(nir_instr_as_intrinsic(instr), state);
       break;
 
    case nir_instr_type_tex:
-      print_tex_instr(nir_instr_as_tex(instr), state, fp);
+      print_tex_instr(nir_instr_as_tex(instr), state);
       break;
 
    case nir_instr_type_load_const:
-      print_load_const_instr(nir_instr_as_load_const(instr), tabs, fp);
+      print_load_const_instr(nir_instr_as_load_const(instr), state);
       break;
 
    case nir_instr_type_jump:
-      print_jump_instr(nir_instr_as_jump(instr), fp);
+      print_jump_instr(nir_instr_as_jump(instr), state);
       break;
 
    case nir_instr_type_ssa_undef:
-      print_ssa_undef_instr(nir_instr_as_ssa_undef(instr), fp);
+      print_ssa_undef_instr(nir_instr_as_ssa_undef(instr), state);
       break;
 
    case nir_instr_type_phi:
-      print_phi_instr(nir_instr_as_phi(instr), fp);
+      print_phi_instr(nir_instr_as_phi(instr), state);
       break;
 
    case nir_instr_type_parallel_copy:
-      print_parallel_copy_instr(nir_instr_as_parallel_copy(instr), fp);
+      print_parallel_copy_instr(nir_instr_as_parallel_copy(instr), state);
       break;
 
    default:
@@ -632,12 +748,14 @@ compare_block_index(const void *p1, const void *p2)
    return (int) block1->index - (int) block2->index;
 }
 
-static void print_cf_node(nir_cf_node *node, print_var_state *state,
-                          unsigned tabs, FILE *fp);
+static void print_cf_node(nir_cf_node *node, print_state *state,
+                          unsigned tabs);
 
 static void
-print_block(nir_block *block, print_var_state *state, unsigned tabs, FILE *fp)
+print_block(nir_block *block, print_state *state, unsigned tabs)
 {
+   FILE *fp = state->fp;
+
    print_tabs(tabs, fp);
    fprintf(fp, "block block_%u:\n", block->index);
 
@@ -665,7 +783,7 @@ print_block(nir_block *block, print_var_state *state, unsigned tabs, FILE *fp)
    free(preds);
 
    nir_foreach_instr(block, instr) {
-      print_instr(instr, state, tabs, fp);
+      print_instr(instr, state, tabs);
       fprintf(fp, "\n");
    }
 
@@ -679,51 +797,54 @@ print_block(nir_block *block, print_var_state *state, unsigned tabs, FILE *fp)
 }
 
 static void
-print_if(nir_if *if_stmt, print_var_state *state, unsigned tabs, FILE *fp)
+print_if(nir_if *if_stmt, print_state *state, unsigned tabs)
 {
+   FILE *fp = state->fp;
+
    print_tabs(tabs, fp);
    fprintf(fp, "if ");
-   print_src(&if_stmt->condition, fp);
+   print_src(&if_stmt->condition, state);
    fprintf(fp, " {\n");
    foreach_list_typed(nir_cf_node, node, node, &if_stmt->then_list) {
-      print_cf_node(node, state, tabs + 1, fp);
+      print_cf_node(node, state, tabs + 1);
    }
    print_tabs(tabs, fp);
    fprintf(fp, "} else {\n");
    foreach_list_typed(nir_cf_node, node, node, &if_stmt->else_list) {
-      print_cf_node(node, state, tabs + 1, fp);
+      print_cf_node(node, state, tabs + 1);
    }
    print_tabs(tabs, fp);
    fprintf(fp, "}\n");
 }
 
 static void
-print_loop(nir_loop *loop, print_var_state *state, unsigned tabs, FILE *fp)
+print_loop(nir_loop *loop, print_state *state, unsigned tabs)
 {
+   FILE *fp = state->fp;
+
    print_tabs(tabs, fp);
    fprintf(fp, "loop {\n");
    foreach_list_typed(nir_cf_node, node, node, &loop->body) {
-      print_cf_node(node, state, tabs + 1, fp);
+      print_cf_node(node, state, tabs + 1);
    }
    print_tabs(tabs, fp);
    fprintf(fp, "}\n");
 }
 
 static void
-print_cf_node(nir_cf_node *node, print_var_state *state, unsigned int tabs,
-              FILE *fp)
+print_cf_node(nir_cf_node *node, print_state *state, unsigned int tabs)
 {
    switch (node->type) {
    case nir_cf_node_block:
-      print_block(nir_cf_node_as_block(node), state, tabs, fp);
+      print_block(nir_cf_node_as_block(node), state, tabs);
       break;
 
    case nir_cf_node_if:
-      print_if(nir_cf_node_as_if(node), state, tabs, fp);
+      print_if(nir_cf_node_as_if(node), state, tabs);
       break;
 
    case nir_cf_node_loop:
-      print_loop(nir_cf_node_as_loop(node), state, tabs, fp);
+      print_loop(nir_cf_node_as_loop(node), state, tabs);
       break;
 
    default:
@@ -732,40 +853,42 @@ print_cf_node(nir_cf_node *node, print_var_state *state, unsigned int tabs,
 }
 
 static void
-print_function_impl(nir_function_impl *impl, print_var_state *state, FILE *fp)
+print_function_impl(nir_function_impl *impl, print_state *state)
 {
+   FILE *fp = state->fp;
+
    fprintf(fp, "\nimpl %s ", impl->overload->function->name);
 
    for (unsigned i = 0; i < impl->num_params; i++) {
       if (i != 0)
          fprintf(fp, ", ");
 
-      print_var(impl->params[i], state, fp);
+      print_var(impl->params[i], state);
    }
 
    if (impl->return_var != NULL) {
       if (impl->num_params != 0)
          fprintf(fp, ", ");
       fprintf(fp, "returning ");
-      print_var(impl->return_var, state, fp);
+      print_var(impl->return_var, state);
    }
 
    fprintf(fp, "{\n");
 
-   foreach_list_typed(nir_variable, var, node, &impl->locals) {
+   nir_foreach_variable(var, &impl->locals) {
       fprintf(fp, "\t");
-      print_var_decl(var, state, fp);
+      print_var_decl(var, state);
    }
 
    foreach_list_typed(nir_register, reg, node, &impl->registers) {
       fprintf(fp, "\t");
-      print_register_decl(reg, fp);
+      print_register_decl(reg, state);
    }
 
    nir_index_blocks(impl);
 
    foreach_list_typed(nir_cf_node, node, node, &impl->body) {
-      print_cf_node(node, state, 1, fp);
+      print_cf_node(node, state, 1);
    }
 
    fprintf(fp, "\tblock block_%u:\n}\n\n", impl->end_block->index);
@@ -773,8 +896,10 @@ print_function_impl(nir_function_impl *impl, print_var_state *state, FILE *fp)
 
 static void
 print_function_overload(nir_function_overload *overload,
-                        print_var_state *state, FILE *fp)
+                        print_state *state)
 {
+   FILE *fp = state->fp;
+
    fprintf(fp, "decl_overload %s ", overload->function->name);
 
    for (unsigned i = 0; i < overload->num_params; i++) {
@@ -808,22 +933,24 @@ print_function_overload(nir_function_overload *overload,
    fprintf(fp, "\n");
 
    if (overload->impl != NULL) {
-      print_function_impl(overload->impl, state, fp);
+      print_function_impl(overload->impl, state);
       return;
    }
 }
 
 static void
-print_function(nir_function *func, print_var_state *state, FILE *fp)
+print_function(nir_function *func, print_state *state)
 {
    foreach_list_typed(nir_function_overload, overload, node, &func->overload_list) {
-      print_function_overload(overload, state, fp);
+      print_function_overload(overload, state);
    }
 }
 
 static void
-init_print_state(print_var_state *state)
+init_print_state(print_state *state, nir_shader *shader, FILE *fp)
 {
+   state->fp = fp;
+   state->shader = shader;
    state->ht = _mesa_hash_table_create(NULL, _mesa_hash_pointer,
                                        _mesa_key_pointer_equal);
    state->syms = _mesa_set_create(NULL, _mesa_key_hash_string,
@@ -832,7 +959,7 @@ init_print_state(print_var_state *state)
 }
 
 static void
-destroy_print_state(print_var_state *state)
+destroy_print_state(print_state *state)
 {
    _mesa_hash_table_destroy(state->ht, NULL);
    _mesa_set_destroy(state->syms, NULL);
@@ -841,37 +968,37 @@ destroy_print_state(print_var_state *state)
 void
 nir_print_shader(nir_shader *shader, FILE *fp)
 {
-   print_var_state state;
-   init_print_state(&state);
+   print_state state;
+   init_print_state(&state, shader, fp);
 
-   struct hash_entry *entry;
+   fprintf(fp, "shader: %s\n", gl_shader_stage_name(shader->stage));
 
-   hash_table_foreach(shader->uniforms, entry) {
-      print_var_decl((nir_variable *) entry->data, &state, fp);
+   nir_foreach_variable(var, &shader->uniforms) {
+      print_var_decl(var, &state);
    }
 
-   hash_table_foreach(shader->inputs, entry) {
-      print_var_decl((nir_variable *) entry->data, &state, fp);
+   nir_foreach_variable(var, &shader->inputs) {
+      print_var_decl(var, &state);
    }
 
-   hash_table_foreach(shader->outputs, entry) {
-      print_var_decl((nir_variable *) entry->data, &state, fp);
+   nir_foreach_variable(var, &shader->outputs) {
+      print_var_decl(var, &state);
    }
 
-   foreach_list_typed(nir_variable, var, node, &shader->globals) {
-      print_var_decl(var, &state, fp);
+   nir_foreach_variable(var, &shader->globals) {
+      print_var_decl(var, &state);
    }
 
-   foreach_list_typed(nir_variable, var, node, &shader->system_values) {
-      print_var_decl(var, &state, fp);
+   nir_foreach_variable(var, &shader->system_values) {
+      print_var_decl(var, &state);
    }
 
    foreach_list_typed(nir_register, reg, node, &shader->registers) {
-      print_register_decl(reg, fp);
+      print_register_decl(reg, &state);
    }
 
    foreach_list_typed(nir_function, func, node, &shader->functions) {
-      print_function(func, &state, fp);
+      print_function(func, &state);
    }
 
    destroy_print_state(&state);
@@ -880,5 +1007,9 @@ nir_print_shader(nir_shader *shader, FILE *fp)
 void
 nir_print_instr(const nir_instr *instr, FILE *fp)
 {
-   print_instr(instr, NULL, 0, fp);
+   print_state state = {
+      .fp = fp,
+   };
+   print_instr(instr, &state, 0);
+
 }