treewide: Also handle struct nir_builder form

Via Coccinelle patch:

    @def@
    typedef bool;
    typedef nir_builder;
    typedef nir_instr;
    typedef nir_def;
    identifier fn, instr, intr, x, builder, data;
    @@

    static fn(struct nir_builder* builder,
    -nir_instr *instr,
    +nir_intrinsic_instr *intr,
    ...)
    {
    (
    -   if (instr->type != nir_instr_type_intrinsic)
    -      return false;
    -   nir_intrinsic_instr *intr = nir_instr_as_intrinsic(instr);
    |
    -   nir_intrinsic_instr *intr = nir_instr_as_intrinsic(instr);
    -   if (instr->type != nir_instr_type_intrinsic)
    -      return false;
    )

    <...
    (
    -instr->x
    +intr->instr.x
    |
    -instr
    +&intr->instr
    )
    ...>

    }

    @pass depends on def@
    identifier def.fn;
    expression shader, progress;
    @@

    (
    -nir_shader_instructions_pass(shader, fn,
    +nir_shader_intrinsics_pass(shader, fn,
    ...)
    |
    -NIR_PASS_V(shader, nir_shader_instructions_pass, fn,
    +NIR_PASS_V(shader, nir_shader_intrinsics_pass, fn,
    ...)
    |
    -NIR_PASS(progress, shader, nir_shader_instructions_pass, fn,
    +NIR_PASS(progress, shader, nir_shader_intrinsics_pass, fn,
    ...)
    )

Signed-off-by: Alyssa Rosenzweig <alyssa@rosenzweig.io>
Acked-by: Faith Ekstrand <faith.ekstrand@collabora.com>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/24852>

src/asahi/compiler/agx_compile.c

@@ -2135,12 +2135,9 @@ agx_lower_sincos(nir_shader *shader)
 }
 
 static bool
-agx_lower_front_face(struct nir_builder *b, nir_instr *instr, UNUSED void *data)
+agx_lower_front_face(struct nir_builder *b, nir_intrinsic_instr *intr,
+                     UNUSED void *data)
 {
-   if (instr->type != nir_instr_type_intrinsic)
-      return false;
-
-   nir_intrinsic_instr *intr = nir_instr_as_intrinsic(instr);
    if (intr->intrinsic != nir_intrinsic_load_front_face)
       return false;
 
@@ -2689,7 +2686,7 @@ agx_preprocess_nir(nir_shader *nir, bool support_lod_bias, bool allow_mediump,
    NIR_PASS_V(nir, nir_lower_load_const_to_scalar);
    NIR_PASS_V(nir, nir_lower_flrp, 16 | 32 | 64, false);
    NIR_PASS_V(nir, agx_lower_sincos);
-   NIR_PASS_V(nir, nir_shader_instructions_pass, agx_lower_front_face,
+   NIR_PASS_V(nir, nir_shader_intrinsics_pass, agx_lower_front_face,
               nir_metadata_block_index | nir_metadata_dominance, NULL);
    NIR_PASS_V(nir, nir_lower_frag_coord_to_pixel_coord);
 

src/asahi/compiler/agx_nir_lower_frag_sidefx.c

@@ -32,12 +32,8 @@ insert_z_write(nir_builder *b)
 }
 
 static bool
-pass(struct nir_builder *b, nir_instr *instr, void *data)
+pass(struct nir_builder *b, nir_intrinsic_instr *intr, void *data)
 {
-   if (instr->type != nir_instr_type_intrinsic)
-      return false;
-
-   nir_intrinsic_instr *intr = nir_instr_as_intrinsic(instr);
    if (intr->intrinsic != nir_intrinsic_store_output)
       return false;
 
@@ -47,7 +43,7 @@ pass(struct nir_builder *b, nir_instr *instr, void *data)
       return false;
    *done = true;
 
-   b->cursor = nir_before_instr(instr);
+   b->cursor = nir_before_instr(&intr->instr);
    insert_z_write(b);
    return true;
 }
@@ -87,7 +83,7 @@ agx_nir_lower_frag_sidefx(nir_shader *s)
       return false;
 
    bool done = false;
-   nir_shader_instructions_pass(
+   nir_shader_intrinsics_pass(
       s, pass, nir_metadata_block_index | nir_metadata_dominance, &done);
 
    /* If there's no render targets written, just put the write at the end */

src/asahi/compiler/agx_nir_lower_shared_bitsize.c

@@ -8,12 +8,8 @@
 
 /* Local memory instructions require 16-bit offsets, so we add conversions. */
 static bool
-pass(struct nir_builder *b, nir_instr *instr, UNUSED void *data)
+pass(struct nir_builder *b, nir_intrinsic_instr *intr, UNUSED void *data)
 {
-   if (instr->type != nir_instr_type_intrinsic)
-      return false;
-
-   nir_intrinsic_instr *intr = nir_instr_as_intrinsic(instr);
    switch (intr->intrinsic) {
    case nir_intrinsic_load_shared:
    case nir_intrinsic_store_shared:
@@ -28,7 +24,7 @@ pass(struct nir_builder *b, nir_instr *instr, UNUSED void *data)
    if (nir_src_bit_size(*offset) == 16)
       return false;
 
-   b->cursor = nir_before_instr(instr);
+   b->cursor = nir_before_instr(&intr->instr);
    nir_src_rewrite(offset, nir_u2u16(b, nir_ssa_for_src(b, *offset, 1)));
    return true;
 }
@@ -36,6 +32,6 @@ pass(struct nir_builder *b, nir_instr *instr, UNUSED void *data)
 bool
 agx_nir_lower_shared_bitsize(nir_shader *shader)
 {
-   return nir_shader_instructions_pass(
+   return nir_shader_intrinsics_pass(
       shader, pass, nir_metadata_block_index | nir_metadata_dominance, NULL);
 }

src/compiler/nir/nir_lower_shader_calls.c

@@ -1412,12 +1412,9 @@ nir_lower_stack_to_scratch(nir_shader *shader,
 }
 
 static bool
-opt_remove_respills_instr(struct nir_builder *b, nir_instr *instr, void *data)
+opt_remove_respills_instr(struct nir_builder *b,
+                          nir_intrinsic_instr *store_intrin, void *data)
 {
-   if (instr->type != nir_instr_type_intrinsic)
-      return false;
-
-   nir_intrinsic_instr *store_intrin = nir_instr_as_intrinsic(instr);
    if (store_intrin->intrinsic != nir_intrinsic_store_stack)
       return false;
 
@@ -1443,8 +1440,7 @@ opt_remove_respills_instr(struct nir_builder *b, nir_instr *instr, void *data)
 static bool
 nir_opt_remove_respills(nir_shader *shader)
 {
-   return nir_shader_instructions_pass(shader,
+   return nir_shader_intrinsics_pass(shader, opt_remove_respills_instr,
-                                       opt_remove_respills_instr,
                                        nir_metadata_block_index |
                                           nir_metadata_dominance,
                                        NULL);
@@ -1846,12 +1842,9 @@ nir_opt_stack_loads(nir_shader *shader)
 }
 
 static bool
-split_stack_components_instr(struct nir_builder *b, nir_instr *instr, void *data)
+split_stack_components_instr(struct nir_builder *b,
+                             nir_intrinsic_instr *intrin, void *data)
 {
-   if (instr->type != nir_instr_type_intrinsic)
-      return false;
-
-   nir_intrinsic_instr *intrin = nir_instr_as_intrinsic(instr);
    if (intrin->intrinsic != nir_intrinsic_load_stack &&
        intrin->intrinsic != nir_intrinsic_store_stack)
       return false;
@@ -1864,7 +1857,7 @@ split_stack_components_instr(struct nir_builder *b, nir_instr *instr, void *data
        intrin->src[0].ssa->num_components == 1)
       return false;
 
-   b->cursor = nir_before_instr(instr);
+   b->cursor = nir_before_instr(&intrin->instr);
 
    unsigned align_mul = nir_intrinsic_align_mul(intrin);
    unsigned align_offset = nir_intrinsic_align_offset(intrin);
@@ -1899,7 +1892,7 @@ split_stack_components_instr(struct nir_builder *b, nir_instr *instr, void *data
       }
    }
 
-   nir_instr_remove(instr);
+   nir_instr_remove(&intrin->instr);
 
    return true;
 }
@@ -1910,8 +1903,7 @@ split_stack_components_instr(struct nir_builder *b, nir_instr *instr, void *data
 static bool
 nir_split_stack_components(nir_shader *shader)
 {
-   return nir_shader_instructions_pass(shader,
+   return nir_shader_intrinsics_pass(shader, split_stack_components_instr,
-                                       split_stack_components_instr,
                                        nir_metadata_block_index |
                                           nir_metadata_dominance,
                                        NULL);

src/compiler/nir/nir_opt_ray_queries.c

@@ -190,12 +190,9 @@ struct rq_range {
 #define RQ_NEW_INDEX_NONE 0xFFFFFFFF
 
 static bool
-count_ranges(struct nir_builder *b, nir_instr *instr, void *data)
+count_ranges(struct nir_builder *b, nir_intrinsic_instr *intrinsic,
+             void *data)
 {
-   if (instr->type != nir_instr_type_intrinsic)
-      return false;
-
-   nir_intrinsic_instr *intrinsic = nir_instr_as_intrinsic(instr);
    if (intrinsic->intrinsic == nir_intrinsic_rq_initialize)
       (*(uint32_t *)data)++;
 
@@ -265,7 +262,8 @@ nir_opt_ray_query_ranges(nir_shader *shader)
    }
 
    uint32_t range_count = 0;
-   nir_shader_instructions_pass(shader, count_ranges, nir_metadata_all, &range_count);
+   nir_shader_intrinsics_pass(shader, count_ranges, nir_metadata_all,
+                              &range_count);
 
    struct rq_range *ranges = rzalloc_array(mem_ctx, struct rq_range, range_count);
 

src/gallium/drivers/asahi/agx_streamout.c

@@ -420,13 +420,10 @@ lower_xfb(nir_builder *b, nir_intrinsic_instr *intr, UNUSED void *data)
 }
 
 static bool
-lower_xfb_intrinsics(struct nir_builder *b, nir_instr *instr, void *data)
+lower_xfb_intrinsics(struct nir_builder *b, nir_intrinsic_instr *intr,
+                     void *data)
 {
-   if (instr->type != nir_instr_type_intrinsic)
+   b->cursor = nir_before_instr(&intr->instr);
-      return false;
-
-   nir_intrinsic_instr *intr = nir_instr_as_intrinsic(instr);
-   b->cursor = nir_before_instr(instr);
 
    struct agx_xfb_key *key = data;
 
@@ -550,7 +547,7 @@ agx_nir_lower_xfb(nir_shader *nir, struct agx_xfb_key *key)
    NIR_PASS_V(nir, insert_overflow_check, key);
    NIR_PASS_V(nir, nir_shader_intrinsics_pass, lower_xfb,
               nir_metadata_block_index | nir_metadata_dominance, key);
-   NIR_PASS_V(nir, nir_shader_instructions_pass, lower_xfb_intrinsics,
+   NIR_PASS_V(nir, nir_shader_intrinsics_pass, lower_xfb_intrinsics,
               nir_metadata_block_index | nir_metadata_dominance, key);
 
    /* Lowering XFB creates piles of dead code. Eliminate now so we don't

src/intel/compiler/brw_mesh.cpp

@@ -177,12 +177,9 @@ brw_print_tue_map(FILE *fp, const struct brw_tue_map *map)
 
 static bool
 brw_nir_adjust_task_payload_offsets_instr(struct nir_builder *b,
-                                          nir_instr *instr, void *data)
+                                          nir_intrinsic_instr *intrin,
+                                          void *data)
 {
-   if (instr->type != nir_instr_type_intrinsic)
-      return false;
-
-   nir_intrinsic_instr *intrin = nir_instr_as_intrinsic(instr);
    switch (intrin->intrinsic) {
    case nir_intrinsic_store_task_payload:
    case nir_intrinsic_load_task_payload: {
@@ -217,7 +214,7 @@ brw_nir_adjust_task_payload_offsets_instr(struct nir_builder *b,
 static bool
 brw_nir_adjust_task_payload_offsets(nir_shader *nir)
 {
-   return nir_shader_instructions_pass(nir,
+   return nir_shader_intrinsics_pass(nir,
                                        brw_nir_adjust_task_payload_offsets_instr,
                                        nir_metadata_block_index |
                                        nir_metadata_dominance,

src/intel/compiler/brw_nir.c

@@ -1041,12 +1041,9 @@ brw_preprocess_nir(const struct brw_compiler *compiler, nir_shader *nir,
 }
 
 static bool
-brw_nir_zero_inputs_instr(struct nir_builder *b, nir_instr *instr, void *data)
+brw_nir_zero_inputs_instr(struct nir_builder *b, nir_intrinsic_instr *intrin,
+                          void *data)
 {
-   if (instr->type != nir_instr_type_intrinsic)
-      return false;
-
-   nir_intrinsic_instr *intrin = nir_instr_as_intrinsic(instr);
    if (intrin->intrinsic != nir_intrinsic_load_deref)
       return false;
 
@@ -1063,13 +1060,13 @@ brw_nir_zero_inputs_instr(struct nir_builder *b, nir_instr *instr, void *data)
    if (!(BITFIELD64_BIT(var->data.location) & zero_inputs))
       return false;
 
-   b->cursor = nir_before_instr(instr);
+   b->cursor = nir_before_instr(&intrin->instr);
 
    nir_def *zero = nir_imm_zero(b, 1, 32);
 
    nir_def_rewrite_uses(&intrin->def, zero);
 
-   nir_instr_remove(instr);
+   nir_instr_remove(&intrin->instr);
 
    return true;
 }
@@ -1077,8 +1074,9 @@ brw_nir_zero_inputs_instr(struct nir_builder *b, nir_instr *instr, void *data)
 static bool
 brw_nir_zero_inputs(nir_shader *shader, uint64_t *zero_inputs)
 {
-   return nir_shader_instructions_pass(shader, brw_nir_zero_inputs_instr,
+   return nir_shader_intrinsics_pass(shader, brw_nir_zero_inputs_instr,
-         nir_metadata_block_index | nir_metadata_dominance, zero_inputs);
+                                     nir_metadata_block_index | nir_metadata_dominance,
+                                     zero_inputs);
 }
 
 /* Code for Wa_18019110168 may have created input/output variables beyond

src/intel/compiler/brw_nir_lower_shader_calls.c

@@ -252,19 +252,13 @@ lower_shader_trace_ray_instr(struct nir_builder *b, nir_instr *instr, void *data
 }
 
 static bool
-lower_shader_call_instr(struct nir_builder *b, nir_instr *instr, void *data)
+lower_shader_call_instr(struct nir_builder *b, nir_intrinsic_instr *call,
+                        void *data)
 {
-   if (instr->type != nir_instr_type_intrinsic)
-      return false;
-
-   /* Leave nir_intrinsic_rt_resume to be lowered by
-    * brw_nir_lower_rt_intrinsics()
-    */
-   nir_intrinsic_instr *call = nir_instr_as_intrinsic(instr);
    if (call->intrinsic != nir_intrinsic_rt_execute_callable)
       return false;
 
-   b->cursor = nir_instr_remove(instr);
+   b->cursor = nir_instr_remove(&call->instr);
 
    store_resume_addr(b, call);
 
@@ -285,8 +279,7 @@ brw_nir_lower_shader_calls(nir_shader *shader, struct brw_bs_prog_key *key)
                                          lower_shader_trace_ray_instr,
                                          nir_metadata_none,
                                          key);
-   bool b = nir_shader_instructions_pass(shader,
+   bool b = nir_shader_intrinsics_pass(shader, lower_shader_call_instr,
-                                         lower_shader_call_instr,
                                          nir_metadata_block_index |
                                          nir_metadata_dominance,
                                          NULL);

src/microsoft/compiler/dxil_nir.c

@@ -1567,14 +1567,10 @@ dxil_reassign_driver_locations(nir_shader* s, nir_variable_mode modes,
 }
 
 static bool
-lower_ubo_array_one_to_static(struct nir_builder *b, nir_instr *inst,
+lower_ubo_array_one_to_static(struct nir_builder *b,
+                              nir_intrinsic_instr *intrin,
                               void *cb_data)
 {
-   if (inst->type != nir_instr_type_intrinsic)
-      return false;
-
-   nir_intrinsic_instr *intrin = nir_instr_as_intrinsic(inst);
-
    if (intrin->intrinsic != nir_intrinsic_load_vulkan_descriptor)
       return false;
 
@@ -1617,8 +1613,9 @@ lower_ubo_array_one_to_static(struct nir_builder *b, nir_instr *inst,
 bool
 dxil_nir_lower_ubo_array_one_to_static(nir_shader *s)
 {
-   bool progress = nir_shader_instructions_pass(
+   bool progress = nir_shader_intrinsics_pass(s,
-      s, lower_ubo_array_one_to_static, nir_metadata_none, NULL);
+                                              lower_ubo_array_one_to_static,
+                                              nir_metadata_none, NULL);
 
    return progress;
 }
@@ -1784,20 +1781,16 @@ remove_after_discard(struct nir_builder *builder, nir_instr *instr,
 }
 
 static bool
-lower_kill(struct nir_builder *builder, nir_instr *instr, void *_cb_data)
+lower_kill(struct nir_builder *builder, nir_intrinsic_instr *intr,
+           void *_cb_data)
 {
-   if (instr->type != nir_instr_type_intrinsic)
-      return false;
-
-   nir_intrinsic_instr *intr = nir_instr_as_intrinsic(instr);
-
    if (intr->intrinsic != nir_intrinsic_discard &&
        intr->intrinsic != nir_intrinsic_terminate &&
        intr->intrinsic != nir_intrinsic_discard_if &&
        intr->intrinsic != nir_intrinsic_terminate_if)
       return false;
 
-   builder->cursor = nir_instr_remove(instr);
+   builder->cursor = nir_instr_remove(&intr->instr);
    if (intr->intrinsic == nir_intrinsic_discard ||
        intr->intrinsic == nir_intrinsic_terminate) {
       nir_demote(builder);
@@ -1822,16 +1815,13 @@ dxil_nir_lower_discard_and_terminate(nir_shader *s)
    state.active_block = NULL;
    nir_shader_instructions_pass(s, remove_after_discard, nir_metadata_none,
                                 &state);
-   return nir_shader_instructions_pass(s, lower_kill, nir_metadata_none,
+   return nir_shader_intrinsics_pass(s, lower_kill, nir_metadata_none,
                                        NULL);
 }
 
 static bool
-update_writes(struct nir_builder *b, nir_instr *instr, void *_state)
+update_writes(struct nir_builder *b, nir_intrinsic_instr *intr, void *_state)
 {
-   if (instr->type != nir_instr_type_intrinsic)
-      return false;
-   nir_intrinsic_instr *intr = nir_instr_as_intrinsic(instr);
    if (intr->intrinsic != nir_intrinsic_store_output)
       return false;
 
@@ -1844,7 +1834,7 @@ update_writes(struct nir_builder *b, nir_instr *instr, void *_state)
    if (src->num_components == 4 && write_mask == 0xf)
       return false;
 
-   b->cursor = nir_before_instr(instr);
+   b->cursor = nir_before_instr(&intr->instr);
    unsigned first_comp = nir_intrinsic_component(intr);
    nir_def *channels[4] = { NULL, NULL, NULL, NULL };
    assert(first_comp + src->num_components <= ARRAY_SIZE(channels));
@@ -1872,7 +1862,7 @@ dxil_nir_ensure_position_writes(nir_shader *s)
    if ((s->info.outputs_written & VARYING_BIT_POS) == 0)
       return false;
 
-   return nir_shader_instructions_pass(s, update_writes,
+   return nir_shader_intrinsics_pass(s, update_writes,
                                        nir_metadata_block_index | nir_metadata_dominance,
                                        NULL);
 }

src/microsoft/spirv_to_dxil/dxil_spirv_nir.c

@@ -497,14 +497,9 @@ dxil_spirv_nir_lower_yz_flip(nir_shader *shader,
 }
 
 static bool
-discard_psiz_access(struct nir_builder *builder, nir_instr *instr,
+discard_psiz_access(struct nir_builder *builder, nir_intrinsic_instr *intrin,
                     void *cb_data)
 {
-   if (instr->type != nir_instr_type_intrinsic)
-      return false;
-
-   nir_intrinsic_instr *intrin = nir_instr_as_intrinsic(instr);
-
    if (intrin->intrinsic != nir_intrinsic_store_deref &&
        intrin->intrinsic != nir_intrinsic_load_deref)
       return false;
@@ -514,12 +509,12 @@ discard_psiz_access(struct nir_builder *builder, nir_instr *instr,
        var->data.location != VARYING_SLOT_PSIZ)
       return false;
 
-   builder->cursor = nir_before_instr(instr);
+   builder->cursor = nir_before_instr(&intrin->instr);
 
    if (intrin->intrinsic == nir_intrinsic_load_deref)
       nir_def_rewrite_uses(&intrin->def, nir_imm_float(builder, 1.0));
 
-   nir_instr_remove(instr);
+   nir_instr_remove(&intrin->instr);
    return true;
 }
 
@@ -542,7 +537,7 @@ dxil_spirv_nir_discard_point_size_var(nir_shader *shader)
    if (!psiz)
       return false;
 
-   if (!nir_shader_instructions_pass(shader, discard_psiz_access,
+   if (!nir_shader_intrinsics_pass(shader, discard_psiz_access,
                                      nir_metadata_block_index |
                                      nir_metadata_dominance |
                                      nir_metadata_loop_analysis,

src/microsoft/vulkan/dzn_pipeline.c

@@ -275,14 +275,10 @@ dzn_pipeline_get_nir_shader(struct dzn_device *device,
 }
 
 static bool
-adjust_resource_index_binding(struct nir_builder *builder, nir_instr *instr,
+adjust_resource_index_binding(struct nir_builder *builder,
+                              nir_intrinsic_instr *intrin,
                               void *cb_data)
 {
-   if (instr->type != nir_instr_type_intrinsic)
-      return false;
-
-   nir_intrinsic_instr *intrin = nir_instr_as_intrinsic(instr);
-
    if (intrin->intrinsic != nir_intrinsic_vulkan_resource_index)
       return false;
 
@@ -379,7 +375,7 @@ adjust_var_bindings(nir_shader *shader,
       }
       return ret;
    } else {
-      return nir_shader_instructions_pass(shader, adjust_resource_index_binding,
+      return nir_shader_intrinsics_pass(shader, adjust_resource_index_binding,
                                           nir_metadata_all, (void *)layout);
    }
 }

src/panfrost/compiler/bifrost_compile.c

@@ -4268,14 +4268,9 @@ bifrost_nir_valid_channel(nir_builder *b, nir_def *in, unsigned channel,
  * compiler. The DDK inserts these moves, so we will as well. */
 
 static bool
-bifrost_nir_lower_blend_components(struct nir_builder *b, nir_instr *instr,
+bifrost_nir_lower_blend_components(struct nir_builder *b,
-                                   void *data)
+                                   nir_intrinsic_instr *intr, void *data)
 {
-   if (instr->type != nir_instr_type_intrinsic)
-      return false;
-
-   nir_intrinsic_instr *intr = nir_instr_as_intrinsic(instr);
-
    if (intr->intrinsic != nir_intrinsic_store_output)
       return false;
 
@@ -4406,7 +4401,7 @@ bi_optimize_nir(nir_shader *nir, unsigned gpu_id, bool is_blend)
    NIR_PASS(progress, nir, nir_opt_dce);
 
    if (nir->info.stage == MESA_SHADER_FRAGMENT) {
-      NIR_PASS_V(nir, nir_shader_instructions_pass,
+      NIR_PASS_V(nir, nir_shader_intrinsics_pass,
                  bifrost_nir_lower_blend_components,
                  nir_metadata_block_index | nir_metadata_dominance, NULL);
    }

src/panfrost/util/pan_lower_sample_position.c

@@ -33,17 +33,13 @@
  * it's a pretty trivial difference */
 
 static bool
-pan_lower_sample_pos_impl(struct nir_builder *b, nir_instr *instr,
+pan_lower_sample_pos_impl(struct nir_builder *b, nir_intrinsic_instr *intr,
                           UNUSED void *data)
 {
-   if (instr->type != nir_instr_type_intrinsic)
-      return false;
-
-   nir_intrinsic_instr *intr = nir_instr_as_intrinsic(instr);
    if (intr->intrinsic != nir_intrinsic_load_sample_pos)
       return false;
 
-   b->cursor = nir_before_instr(instr);
+   b->cursor = nir_before_instr(&intr->instr);
 
    /* Elements are 4 bytes */
    nir_def *addr =
@@ -68,7 +64,7 @@ pan_lower_sample_pos(nir_shader *shader)
    if (shader->info.stage != MESA_SHADER_FRAGMENT)
       return false;
 
-   return nir_shader_instructions_pass(
+   return nir_shader_intrinsics_pass(
       shader, pan_lower_sample_pos_impl,
       nir_metadata_block_index | nir_metadata_dominance, NULL);
 }