diff --git a/src/amd/common/nir/ac_nir.c b/src/amd/common/nir/ac_nir.c
index 51c3e2af69b..4b26fb76101 100644
--- a/src/amd/common/nir/ac_nir.c
+++ b/src/amd/common/nir/ac_nir.c
@@ -652,10 +652,8 @@ ac_nir_mem_vectorize_callback(unsigned align_mul, unsigned align_offset, unsigne
    return false;
 }
 
-bool ac_nir_scalarize_overfetching_loads_callback(const nir_instr *instr, const void *data)
+bool ac_nir_scalarize_overfetching_loads_callback(const nir_intrinsic_instr *intr, const void *data)
 {
-   nir_intrinsic_instr *intr = nir_instr_as_intrinsic(instr);
-
    /* Reject opcodes we don't scalarize. */
    switch (intr->intrinsic) {
    case nir_intrinsic_load_ubo:
diff --git a/src/amd/common/nir/ac_nir.h b/src/amd/common/nir/ac_nir.h
index 6f6dd3105ff..2ab3e10a1f5 100644
--- a/src/amd/common/nir/ac_nir.h
+++ b/src/amd/common/nir/ac_nir.h
@@ -433,7 +433,7 @@ ac_nir_mem_vectorize_callback(unsigned align_mul, unsigned align_offset, unsigne
                               nir_intrinsic_instr *low, nir_intrinsic_instr *high, void *data);
 
 bool
-ac_nir_scalarize_overfetching_loads_callback(const nir_instr *instr, const void *data);
+ac_nir_scalarize_overfetching_loads_callback(const nir_intrinsic_instr *intr, const void *data);
 
 bool
 ac_nir_store_may_be_subdword(const nir_intrinsic_instr *instr);
diff --git a/src/compiler/nir/nir.h b/src/compiler/nir/nir.h
index b12223909e6..e3337a9eaa5 100644
--- a/src/compiler/nir/nir.h
+++ b/src/compiler/nir/nir.h
@@ -5596,7 +5596,7 @@ bool nir_lower_all_phis_to_scalar(nir_shader *shader);
 void nir_lower_io_array_vars_to_elements(nir_shader *producer, nir_shader *consumer);
 bool nir_lower_io_array_vars_to_elements_no_indirects(nir_shader *shader,
                                                       bool outputs_only);
-bool nir_lower_io_to_scalar(nir_shader *shader, nir_variable_mode mask, nir_instr_filter_cb filter, void *filter_data);
+bool nir_lower_io_to_scalar(nir_shader *shader, nir_variable_mode mask, nir_intrin_filter_cb filter, void *filter_data);
 bool nir_lower_io_vars_to_scalar(nir_shader *shader, nir_variable_mode mask);
 bool nir_opt_vectorize_io_vars(nir_shader *shader, nir_variable_mode mask);
 bool nir_lower_tess_level_array_vars_to_vec(nir_shader *shader);
diff --git a/src/compiler/nir/nir_lower_io_to_scalar.c b/src/compiler/nir/nir_lower_io_to_scalar.c
index e6ded377414..d21d9ee6422 100644
--- a/src/compiler/nir/nir_lower_io_to_scalar.c
+++ b/src/compiler/nir/nir_lower_io_to_scalar.c
@@ -268,20 +268,15 @@ lower_store_to_scalar(nir_builder *b, nir_intrinsic_instr *intr)
 
 struct scalarize_state {
    nir_variable_mode mask;
-   nir_instr_filter_cb filter;
+   nir_intrin_filter_cb filter;
    void *filter_data;
 };
 
 static bool
-nir_lower_io_to_scalar_instr(nir_builder *b, nir_instr *instr, void *data)
+nir_lower_io_to_scalar_instr(nir_builder *b, nir_intrinsic_instr *intr, void *data)
 {
    struct scalarize_state *state = data;
 
-   if (instr->type != nir_instr_type_intrinsic)
-      return false;
-
-   nir_intrinsic_instr *intr = nir_instr_as_intrinsic(instr);
-
    if (intr->num_components == 1)
       return false;
 
@@ -291,7 +286,7 @@ nir_lower_io_to_scalar_instr(nir_builder *b, nir_instr *instr, void *data)
         intr->intrinsic == nir_intrinsic_load_interpolated_input ||
         intr->intrinsic == nir_intrinsic_load_input_vertex) &&
        (state->mask & nir_var_shader_in) &&
-       (!state->filter || state->filter(instr, state->filter_data))) {
+       (!state->filter || state->filter(intr, state->filter_data))) {
       lower_load_input_to_scalar(b, intr);
       return true;
    }
@@ -301,7 +296,7 @@ nir_lower_io_to_scalar_instr(nir_builder *b, nir_instr *instr, void *data)
         intr->intrinsic == nir_intrinsic_load_per_view_output ||
         intr->intrinsic == nir_intrinsic_load_per_primitive_output) &&
        (state->mask & nir_var_shader_out) &&
-       (!state->filter || state->filter(instr, state->filter_data))) {
+       (!state->filter || state->filter(intr, state->filter_data))) {
       lower_load_input_to_scalar(b, intr);
       return true;
    }
@@ -311,7 +306,7 @@ nir_lower_io_to_scalar_instr(nir_builder *b, nir_instr *instr, void *data)
         (intr->intrinsic == nir_intrinsic_load_global && (state->mask & nir_var_mem_global)) ||
         (intr->intrinsic == nir_intrinsic_load_shared && (state->mask & nir_var_mem_shared)) ||
         (intr->intrinsic == nir_intrinsic_load_push_constant && (state->mask & nir_var_mem_push_const))) &&
-       (!state->filter || state->filter(instr, state->filter_data))) {
+       (!state->filter || state->filter(intr, state->filter_data))) {
       lower_load_to_scalar(b, intr);
       return true;
    }
@@ -321,7 +316,7 @@ nir_lower_io_to_scalar_instr(nir_builder *b, nir_instr *instr, void *data)
         intr->intrinsic == nir_intrinsic_store_per_view_output ||
         intr->intrinsic == nir_intrinsic_store_per_primitive_output) &&
        state->mask & nir_var_shader_out &&
-       (!state->filter || state->filter(instr, state->filter_data))) {
+       (!state->filter || state->filter(intr, state->filter_data))) {
       lower_store_output_to_scalar(b, intr);
       return true;
    }
@@ -329,7 +324,7 @@ nir_lower_io_to_scalar_instr(nir_builder *b, nir_instr *instr, void *data)
    if (((intr->intrinsic == nir_intrinsic_store_ssbo && (state->mask & nir_var_mem_ssbo)) ||
         (intr->intrinsic == nir_intrinsic_store_global && (state->mask & nir_var_mem_global)) ||
         (intr->intrinsic == nir_intrinsic_store_shared && (state->mask & nir_var_mem_shared))) &&
-       (!state->filter || state->filter(instr, state->filter_data))) {
+       (!state->filter || state->filter(intr, state->filter_data))) {
       lower_store_to_scalar(b, intr);
       return true;
    }
@@ -338,15 +333,15 @@ nir_lower_io_to_scalar_instr(nir_builder *b, nir_instr *instr, void *data)
 }
 
 bool
-nir_lower_io_to_scalar(nir_shader *shader, nir_variable_mode mask, nir_instr_filter_cb filter, void *filter_data)
+nir_lower_io_to_scalar(nir_shader *shader, nir_variable_mode mask, nir_intrin_filter_cb filter, void *filter_data)
 {
    struct scalarize_state state = {
       mask,
       filter,
       filter_data
    };
-   return nir_shader_instructions_pass(shader,
-                                       nir_lower_io_to_scalar_instr,
-                                       nir_metadata_control_flow,
-                                       &state);
+   return nir_shader_intrinsics_pass(shader,
+                                     nir_lower_io_to_scalar_instr,
+                                     nir_metadata_control_flow,
+                                     &state);
 }
diff --git a/src/freedreno/ir3/ir3_nir.c b/src/freedreno/ir3/ir3_nir.c
index 2ba5fedcae7..15538e458cf 100644
--- a/src/freedreno/ir3/ir3_nir.c
+++ b/src/freedreno/ir3/ir3_nir.c
@@ -137,10 +137,9 @@ ir3_load_driver_ubo_indirect(nir_builder *b, unsigned components,
 }
 
 static bool
-ir3_nir_should_scalarize_mem(const nir_instr *instr, const void *data)
+ir3_nir_should_scalarize_mem(const nir_intrinsic_instr *intrin, const void *data)
 {
    const struct ir3_compiler *compiler = data;
-   const nir_intrinsic_instr *intrin = nir_instr_as_intrinsic(instr);
 
    /* Scalarize load_ssbo's that we could otherwise lower to isam,
     * as the tex cache benefit outweighs the benefit of vectorizing
diff --git a/src/imagination/pco/pco_nir.c b/src/imagination/pco/pco_nir.c
index 3b9ce60196b..985f2b48111 100644
--- a/src/imagination/pco/pco_nir.c
+++ b/src/imagination/pco/pco_nir.c
@@ -144,12 +144,10 @@ static uint8_t vectorize_filter(const nir_instr *instr, UNUSED const void *data)
  * \param[in] data User data.
  * \return True if the instruction was found.
  */
-static bool frag_in_scalar_filter(const nir_instr *instr, const void *data)
+static bool frag_in_scalar_filter(const nir_intrinsic_instr *intr, const void *data)
 {
-   assert(instr->type == nir_instr_type_intrinsic);
    nir_shader *nir = (nir_shader *)data;
 
-   nir_intrinsic_instr *intr = nir_instr_as_intrinsic(instr);
    if (intr->intrinsic != nir_intrinsic_load_input &&
        intr->intrinsic != nir_intrinsic_load_interpolated_input) {
       return false;