i965/nir: fixup for new foreach_block()

Reviewed-by: Jason Ekstrand <jason@jlekstrand.net>

1 files changed, 39 insertions, 51 deletions

diff --git a/src/mesa/drivers/dri/i965/brw_nir.c b/src/mesa/drivers/dri/i965/brw_nir.c
index f9bcba2..3dd5f07 100644
--- a/src/mesa/drivers/dri/i965/brw_nir.c
+++ b/src/mesa/drivers/dri/i965/brw_nir.c
@@ -54,25 +54,19 @@ is_output(nir_intrinsic_instr *intrin)
  * we don't know what part of a compound variable is accessed, we allocate
  * storage for the entire thing.
  */
-struct add_const_offset_to_base_params {
-   nir_builder b;
-   nir_variable_mode mode;
-};
 
 static bool
-add_const_offset_to_base_block(nir_block *block, void *closure)
+add_const_offset_to_base_block(nir_block *block, nir_builder *b,
+                               nir_variable_mode mode)
 {
-   struct add_const_offset_to_base_params *params = closure;
-   nir_builder *b = &params->b;
-
    nir_foreach_instr_safe(block, instr) {
       if (instr->type != nir_instr_type_intrinsic)
          continue;
 
       nir_intrinsic_instr *intrin = nir_instr_as_intrinsic(instr);
 
-      if ((params->mode == nir_var_shader_in && is_input(intrin)) ||
-          (params->mode == nir_var_shader_out && is_output(intrin))) {
+      if ((mode == nir_var_shader_in && is_input(intrin)) ||
+          (mode == nir_var_shader_out && is_output(intrin))) {
          nir_src *offset = nir_get_io_offset_src(intrin);
          nir_const_value *const_offset = nir_src_as_const_value(*offset);
 
@@ -90,21 +84,20 @@ add_const_offset_to_base_block(nir_block *block, void *closure)
 static void
 add_const_offset_to_base(nir_shader *nir, nir_variable_mode mode)
 {
-   struct add_const_offset_to_base_params params = { .mode = mode };
-
    nir_foreach_function(nir, f) {
       if (f->impl) {
-         nir_builder_init(&params.b, f->impl);
-         nir_foreach_block_call(f->impl, add_const_offset_to_base_block, &params);
+         nir_builder b;
+         nir_builder_init(&b, f->impl);
+         nir_foreach_block(block, f->impl) {
+            add_const_offset_to_base_block(block, &b, mode);
+         }
       }
    }
 }
 
 static bool
-remap_vs_attrs(nir_block *block, void *closure)
+remap_vs_attrs(nir_block *block, GLbitfield64 inputs_read)
 {
-   GLbitfield64 inputs_read = *((GLbitfield64 *) closure);
-
    nir_foreach_instr(block, instr) {
       if (instr->type != nir_instr_type_intrinsic)
          continue;
@@ -127,10 +120,8 @@ remap_vs_attrs(nir_block *block, void *closure)
 }
 
 static bool
-remap_inputs_with_vue_map(nir_block *block, void *closure)
+remap_inputs_with_vue_map(nir_block *block, const struct brw_vue_map *vue_map)
 {
-   const struct brw_vue_map *vue_map = closure;
-
    nir_foreach_instr(block, instr) {
       if (instr->type != nir_instr_type_intrinsic)
          continue;
@@ -147,27 +138,21 @@ remap_inputs_with_vue_map(nir_block *block, void *closure)
    return true;
 }
 
-struct remap_patch_urb_offsets_state {
-   nir_builder b;
-   const struct brw_vue_map *vue_map;
-};
-
 static bool
-remap_patch_urb_offsets(nir_block *block, void *closure)
+remap_patch_urb_offsets(nir_block *block, nir_builder *b,
+                        const struct brw_vue_map *vue_map)
 {
-   struct remap_patch_urb_offsets_state *state = closure;
-
    nir_foreach_instr_safe(block, instr) {
       if (instr->type != nir_instr_type_intrinsic)
          continue;
 
       nir_intrinsic_instr *intrin = nir_instr_as_intrinsic(instr);
 
-      gl_shader_stage stage = state->b.shader->stage;
+      gl_shader_stage stage = b->shader->stage;
 
       if ((stage == MESA_SHADER_TESS_CTRL && is_output(intrin)) ||
           (stage == MESA_SHADER_TESS_EVAL && is_input(intrin))) {
-         int vue_slot = state->vue_map->varying_to_slot[intrin->const_index[0]];
+         int vue_slot = vue_map->varying_to_slot[intrin->const_index[0]];
          assert(vue_slot != -1);
          intrin->const_index[0] = vue_slot;
 
@@ -176,22 +161,22 @@ remap_patch_urb_offsets(nir_block *block, void *closure)
             nir_const_value *const_vertex = nir_src_as_const_value(*vertex);
             if (const_vertex) {
                intrin->const_index[0] += const_vertex->u32[0] *
-                                         state->vue_map->num_per_vertex_slots;
+                                         vue_map->num_per_vertex_slots;
             } else {
-               state->b.cursor = nir_before_instr(&intrin->instr);
+               b->cursor = nir_before_instr(&intrin->instr);
 
                /* Multiply by the number of per-vertex slots. */
                nir_ssa_def *vertex_offset =
-                  nir_imul(&state->b,
-                           nir_ssa_for_src(&state->b, *vertex, 1),
-                           nir_imm_int(&state->b,
-                                       state->vue_map->num_per_vertex_slots));
+                  nir_imul(b,
+                           nir_ssa_for_src(b, *vertex, 1),
+                           nir_imm_int(b,
+                                       vue_map->num_per_vertex_slots));
 
                /* Add it to the existing offset */
                nir_src *offset = nir_get_io_offset_src(intrin);
                nir_ssa_def *total_offset =
-                  nir_iadd(&state->b, vertex_offset,
-                           nir_ssa_for_src(&state->b, *offset, 1));
+                  nir_iadd(b, vertex_offset,
+                           nir_ssa_for_src(b, *offset, 1));
 
                nir_instr_rewrite_src(&intrin->instr, offset,
                                      nir_src_for_ssa(total_offset));
@@ -239,7 +224,9 @@ brw_nir_lower_vs_inputs(nir_shader *nir,
 
       nir_foreach_function(nir, function) {
          if (function->impl) {
-            nir_foreach_block_call(function->impl, remap_vs_attrs, &inputs_read);
+            nir_foreach_block(block, function->impl) {
+               remap_vs_attrs(block, inputs_read);
+            }
          }
       }
    }
@@ -264,8 +251,9 @@ brw_nir_lower_vue_inputs(nir_shader *nir, bool is_scalar,
 
       nir_foreach_function(nir, function) {
          if (function->impl) {
-            nir_foreach_block_call(function->impl, remap_inputs_with_vue_map,
-                              (void *) vue_map);
+            nir_foreach_block(block, function->impl) {
+               remap_inputs_with_vue_map(block, vue_map);
+            }
          }
       }
    }
@@ -274,9 +262,6 @@ brw_nir_lower_vue_inputs(nir_shader *nir, bool is_scalar,
 void
 brw_nir_lower_tes_inputs(nir_shader *nir, const struct brw_vue_map *vue_map)
 {
-   struct remap_patch_urb_offsets_state state;
-   state.vue_map = vue_map;
-
    foreach_list_typed(nir_variable, var, node, &nir->inputs) {
       var->data.driver_location = var->data.location;
    }
@@ -290,8 +275,11 @@ brw_nir_lower_tes_inputs(nir_shader *nir, const struct brw_vue_map *vue_map)
 
    nir_foreach_function(nir, function) {
       if (function->impl) {
-         nir_builder_init(&state.b, function->impl);
-         nir_foreach_block_call(function->impl, remap_patch_urb_offsets, &state);
+         nir_builder b;
+         nir_builder_init(&b, function->impl);
+         nir_foreach_block(block, function->impl) {
+            remap_patch_urb_offsets(block, &b, vue_map);
+         }
       }
    }
 }
@@ -321,9 +309,6 @@ brw_nir_lower_vue_outputs(nir_shader *nir,
 void
 brw_nir_lower_tcs_outputs(nir_shader *nir, const struct brw_vue_map *vue_map)
 {
-   struct remap_patch_urb_offsets_state state;
-   state.vue_map = vue_map;
-
    nir_foreach_variable(var, &nir->outputs) {
       var->data.driver_location = var->data.location;
    }
@@ -337,8 +322,11 @@ brw_nir_lower_tcs_outputs(nir_shader *nir, const struct brw_vue_map *vue_map)
 
    nir_foreach_function(nir, function) {
       if (function->impl) {
-         nir_builder_init(&state.b, function->impl);
-         nir_foreach_block_call(function->impl, remap_patch_urb_offsets, &state);
+         nir_builder b;
+         nir_builder_init(&b, function->impl);
+         nir_foreach_block(block, function->impl) {
+            remap_patch_urb_offsets(block, &b, vue_map);
+         }
       }
    }
 }