treewide: simplify nir_def_rewrite_uses_after

Most of the time with nir_def_rewrite_uses_after, you want to rewrite after the
replacement. Make that the default thing to be more ergonomic and to drop
parent_instr uses.

We leave nir_def_rewrite_uses_after_instr defined if you really want the old
signature with an arbitrary after point.

Via Coccinelle patch:

    @@
    expression a, b;
    @@

    -nir_def_rewrite_uses_after(a, b, b->parent_instr)
    +nir_def_rewrite_uses_after_def(a, b)

Followed by a bunch of sed.

Signed-off-by: Alyssa Rosenzweig <alyssa@rosenzweig.io>
Reviewed-by: Emma Anholt <emma@anholt.net>
Reviewed-by: Marek Olšák <maraeo@gmail.com>
Acked-by: Karol Herbst <kherbst@redhat.com>
Acked-by: Konstantin Seurer <konstantin.seurer@gmail.com>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/36489>

src/amd/common/nir/ac_nir_lower_image_opcodes_cdna.c

@@ -390,7 +390,7 @@ static bool lower_image_opcodes(nir_builder *b, nir_instr *instr, void *data)
       case nir_intrinsic_bindless_image_load:
          result = emulated_image_load(b, intr->def.num_components, intr->def.bit_size,
                                       desc, intr->src[1].ssa, access, dim, is_array, true);
-         nir_def_rewrite_uses_after(dst, result, instr);
+         nir_def_rewrite_uses_after_instr(dst, result, instr);
          nir_instr_remove(instr);
          return true;
 
@@ -480,7 +480,7 @@ static bool lower_image_opcodes(nir_builder *b, nir_instr *instr, void *data)
                                          desc, coord,
                                          ACCESS_RESTRICT | ACCESS_NON_WRITEABLE | ACCESS_CAN_REORDER,
                                          tex->sampler_dim, tex->is_array, true);
-            nir_def_rewrite_uses_after(dst, result, instr);
+            nir_def_rewrite_uses_after_instr(dst, result, instr);
             nir_instr_remove(instr);
             return true;
 
@@ -488,7 +488,7 @@ static bool lower_image_opcodes(nir_builder *b, nir_instr *instr, void *data)
          case nir_texop_txl:
             result = emulated_tex_level_zero(b, tex->def.num_components, tex->def.bit_size,
                                   desc, sampler_desc, coord, tex->sampler_dim, tex->is_array);
-            nir_def_rewrite_uses_after(dst, result, instr);
+            nir_def_rewrite_uses_after_instr(dst, result, instr);
             nir_instr_remove(instr);
             return true;
 

src/amd/common/nir/ac_nir_lower_ngg.c

@@ -413,7 +413,7 @@ replace_scalar_component_uses(nir_builder *b, nir_scalar old, nir_scalar rep)
    }
 
    nir_def *replacement = nir_vec(b, dst, old.def->num_components);
-   nir_def_rewrite_uses_after(old.def, replacement, replacement->parent_instr);
+   nir_def_rewrite_uses_after(old.def, replacement);
 }
 
 static bool
@@ -795,7 +795,7 @@ save_reusable_variables(nir_builder *b, lower_ngg_nogs_state *s)
                      : nir_after_instr(instr);
          nir_store_var(b, saved->var, saved->ssa, BITFIELD_MASK(ssa->num_components));
          nir_def *reloaded = nir_load_var(b, saved->var);
-         nir_def_rewrite_uses_after(ssa, reloaded, reloaded->parent_instr);
+         nir_def_rewrite_uses_after(ssa, reloaded);
       }
 
       /* Look at the next CF node. */

src/amd/common/nir/ac_nir_lower_resinfo.c

@@ -368,7 +368,7 @@ static bool lower_resinfo(nir_builder *b, nir_instr *instr, void *data)
    if (dst->bit_size == 16)
       result = nir_u2u16(b, result);
 
-   nir_def_rewrite_uses_after(dst, result, instr);
+   nir_def_rewrite_uses_after_instr(dst, result, instr);
    nir_instr_remove(instr);
    return true;
 }

src/amd/vulkan/nir/radv_nir_lower_fs_intrinsics.c

@@ -69,7 +69,7 @@ pass(nir_builder *b, nir_intrinsic_instr *intrin, void *data)
       frag_z = nir_bcsel(b, cond, adjusted_frag_z, frag_z);
 
       nir_def *new_dest = nir_vector_insert_imm(b, &intrin->def, frag_z, 2);
-      nir_def_rewrite_uses_after(&intrin->def, new_dest, new_dest->parent_instr);
+      nir_def_rewrite_uses_after(&intrin->def, new_dest);
       return true;
    }
    case nir_intrinsic_load_barycentric_at_sample: {

src/amd/vulkan/nir/radv_nir_lower_vs_inputs.c

@@ -472,7 +472,7 @@ opt_vs_input_to_const(nir_builder *b, nir_intrinsic_instr *intrin, void *state)
    }
 
    if (res != &intrin->def) {
-      nir_def_rewrite_uses_after(&intrin->def, res, res->parent_instr);
+      nir_def_rewrite_uses_after(&intrin->def, res);
       return true;
    } else {
       return false;

src/amd/vulkan/nir/radv_nir_rt_shader.c

@@ -1084,7 +1084,7 @@ lower_any_hit_for_intersection(nir_shader *any_hit)
             case nir_intrinsic_load_rt_arg_scratch_offset_amd:
                b->cursor = nir_after_instr(instr);
                nir_def *arg_offset = nir_isub(b, &intrin->def, scratch_offset);
-               nir_def_rewrite_uses_after(&intrin->def, arg_offset, arg_offset->parent_instr);
+               nir_def_rewrite_uses_after(&intrin->def, arg_offset);
                break;
 
             default:

src/asahi/compiler/agx_nir_lower_fminmax.c

@@ -65,8 +65,7 @@ lower(nir_builder *b, nir_alu_instr *alu, void *data)
       b->exact = true;
 
       nir_def *canonicalized = nir_fadd_imm(b, &alu->def, -0.0);
-      nir_def_rewrite_uses_after(&alu->def, canonicalized,
-                                 canonicalized->parent_instr);
+      nir_def_rewrite_uses_after(&alu->def, canonicalized);
    }
 
    return true;

src/asahi/compiler/agx_nir_lower_subgroups.c

@@ -151,7 +151,7 @@ lower(nir_builder *b, nir_intrinsic_instr *intr, void *data)
       b->cursor = nir_after_instr(&intr->instr);
       intr->intrinsic = nir_intrinsic_exclusive_scan;
       nir_def *accum = nir_build_alu2(b, red_op, data, &intr->def);
-      nir_def_rewrite_uses_after(&intr->def, accum, accum->parent_instr);
+      nir_def_rewrite_uses_after(&intr->def, accum);
       return true;
    }
 

src/asahi/lib/agx_nir_lower_sample_intrinsics.c

@@ -87,7 +87,7 @@ lower(nir_builder *b, nir_intrinsic_instr *intr, void *data)
          lowered = nir_iand(b, lowered, nir_u2uN(b, bit, old->bit_size));
       }
 
-      nir_def_rewrite_uses_after(old, lowered, lowered->parent_instr);
+      nir_def_rewrite_uses_after(old, lowered);
       return true;
    }
 
@@ -121,7 +121,7 @@ lower(nir_builder *b, nir_intrinsic_instr *intr, void *data)
          b, intr->def.bit_size, nir_load_sample_id(b),
          .interp_mode = nir_intrinsic_interp_mode(intr));
 
-      nir_def_rewrite_uses_after(old, lowered, lowered->parent_instr);
+      nir_def_rewrite_uses_after(old, lowered);
       return true;
    }
 

src/asahi/vulkan/hk_shader.c

@@ -697,7 +697,7 @@ lower_min_lod(nir_builder *b, nir_tex_instr *tex, UNUSED void *_data)
       nir_def *oob = nir_ine_imm(b, min_lod, 0);
       nir_def *zero = nir_imm_zero(b, old->num_components, old->bit_size);
       nir_def *new_ = nir_bcsel(b, oob, zero, old);
-      nir_def_rewrite_uses_after(old, new_, new_->parent_instr);
+      nir_def_rewrite_uses_after(old, new_);
    } else if (tex->op == nir_texop_txl) {
       assert(other_min_lod == NULL && "txl doesn't have an API min lod");
 
@@ -747,7 +747,7 @@ lower_viewport_fs(nir_builder *b, nir_intrinsic_instr *intr, UNUSED void *data)
    nir_def *uvs = nir_load_uvs_index_agx(b, .io_semantics = sem);
    nir_def *def = nir_bcsel(b, nir_ine_imm(b, uvs, 0), orig, nir_imm_int(b, 0));
 
-   nir_def_rewrite_uses_after(orig, def, def->parent_instr);
+   nir_def_rewrite_uses_after(orig, def);
    return true;
 }
 

src/broadcom/compiler/v3d_nir_lower_image_load_store.c

@@ -419,8 +419,7 @@ v3d_nir_lower_image_load(nir_builder *b, nir_intrinsic_instr *instr)
                                   nir_unpack_half_2x16_split_y(b, ba));
         }
 
-        nir_def_rewrite_uses_after(&instr->def, result,
-                                       result->parent_instr);
+        nir_def_rewrite_uses_after(&instr->def, result);
 
         return true;
 }

src/broadcom/vulkan/v3dv_pipeline.c

@@ -915,8 +915,7 @@ lower_point_coord_cb(nir_builder *b, nir_intrinsic_instr *intr, void *_state)
    result =
       nir_vector_insert_imm(b, result,
                             nir_fsub_imm(b, 1.0, nir_channel(b, result, 1)), 1);
-   nir_def_rewrite_uses_after(&intr->def,
-                                  result, result->parent_instr);
+   nir_def_rewrite_uses_after(&intr->def, result);
    return true;
 }
 

src/compiler/glsl/gl_nir_lower_buffers.c

@@ -262,9 +262,7 @@ lower_buffer_interface_derefs_impl(nir_function_impl *impl,
                   b.cursor = nir_after_instr(&intrin->instr);
                   intrin->def.bit_size = 32;
                   nir_def *bval = nir_i2b(&b, &intrin->def);
-                  nir_def_rewrite_uses_after(&intrin->def,
-                                                 bval,
-                                                 bval->parent_instr);
+                  nir_def_rewrite_uses_after(&intrin->def, bval);
                   progress = true;
                }
                break;

src/compiler/nir/nir.c

@@ -1653,7 +1653,7 @@ is_instr_between(nir_instr *start, nir_instr *end, nir_instr *between)
  * def->parent_instr and that after_me comes after def->parent_instr.
  */
 void
-nir_def_rewrite_uses_after(nir_def *def, nir_def *new_ssa,
+nir_def_rewrite_uses_after_instr(nir_def *def, nir_def *new_ssa,
                            nir_instr *after_me)
 {
    if (def == new_ssa)

src/compiler/nir/nir.h

@@ -4454,8 +4454,14 @@ nir_def_init_for_type(nir_instr *instr, nir_def *def,
 }
 void nir_def_rewrite_uses(nir_def *def, nir_def *new_ssa);
 void nir_def_rewrite_uses_src(nir_def *def, nir_src new_src);
-void nir_def_rewrite_uses_after(nir_def *def, nir_def *new_ssa,
-                                nir_instr *after_me);
+void nir_def_rewrite_uses_after_instr(nir_def *def, nir_def *new_ssa,
+                                      nir_instr *after_me);
+
+static inline void
+nir_def_rewrite_uses_after(nir_def *def, nir_def *new_ssa)
+{
+   nir_def_rewrite_uses_after_instr(def, new_ssa, new_ssa->parent_instr);
+}
 
 static inline void
 nir_def_replace(nir_def *def, nir_def *new_ssa)

src/compiler/nir/nir_deref.c

@@ -1389,8 +1389,7 @@ opt_load_vec_deref(nir_builder *b, nir_intrinsic_instr *load)
          data = nir_bitcast_vector(b, &load->def, old_bit_size);
       data = resize_vector(b, data, old_num_comps);
 
-      nir_def_rewrite_uses_after(&load->def, data,
-                                 data->parent_instr);
+      nir_def_rewrite_uses_after(&load->def, data);
       return true;
    }
 

src/compiler/nir/nir_lower_array_deref_of_vec.c

@@ -122,9 +122,7 @@ nir_lower_array_deref_of_vec_impl(nir_function_impl *impl,
             if (scalar->parent_instr->type == nir_instr_type_undef) {
                nir_def_replace(&intrin->def, scalar);
             } else {
-               nir_def_rewrite_uses_after(&intrin->def,
-                                          scalar,
-                                          scalar->parent_instr);
+               nir_def_rewrite_uses_after(&intrin->def, scalar);
             }
             progress = true;
          }

src/compiler/nir/nir_lower_bit_size.c

@@ -303,8 +303,7 @@ lower_phi_instr(nir_builder *b, nir_phi_instr *phi, unsigned bit_size,
    b->cursor = nir_after_instr(&last_phi->instr);
 
    nir_def *new_dest = nir_u2uN(b, &phi->def, old_bit_size);
-   nir_def_rewrite_uses_after(&phi->def, new_dest,
-                              new_dest->parent_instr);
+   nir_def_rewrite_uses_after(&phi->def, new_dest);
 }
 
 static bool

src/compiler/nir/nir_lower_cl_images.c

@@ -264,7 +264,7 @@ nir_lower_cl_images(nir_shader *shader, bool lower_image_derefs, bool lower_samp
                   intrin->num_components = 4;
                   intrin->def.num_components = 4;
                   nir_def *scalar = nir_channel(&b, &intrin->def, 0);
-                  nir_def_rewrite_uses_after(&intrin->def, scalar, scalar->parent_instr);
+                  nir_def_rewrite_uses_after(&intrin->def, scalar);
                   progress = true;
                }
 

src/compiler/nir/nir_lower_fragcoord_wtrans.c

@@ -62,8 +62,7 @@ lower_fragcoord_wtrans(nir_builder *b, nir_intrinsic_instr *intr,
 
    nir_def *frag_coord = nir_vector_insert_imm(b, &intr->def, invert, 3);
 
-   nir_def_rewrite_uses_after(&intr->def, frag_coord,
-                              frag_coord->parent_instr);
+   nir_def_rewrite_uses_after(&intr->def, frag_coord);
 
    return true;
 }

src/compiler/nir/nir_lower_mediump.c

@@ -129,8 +129,7 @@ nir_lower_mediump_io(nir_shader *nir, nir_variable_mode modes,
             intr->def.bit_size = 16;
             nir_intrinsic_set_dest_type(intr, (type & ~32) | 16);
             nir_def *dst = convert(&b, &intr->def);
-            nir_def_rewrite_uses_after(&intr->def, dst,
-                                       dst->parent_instr);
+            nir_def_rewrite_uses_after(&intr->def, dst);
          }
 
          if (use_16bit_slots && is_varying &&
@@ -278,9 +277,7 @@ nir_lower_mediump_vars_impl(nir_function_impl *impl, nir_variable_mode modes,
                   UNREACHABLE("Invalid 16-bit type");
                }
 
-               nir_def_rewrite_uses_after(&intrin->def,
-                                          replace,
-                                          replace->parent_instr);
+               nir_def_rewrite_uses_after(&intrin->def, replace);
                progress = true;
                break;
             }

src/compiler/nir/nir_lower_pntc_ytransform.c

@@ -83,7 +83,7 @@ lower_load_pointcoord(lower_pntc_ytransform_state *state,
 
    /* Reassemble the vector. */
    pntc = nir_vector_insert_imm(b, pntc, flipped_y, y_swizzle);
-   nir_def_rewrite_uses_after(&intr->def, pntc, pntc->parent_instr);
+   nir_def_rewrite_uses_after(&intr->def, pntc);
 }
 
 static void

src/compiler/nir/nir_lower_tex.c

@@ -307,7 +307,7 @@ lower_1d(nir_builder *b, nir_tex_instr *tex)
          dst = nir_channel(b, &tex->def, 0);
       }
 
-      nir_def_rewrite_uses_after(&tex->def, dst, dst->parent_instr);
+      nir_def_rewrite_uses_after(&tex->def, dst);
    }
 }
 
@@ -1087,8 +1087,7 @@ swizzle_tg4_broadcom(nir_builder *b, nir_tex_instr *tex)
    unsigned swiz[4] = { 2, 3, 1, 0 };
    nir_def *swizzled = nir_swizzle(b, &tex->def, swiz, 4);
 
-   nir_def_rewrite_uses_after(&tex->def, swizzled,
-                              swizzled->parent_instr);
+   nir_def_rewrite_uses_after(&tex->def, swizzled);
 }
 
 static void
@@ -1125,8 +1124,7 @@ swizzle_result(nir_builder *b, nir_tex_instr *tex, const uint8_t swizzle[4])
       }
    }
 
-   nir_def_rewrite_uses_after(&tex->def, swizzled,
-                              swizzled->parent_instr);
+   nir_def_rewrite_uses_after(&tex->def, swizzled);
 }
 
 static void
@@ -1147,8 +1145,7 @@ linearize_srgb_result(nir_builder *b, nir_tex_instr *tex)
                               nir_channel(b, rgb, 2),
                               nir_channel(b, &tex->def, 3));
 
-   nir_def_rewrite_uses_after(&tex->def, result,
-                              result->parent_instr);
+   nir_def_rewrite_uses_after(&tex->def, result);
 }
 
 /**
@@ -1228,8 +1225,7 @@ lower_tex_packing(nir_builder *b, nir_tex_instr *tex,
       break;
    }
 
-   nir_def_rewrite_uses_after(&tex->def, color,
-                              color->parent_instr);
+   nir_def_rewrite_uses_after(&tex->def, color);
    return true;
 }
 
@@ -1352,8 +1348,7 @@ nir_lower_txs_lod(nir_builder *b, nir_tex_instr *tex)
       minified = nir_vec(b, comp, dest_size);
    }
 
-   nir_def_rewrite_uses_after(&tex->def, minified,
-                              minified->parent_instr);
+   nir_def_rewrite_uses_after(&tex->def, minified);
    return true;
 }
 
@@ -1372,7 +1367,7 @@ nir_lower_txs_cube_array(nir_builder *b, nir_tex_instr *tex)
                    nir_idiv(b, nir_channel(b, size, 2),
                             nir_imm_int(b, 6)));
 
-   nir_def_rewrite_uses_after(&tex->def, size, size->parent_instr);
+   nir_def_rewrite_uses_after(&tex->def, size);
 }
 
 /* Adjust the sample index according to AMD FMASK (fragment mask).
@@ -1483,7 +1478,7 @@ nir_lower_lod_zero_width(nir_builder *b, nir_tex_instr *tex)
    nir_def *def =
       nir_vec2(b, nir_channel(b, &tex->def, 0), adjusted_lod);
 
-   nir_def_rewrite_uses_after(&tex->def, def, def->parent_instr);
+   nir_def_rewrite_uses_after(&tex->def, def);
 }
 
 static void

src/compiler/nir/nir_lower_texcoord_replace.c

@@ -118,9 +118,7 @@ nir_lower_texcoord_replace_impl(nir_function_impl *impl,
          nir_def *result = nir_bcsel(&b, cond, nir_channels(&b, new_coord, component_mask),
                                      &intrin->def);
 
-         nir_def_rewrite_uses_after(&intrin->def,
-                                    result,
-                                    result->parent_instr);
+         nir_def_rewrite_uses_after(&intrin->def, result);
       }
    }
 

src/compiler/nir/nir_lower_texcoord_replace_late.c

@@ -64,8 +64,7 @@ pass(nir_builder *b, nir_instr *instr, void *data)
    }
 
    nir_def *res = nir_vec(b, &channels[component], intr->num_components);
-   nir_def_rewrite_uses_after(&intr->def, res,
-                              res->parent_instr);
+   nir_def_rewrite_uses_after(&intr->def, res);
    return true;
 }
 

src/compiler/nir/nir_lower_vec3_to_vec4.c

@@ -59,9 +59,7 @@ lower_vec3_to_vec4_instr(nir_builder *b, nir_instr *instr, void *data)
 
          b->cursor = nir_after_instr(&intrin->instr);
          nir_def *vec3 = nir_trim_vector(b, &intrin->def, 3);
-         nir_def_rewrite_uses_after(&intrin->def,
-                                    vec3,
-                                    vec3->parent_instr);
+         nir_def_rewrite_uses_after(&intrin->def, vec3);
          return true;
       }
 

src/compiler/nir/nir_lower_wpos_center.c

@@ -52,7 +52,7 @@ lower_wpos_center_instr(nir_builder *b, nir_intrinsic_instr *intr, void *data)
    nir_def *spos = nir_load_sample_pos_or_center(b);
    wpos = nir_fadd(b, wpos, nir_pad_vector_imm_int(b, spos, 0, 4));
 
-   nir_def_rewrite_uses_after(&intr->def, wpos, wpos->parent_instr);
+   nir_def_rewrite_uses_after(&intr->def, wpos);
    return true;
 }
 

src/compiler/nir/nir_lower_wpos_ytransform.c

@@ -112,8 +112,7 @@ emit_wpos_adjustment(lower_wpos_ytransform_state *state,
 
    nir_def *new_wpos = nir_vec(b, &wpos[c], intr->num_components);
 
-   nir_def_rewrite_uses_after(&intr->def, new_wpos,
-                              new_wpos->parent_instr);
+   nir_def_rewrite_uses_after(&intr->def, new_wpos);
 
    return true;
 }
@@ -263,8 +262,7 @@ lower_load_sample_pos(lower_wpos_ytransform_state *state,
                                  nir_fmax(b, neg_scale, nir_imm_float(b, 0.0)));
    nir_def *flipped_pos = nir_vector_insert_imm(b, pos, flipped_y, 1);
 
-   nir_def_rewrite_uses_after(&intr->def, flipped_pos,
-                              flipped_pos->parent_instr);
+   nir_def_rewrite_uses_after(&intr->def, flipped_pos);
 
    return true;
 }

src/compiler/nir/nir_opt_copy_prop_vars.c

@@ -1110,8 +1110,7 @@ copy_prop_vars_block(struct copy_prop_var_state *state,
                    * rewrite the vecN itself.
                    */
                   nir_def_rewrite_uses_after(&intrin->def,
-                                             value.ssa.def[0],
-                                             value.ssa.def[0]->parent_instr);
+                                                 value.ssa.def[0]);
                } else {
                   nir_def_rewrite_uses(&intrin->def,
                                        value.ssa.def[0]);

src/compiler/nir/nir_opt_load_store_vectorize.c

@@ -828,13 +828,12 @@ vectorize_loads(nir_builder *b, struct vectorize_ctx *ctx,
 
    /* update uses */
    if (first == low) {
-      nir_def_rewrite_uses_after(&low->intrin->def, low_def,
+      nir_def_rewrite_uses_after_instr(&low->intrin->def, low_def,
                                  high_def->parent_instr);
       nir_def_rewrite_uses(&high->intrin->def, high_def);
    } else {
       nir_def_rewrite_uses(&low->intrin->def, low_def);
-      nir_def_rewrite_uses_after(&high->intrin->def, high_def,
-                                 high_def->parent_instr);
+      nir_def_rewrite_uses_after(&high->intrin->def, high_def);
    }
 
    /* update the intrinsic */

src/compiler/nir/nir_opt_vectorize_io_vars.c

@@ -494,9 +494,7 @@ nir_opt_vectorize_io_vars_impl(nir_function_impl *impl, nir_variable_mode modes)
 
             nir_def *new_vec = nir_channels(&b, &intrin->def,
                                             vec4_comp_mask >> new_frac);
-            nir_def_rewrite_uses_after(&intrin->def,
-                                       new_vec,
-                                       new_vec->parent_instr);
+            nir_def_rewrite_uses_after(&intrin->def, new_vec);
 
             progress = true;
             break;

src/compiler/nir/nir_split_vars.c

@@ -1607,9 +1607,7 @@ shrink_vec_var_access_impl(nir_function_impl *impl,
                }
                nir_def *vec = nir_vec(&b, vec_srcs, intrin->num_components);
 
-               nir_def_rewrite_uses_after(&intrin->def,
-                                          vec,
-                                          vec->parent_instr);
+               nir_def_rewrite_uses_after(&intrin->def, vec);
 
                /* The SSA def is now only used by the swizzle.  It's safe to
                 * shrink the number of components.

src/compiler/nir/nir_trivialize_registers.c

@@ -101,7 +101,7 @@ trivialize_load(nir_intrinsic_instr *load)
    nir_builder b = nir_builder_at(nir_after_instr(&load->instr));
    nir_def *copy = nir_mov(&b, &load->def);
    copy->divergent = load->def.divergent;
-   nir_def_rewrite_uses_after(&load->def, copy, copy->parent_instr);
+   nir_def_rewrite_uses_after(&load->def, copy);
 
    assert(list_is_singular(&load->def.uses));
 }

src/freedreno/ir3/ir3_nir_lower_shading_rate.c

@@ -52,7 +52,7 @@ nir_lower_frag_shading_rate(nir_builder *b, nir_intrinsic_instr *intr,
    nir_deref_instr *result = nir_build_deref_array(b, lut, &intr->def);
    nir_def *r = nir_build_load_deref(b, 1, 32, &result->def, 0);
 
-   nir_def_rewrite_uses_after(&intr->def, r, r->parent_instr);
+   nir_def_rewrite_uses_after(&intr->def, r);
    return true;
 }
 

src/freedreno/vulkan/tu_shader.cc

@@ -599,8 +599,7 @@ lower_tex_ycbcr(const struct tu_pipeline_layout *layout,
                                               ycbcr_sampler->ycbcr_range,
                                               &tex->def,
                                               bpcs);
-   nir_def_rewrite_uses_after(&tex->def, result,
-                              result->parent_instr);
+   nir_def_rewrite_uses_after(&tex->def, result);
 
    builder->cursor = nir_before_instr(&tex->instr);
 }

src/gallium/drivers/asahi/agx_state.c

@@ -1463,7 +1463,7 @@ agx_nir_lower_point_sprite_zw(nir_builder *b, nir_intrinsic_instr *intr,
    }
 
    nir_def *new_vec = nir_vec(b, &chans[component], intr->def.num_components);
-   nir_def_rewrite_uses_after(&intr->def, new_vec, new_vec->parent_instr);
+   nir_def_rewrite_uses_after(&intr->def, new_vec);
    return true;
 }
 

src/gallium/drivers/crocus/crocus_program.c

@@ -985,7 +985,7 @@ crocus_setup_binding_table(const struct intel_device_info *devinfo,
                   val = nir_ishl_imm(&b, val, 32 - width);
                   val = nir_ishr_imm(&b, val, 32 - width);
                }
-               nir_def_rewrite_uses_after(&tex->def, val, val->parent_instr);
+               nir_def_rewrite_uses_after(&tex->def, val);
             }
 
             tex->texture_index =

src/gallium/drivers/d3d12/d3d12_lower_image_casts.c

@@ -230,7 +230,7 @@ lower_image_cast_instr(nir_builder *b, nir_intrinsic_instr *intr, void *_data)
          nir_type_int : nir_type_float);
 
    if (intr->intrinsic == nir_intrinsic_image_deref_load) {
-      nir_def_rewrite_uses_after(value, new_value, new_value->parent_instr);
+      nir_def_rewrite_uses_after(value, new_value);
       nir_intrinsic_set_dest_type(intr, alu_type);
    } else {
       nir_src_rewrite(&intr->src[3], new_value);

src/gallium/drivers/d3d12/d3d12_nir_passes.c

@@ -124,7 +124,7 @@ lower_pos_read(nir_builder *b, struct nir_intrinsic_instr *intr, void *_var)
 
    pos = nir_vector_insert_imm(b, pos, depth, 2);
 
-   nir_def_rewrite_uses_after(&intr->def, pos, pos->parent_instr);
+   nir_def_rewrite_uses_after(&intr->def, pos);
    return true;
 }
 

src/gallium/drivers/etnaviv/etnaviv_nir.c

@@ -68,9 +68,7 @@ etna_lower_io(nir_shader *shader, struct etna_shader_variant *v)
                   if (v->key.front_ccw)
                      nir_def_as_alu(ssa)->op = nir_op_ieq;
 
-                  nir_def_rewrite_uses_after(&intr->def,
-                                                 ssa,
-                                                 ssa->parent_instr);
+                  nir_def_rewrite_uses_after(&intr->def, ssa);
 
                   func_progress = true;
                } break;
@@ -170,9 +168,7 @@ etna_lower_alu_impl(nir_function_impl *impl, bool has_new_transcendentals)
 
             nir_instr_insert_after(instr, &mul->instr);
 
-            nir_def_rewrite_uses_after(ssa, &mul->def,
-                                           &mul->instr);
-
+            nir_def_rewrite_uses_after(ssa, &mul->def);
             progress = true;
          }
       }

src/gallium/drivers/vc4/vc4_nir_lower_io.c

@@ -252,9 +252,7 @@ vc4_nir_lower_fs_input(struct vc4_compile *c, nir_builder *b,
                         result = nir_fsub_imm(b, 1.0, result);
 
                 if (result != &intr->def) {
-                        nir_def_rewrite_uses_after(&intr->def,
-                                                       result,
-                                                       result->parent_instr);
+                        nir_def_rewrite_uses_after(&intr->def, result);
                 }
         }
 }

src/gallium/drivers/zink/zink_compiler.c

@@ -135,8 +135,7 @@ lower_basevertex_instr(nir_builder *b, nir_intrinsic_instr *instr, void *data)
                                           nir_imm_int(b, 0),
                                           NULL);
 
-   nir_def_rewrite_uses_after(&instr->def, composite,
-                                  composite->parent_instr);
+   nir_def_rewrite_uses_after(&instr->def, composite);
    return true;
 }
 
@@ -2824,7 +2823,7 @@ fill_zero_reads(nir_builder *b, nir_intrinsic_instr *intr, void *data)
    nir_def *dest = &intr->def;
    u_foreach_bit(component, rewrite_mask)
       dest = nir_vector_insert_imm(b, dest, nir_channel(b, zero, component), component);
-   nir_def_rewrite_uses_after(&intr->def, dest, dest->parent_instr);
+   nir_def_rewrite_uses_after(&intr->def, dest);
    return true;
 }
 
@@ -3227,7 +3226,7 @@ lower_64bit_vars_function(nir_shader *shader, nir_function_impl *impl, nir_varia
                   }
                   dest = nir_vec(&b, comp, intr->num_components);
                }
-               nir_def_rewrite_uses_after(&intr->def, dest, instr);
+               nir_def_rewrite_uses_after_instr(&intr->def, dest, instr);
             }
             _mesa_set_add(deletes, instr);
             break;
@@ -3486,7 +3485,7 @@ rewrite_tex_dest(nir_builder *b, nir_tex_instr *tex, nir_variable *var, struct z
          dest = nir_f2fN(b, &tex->def, dest_size);
       }
       if (!rewrite_depth)
-         nir_def_rewrite_uses_after(&tex->def, dest, dest->parent_instr);
+         nir_def_rewrite_uses_after(&tex->def, dest);
    }
    return dest;
 }
@@ -3555,7 +3554,7 @@ lower_zs_swizzle_tex_instr(nir_builder *b, nir_instr *instr, void *data)
             tex->component = 0;
             return true;
          }
-         nir_def_rewrite_uses_after(dest, swizzle, swizzle->parent_instr);
+         nir_def_rewrite_uses_after(dest, swizzle);
          return true;
       }
       nir_def *vec[4];
@@ -3576,12 +3575,12 @@ lower_zs_swizzle_tex_instr(nir_builder *b, nir_instr *instr, void *data)
          }
       }
       nir_def *swizzle = nir_vec(b, vec, num_components);
-      nir_def_rewrite_uses_after(dest, swizzle, swizzle->parent_instr);
+      nir_def_rewrite_uses_after(dest, swizzle);
    } else {
       assert(tex->is_shadow);
       nir_def *vec[4] = {dest, dest, dest, dest};
       nir_def *splat = nir_vec(b, vec, num_components);
-      nir_def_rewrite_uses_after(dest, splat, splat->parent_instr);
+      nir_def_rewrite_uses_after(dest, splat);
    }
    return true;
 }
@@ -3617,7 +3616,7 @@ invert_point_coord_instr(nir_builder *b, nir_intrinsic_instr *intr,
    b->cursor = nir_after_instr(&intr->instr);
    nir_def *def = nir_vec2(b, nir_channel(b, &intr->def, 0),
                                   nir_fsub_imm(b, 1.0, nir_channel(b, &intr->def, 1)));
-   nir_def_rewrite_uses_after(&intr->def, def, def->parent_instr);
+   nir_def_rewrite_uses_after(&intr->def, def);
    return true;
 }
 
@@ -3644,7 +3643,7 @@ lower_sparse_instr(nir_builder *b, nir_instr *instr, void *data)
       nir_def *res = nir_b2i32(b, nir_is_sparse_resident_zink(b, &tex->def));
       nir_def *vec = nir_vector_insert_imm(b, &tex->def, res,
                                            tex->def.num_components - 1);
-      nir_def_rewrite_uses_after(&tex->def, vec, vec->parent_instr);
+      nir_def_rewrite_uses_after(&tex->def, vec);
       return true;
    }
 
@@ -3654,7 +3653,7 @@ lower_sparse_instr(nir_builder *b, nir_instr *instr, void *data)
       case nir_intrinsic_image_deref_sparse_load: {
          nir_def *res = nir_b2i32(b, nir_is_sparse_resident_zink(b, &intrin->def));
          nir_def *vec = nir_vector_insert_imm(b, &intrin->def, res, 4);
-         nir_def_rewrite_uses_after(&intrin->def, vec, vec->parent_instr);
+         nir_def_rewrite_uses_after(&intrin->def, vec);
          return true;
       }
 
@@ -4181,7 +4180,7 @@ lower_baseinstance_instr(nir_builder *b, nir_intrinsic_instr *intr,
       return false;
    b->cursor = nir_after_instr(&intr->instr);
    nir_def *def = nir_isub(b, &intr->def, nir_load_base_instance(b));
-   nir_def_rewrite_uses_after(&intr->def, def, def->parent_instr);
+   nir_def_rewrite_uses_after(&intr->def, def);
    return true;
 }
 
@@ -4658,7 +4657,7 @@ convert_1d_shadow_tex(nir_builder *b, nir_instr *instr, void *data)
       /* take either xz or just x since this is promoted to 2D from 1D */
       uint32_t mask = num_components == 2 ? (1|4) : 1;
       nir_def *dst = nir_channels(b, &tex->def, mask);
-      nir_def_rewrite_uses_after(&tex->def, dst, dst->parent_instr);
+      nir_def_rewrite_uses_after(&tex->def, dst);
    }
    return true;
 }
@@ -4841,7 +4840,7 @@ split_bitfields_instr(nir_builder *b, nir_alu_instr *alu, void *data)
                                           nir_channel(b, alu->src[2].src.ssa, alu->src[2].swizzle[i]));
    }
    nir_def *dest = nir_vec(b, dests, num_components);
-   nir_def_rewrite_uses_after(&alu->def, dest, &alu->instr);
+   nir_def_rewrite_uses_after_instr(&alu->def, dest, &alu->instr);
    nir_instr_remove(&alu->instr);
    return true;
 }
@@ -4863,7 +4862,7 @@ strip_tex_ms_instr(nir_builder *b, nir_instr *in, void *data)
    switch (intr->intrinsic) {
    case nir_intrinsic_image_deref_samples:
       b->cursor = nir_before_instr(in);
-      nir_def_rewrite_uses_after(&intr->def, nir_imm_zero(b, 1, intr->def.bit_size), in);
+      nir_def_rewrite_uses_after_instr(&intr->def, nir_imm_zero(b, 1, intr->def.bit_size), in);
       nir_instr_remove(in);
       break;
    case nir_intrinsic_image_deref_store:
@@ -5982,7 +5981,7 @@ trivial_revectorize_scan(struct nir_builder *b, nir_intrinsic_instr *intr, void
                   /* detect if the merged instr loaded multiple components and use swizzle mask for rewrite */
                   unsigned use_components = merge_intr == base ? orig_components : merge_intr->def.num_components;
                   nir_def *swiz = nir_channels(b, &base->def, BITFIELD_RANGE(j, use_components));
-                  nir_def_rewrite_uses_after(&merge_intr->def, swiz, merge_intr == base ? swiz->parent_instr : &merge_intr->instr);
+                  nir_def_rewrite_uses_after_instr(&merge_intr->def, swiz, merge_intr == base ? swiz->parent_instr : &merge_intr->instr);
                   j += use_components - 1;
                }
             } else {
@@ -6058,7 +6057,7 @@ flatten_image_arrays_intr(struct nir_builder *b, nir_instr *instr, void *data)
    int parent_size = glsl_array_size(parent->type);
    b->cursor = nir_after_instr(instr);
    nir_deref_instr *new_deref = nir_build_deref_array(b, parent_parent, nir_iadd(b, nir_imul_imm(b, parent->arr.index.ssa, parent_size), deref->arr.index.ssa));
-   nir_def_rewrite_uses_after(&deref->def, &new_deref->def, &new_deref->instr);
+   nir_def_rewrite_uses_after(&deref->def, &new_deref->def);
    _mesa_set_add(data, instr);
    _mesa_set_add(data, &parent->instr);
    return true;

src/intel/compiler/brw_nir.c

@@ -268,8 +268,7 @@ remap_tess_levels(nir_builder *b, nir_intrinsic_instr *intr,
          nir_src_rewrite(&intr->src[0], src);
       }
    } else if (dest) {
-      nir_def_rewrite_uses_after(&intr->def, dest,
-                                     dest->parent_instr);
+      nir_def_rewrite_uses_after(&intr->def, dest);
    }
 
    return true;

src/intel/compiler/brw_nir_lower_fs_barycentrics.c

@@ -52,7 +52,7 @@ lower_flat_inputs(nir_builder *b, nir_intrinsic_instr *intrin, void *data)
                                                    INTEL_MSAA_FLAG_PROVOKING_VERTEX_LAST),
                                      last_vtx,
                                      first_vtx);
-   nir_def_rewrite_uses_after(&intrin->def, input_vertex, input_vertex->parent_instr);
+   nir_def_rewrite_uses_after(&intrin->def, input_vertex);
 
    return true;
 }

src/intel/compiler/brw_nir_opt_fsat.c

@@ -190,7 +190,7 @@ fixup_defs(struct set *fixup)
 
       nir_def *new_fsat = nir_fsat(&b, src_def);
 
-      nir_def_rewrite_uses_after(src_def, new_fsat, new_fsat->parent_instr);
+      nir_def_rewrite_uses_after(src_def, new_fsat);
    }
 }
 

src/intel/compiler/elk/elk_nir.c

@@ -157,8 +157,7 @@ remap_tess_levels(nir_builder *b, nir_intrinsic_instr *intr,
          nir_src_rewrite(&intr->src[0], src);
       }
    } else if (dest) {
-      nir_def_rewrite_uses_after(&intr->def, dest,
-                                     dest->parent_instr);
+      nir_def_rewrite_uses_after(&intr->def, dest);
    }
 
    return true;
@@ -516,7 +515,7 @@ elk_nir_lower_fs_smooth_interp_gfx4_instr(nir_builder *b, nir_intrinsic_instr *i
    b->cursor = nir_after_instr(&intr->instr);
    nir_def *result = nir_fmul(b, &intr->def, *pixel_w);
 
-   nir_def_rewrite_uses_after(&intr->def, result, result->parent_instr);
+   nir_def_rewrite_uses_after(&intr->def, result);
    return true;
 }
 

src/intel/compiler/elk/elk_nir_attribute_workarounds.c

@@ -115,8 +115,7 @@ apply_attr_wa_instr(nir_builder *b, nir_instr *instr, void *cb_data)
                                             : nir_u2f32(b, val);
    }
 
-   nir_def_rewrite_uses_after(&intrin->def, val,
-                                  val->parent_instr);
+   nir_def_rewrite_uses_after(&intrin->def, val);
 
    return true;
 }

src/intel/compiler/intel_nir_blockify_uniform_loads.c

@@ -93,7 +93,7 @@ rebase_const_offset_ubo_loads_instr(nir_builder *b,
    nir_def *rebase = nir_vec_scalars(b, components, orig_def_components);
    rebase->divergent = false;
 
-   nir_def_rewrite_uses_after(&intrin->def, rebase, rebase->parent_instr);
+   nir_def_rewrite_uses_after(&intrin->def, rebase);
 
    return true;
 }

src/intel/compiler/intel_nir_clamp_image_1d_2d_array_sizes.c

@@ -125,11 +125,7 @@ intel_nir_clamp_image_1d_2d_array_sizes_instr(nir_builder *b,
       nir_vec(b, components, image_size->num_components);
 
    b->cursor = nir_after_instr(instr);
-
-   nir_def_rewrite_uses_after(image_size,
-                                  image_size_replacement,
-                                  image_size_replacement->parent_instr);
-
+   nir_def_rewrite_uses_after(image_size, image_size_replacement);
    return true;
 }
 

src/intel/compiler/intel_nir_lower_shading_rate_output.c

@@ -92,8 +92,7 @@ lower_shading_rate_output_instr(nir_builder *b, nir_intrinsic_instr *intrin,
          nir_ior(b, nir_ishl_imm(b, nir_ushr_imm(b, u32_x, 1), 2),
                     nir_ushr_imm(b, u32_y, 1));
 
-      nir_def_rewrite_uses_after(packed_fp16_xy, bit_field,
-                                     bit_field->parent_instr);
+      nir_def_rewrite_uses_after(packed_fp16_xy, bit_field);
    }
 
    return true;

src/intel/compiler/intel_nir_lower_sparse.c

@@ -194,7 +194,7 @@ lower_tex_compare(nir_builder *b, nir_tex_instr *tex, int compare_idx)
 
    nir_def *new_vec = nir_vec(b, new_comps, sparse_tex->def.num_components);
 
-   nir_def_rewrite_uses_after(&tex->def, new_vec, new_vec->parent_instr);
+   nir_def_rewrite_uses_after(&tex->def, new_vec);
 }
 
 static bool

src/intel/vulkan/anv_nir_apply_pipeline_layout.c

@@ -1877,7 +1877,7 @@ lower_image_size_intrinsic(nir_builder *b, nir_intrinsic_instr *intrin,
       comps[c] = c == 2 ? image_depth : nir_channel(b, &intrin->def, c);
 
    nir_def *vec = nir_vec(b, comps, intrin->def.num_components);
-   nir_def_rewrite_uses_after(&intrin->def, vec, vec->parent_instr);
+   nir_def_rewrite_uses_after(&intrin->def, vec);
 
    return true;
 }

src/intel/vulkan_hasvk/anv_nir_apply_pipeline_layout.c

@@ -1134,9 +1134,7 @@ lower_gfx7_tex_swizzle(nir_builder *b, nir_tex_instr *tex, unsigned plane,
    nir_def *swiz_tex_res = nir_vec(b, swiz_comps, 4);
 
    /* Rewrite uses before we insert so we don't rewrite this use */
-   nir_def_rewrite_uses_after(&tex->def,
-                                  swiz_tex_res,
-                                  swiz_tex_res->parent_instr);
+   nir_def_rewrite_uses_after(&tex->def, swiz_tex_res);
 }
 
 static bool

src/microsoft/clc/clc_compiler.c

@@ -338,10 +338,7 @@ clc_lower_64bit_semantics(nir_shader *nir)
                b.cursor = nir_after_instr(instr);
 
                nir_def *i64 = nir_u2u64(&b, &intrinsic->def);
-               nir_def_rewrite_uses_after(
-                  &intrinsic->def,
-                  i64,
-                  i64->parent_instr);
+               nir_def_rewrite_uses_after(&intrinsic->def, i64);
             }
          }
       }

src/microsoft/compiler/dxil_nir.c

@@ -455,7 +455,7 @@ lower_deref_bit_size(nir_builder *b, nir_intrinsic_instr *intr, void *data)
          intr->def.bit_size = glsl_get_bit_size(var_scalar_type);
          b->cursor = nir_after_instr(&intr->instr);
          nir_def *downcast = nir_type_convert(b, &intr->def, new_type, old_type, nir_rounding_mode_undef);
-         nir_def_rewrite_uses_after(&intr->def, downcast, downcast->parent_instr);
+         nir_def_rewrite_uses_after(&intr->def, downcast);
       }
       else {
          b->cursor = nir_before_instr(&intr->instr);
@@ -1084,7 +1084,7 @@ dxil_nir_lower_double_math_instr(nir_builder *b,
       nir_src_rewrite(&intr->src[0], nir_pack_double_2x32_dxil(b, nir_unpack_64_2x32(b, intr->src[0].ssa)));
       b->cursor = nir_after_instr(instr);
       nir_def *result = nir_pack_64_2x32(b, nir_unpack_double_2x32_dxil(b, &intr->def));
-      nir_def_rewrite_uses_after(&intr->def, result, result->parent_instr);
+      nir_def_rewrite_uses_after(&intr->def, result);
       return true;
    }
 
@@ -1132,7 +1132,7 @@ dxil_nir_lower_double_math_instr(nir_builder *b,
          components[c] = nir_pack_64_2x32(b, unpacked_double);
       }
       nir_def *repacked_dvec = nir_vec(b, components, alu->def.num_components);
-      nir_def_rewrite_uses_after(&alu->def, repacked_dvec, repacked_dvec->parent_instr);
+      nir_def_rewrite_uses_after(&alu->def, repacked_dvec);
       progress = true;
    }
 
@@ -2145,7 +2145,7 @@ lower_inclusive_to_exclusive(nir_builder *b, nir_intrinsic_instr *intr)
 
    nir_def *final_val = nir_build_alu2(b, nir_intrinsic_reduction_op(intr),
                                            &intr->def, intr->src[0].ssa);
-   nir_def_rewrite_uses_after(&intr->def, final_val, final_val->parent_instr);
+   nir_def_rewrite_uses_after(&intr->def, final_val);
 }
 
 static bool

src/microsoft/spirv_to_dxil/dxil_spirv_nir.c

@@ -688,7 +688,7 @@ lower_pntc_read(nir_builder *b, nir_intrinsic_instr *intr, void *data)
    nir_def *pntc = nir_fadd_imm(b,
                                     nir_fsub(b, nir_trim_vector(b, pos, 2), nir_trim_vector(b, point_center, 2)),
                                     0.5);
-   nir_def_rewrite_uses_after(point_center, pntc, pntc->parent_instr);
+   nir_def_rewrite_uses_after(point_center, pntc);
    return true;
 }
 

src/nouveau/compiler/nak_nir_lower_fs_inputs.c

@@ -333,7 +333,7 @@ lower_fs_input_intrin(nir_builder *b, nir_intrinsic_instr *intrin, void *data)
          nir_def *sample = nir_load_sample_id(b);
          nir_def *mask = nir_ishl(b, nir_imm_int(b, 1), sample);
          mask = nir_iand(b, &intrin->def, mask);
-         nir_def_rewrite_uses_after(&intrin->def, mask, mask->parent_instr);
+         nir_def_rewrite_uses_after(&intrin->def, mask);
 
          return true;
       } else if (ctx->fs_key && ctx->fs_key->force_sample_shading) {
@@ -344,7 +344,7 @@ lower_fs_input_intrin(nir_builder *b, nir_intrinsic_instr *intrin, void *data)
          nir_def *sample = nir_load_sample_id(b);
          nir_def *mask = load_pass_sample_mask_at(b, sample, ctx->fs_key);
          mask = nir_iand(b, &intrin->def, nir_u2u32(b, mask));
-         nir_def_rewrite_uses_after(&intrin->def, mask, mask->parent_instr);
+         nir_def_rewrite_uses_after(&intrin->def, mask);
 
          return true;
       } else {

src/nouveau/compiler/nak_nir_lower_tex.c

@@ -419,7 +419,7 @@ lower_tex(nir_builder *b, nir_tex_instr *tex, const struct nak_compiler *nak)
          res = nir_bcsel(b, img_is_null, nir_imm_int(b, 0), res);
       }
 
-      nir_def_rewrite_uses_after(&tex->def, res, res->parent_instr);
+      nir_def_rewrite_uses_after(&tex->def, res);
    }
 
    return true;
@@ -585,7 +585,7 @@ shrink_image_load(nir_builder *b, nir_intrinsic_instr *intrin,
                          nir_u2u64(b, data_w));
       }
 
-      nir_def_rewrite_uses_after(&intrin->def, data, data->parent_instr);
+      nir_def_rewrite_uses_after(&intrin->def, data);
       return true;
    }
 
@@ -630,7 +630,7 @@ shrink_image_load(nir_builder *b, nir_intrinsic_instr *intrin,
       comps[old_comps - 1] = nir_channel(b, &intrin->def, new_comps);
 
    nir_def *data = nir_vec(b, comps, old_comps);
-   nir_def_rewrite_uses_after(&intrin->def, data, data->parent_instr);
+   nir_def_rewrite_uses_after(&intrin->def, data);
    return true;
 }
 

src/nouveau/compiler/nak_nir_mark_lcssa_invariants.c

@@ -47,7 +47,7 @@ lower_block(nir_builder *b, nir_block *block)
 
       nir_def* x = nir_as_uniform(b, &phi->def);
       x->divergent = false;
-      nir_def_rewrite_uses_after(&phi->def, x, x->parent_instr);
+      nir_def_rewrite_uses_after(&phi->def, x);
 
       progress = true;
    }

src/nouveau/vulkan/nvk_nir_lower_descriptors.c

@@ -998,7 +998,7 @@ lower_edb_buffer_image_intrin(nir_builder *b, nir_intrinsic_instr *intrin,
          nir_def *res = &intrin->def;
          res = fixup_edb_buffer_view_result(b, desc, in_bounds, res,
                                             nir_intrinsic_dest_type(intrin));
-         nir_def_rewrite_uses_after(&intrin->def, res, res->parent_instr);
+         nir_def_rewrite_uses_after(&intrin->def, res);
       }
 
       nir_rewrite_image_intrinsic(intrin, index, true);
@@ -1047,7 +1047,7 @@ lower_image_intrin(nir_builder *b, nir_intrinsic_instr *intrin,
       nir_def *zero = nir_imm_zero(b, intrin->def.num_components,
                                       intrin->def.bit_size);
       nir_def *res = nir_bcsel(b, is_null, zero, &intrin->def);
-      nir_def_rewrite_uses_after(&intrin->def, res, res->parent_instr);
+      nir_def_rewrite_uses_after(&intrin->def, res);
    }
 
    return true;

src/panfrost/midgard/nir_fuse_io_16.c

@@ -82,7 +82,7 @@ nir_fuse_io_16(nir_shader *shader)
 
             /* The f2f32(f2fmp(x)) will cancel by opt_algebraic */
             nir_def *conv = nir_f2f32(&b, &intr->def);
-            nir_def_rewrite_uses_after(&intr->def, conv, conv->parent_instr);
+            nir_def_rewrite_uses_after(&intr->def, conv);
 
             progress |= true;
          }

src/panfrost/util/pan_lower_framebuffer.c

@@ -559,7 +559,7 @@ pan_lower_fb_load(nir_builder *b, nir_intrinsic_instr *intr,
    if (reorder_comps)
       unpacked = pan_unpack_reorder(b, desc, unpacked);
 
-   nir_def_rewrite_uses_after(&intr->def, unpacked, &intr->instr);
+   nir_def_rewrite_uses_after_instr(&intr->def, unpacked, &intr->instr);
 }
 
 struct inputs {

src/panfrost/util/pan_lower_noperspective.c

@@ -212,7 +212,7 @@ lower_noperspective_fs(nir_builder *b, nir_intrinsic_instr *intrin,
       fragcoord_w = nir_f2f16(b, fragcoord_w);
 
    nir_def *new_value = nir_fmul(b, &intrin->def, fragcoord_w);
-   nir_def_rewrite_uses_after(&intrin->def, new_value, new_value->parent_instr);
+   nir_def_rewrite_uses_after(&intrin->def, new_value);
 
    return true;
 }