KonstantinSeurer
/
mesa
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

nir: Make nir_ssa_def_rewrite_uses take an SSA value 

This commit replaces the new_src parameter of nir_ssa_def_rewrite_uses()
with an SSA def, removes nir_ssa_def_rewrite_uses_ssa(), and rewrites
all the users as needed.

Reviewed-by: Rhys Perry <pendingchaos02@gmail.com>
Acked-by: Alyssa Rosenzweig <alyssa@collabora.com>
Acked-By: Mike Blumenkrantz <michael.blumenkrantz@gmail.com>
Reviewed-by: Eric Anholt <eric@anholt.net>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/9383>
This commit is contained in:
Jason Ekstrand 2021-03-03 00:13:38 -06:00 committed by Marge Bot
parent 13a0ee8a51
commit 117668b811
110 changed files with 194 additions and 205 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/amd/vulkan/radv_nir_lower_ycbcr_textures.c
View File

@ -298,7 +298,7 @@ try_lower_tex_ycbcr(const struct radv_pipeline_layout *layout,
bpcs);
}
nir_ssa_def_rewrite_uses(&tex->dest.ssa, nir_src_for_ssa(result));
nir_ssa_def_rewrite_uses(&tex->dest.ssa, result);
nir_instr_remove(&tex->instr);
return true;

4
src/amd/vulkan/radv_shader.c
View File

@ -363,7 +363,7 @@ lower_intrinsics(nir_shader *nir)
}
nir_ssa_def_rewrite_uses(&intrin->dest.ssa,
nir_src_for_ssa(def));
def);
nir_instr_remove(instr);
progress = true;
@ -770,7 +770,7 @@ lower_view_index(nir_shader *nir)
b.cursor = nir_before_instr(instr);
nir_ssa_def *def = nir_load_var(&b, layer);
nir_ssa_def_rewrite_uses(&load->dest.ssa,
nir_src_for_ssa(def));
def);
nir_instr_remove(instr);
progress = true;

2
src/broadcom/compiler/v3d_nir_lower_scratch.c
View File

@ -78,7 +78,7 @@ v3d_nir_lower_load_scratch(nir_builder *b, nir_intrinsic_instr *instr)
}
nir_ssa_def *result = nir_vec(b, chans, instr->num_components);
nir_ssa_def_rewrite_uses(&instr->dest.ssa, nir_src_for_ssa(result));
nir_ssa_def_rewrite_uses(&instr->dest.ssa, result);
nir_instr_remove(&instr->instr);
}

6
src/broadcom/vulkan/v3dv_pipeline.c
View File

@ -641,7 +641,7 @@ lower_vulkan_resource_index(nir_builder *b,
* second component (unused right now) to zero.
*/
nir_ssa_def_rewrite_uses(&instr->dest.ssa,
nir_src_for_ssa(nir_imm_int(b, index)));
nir_imm_int(b, index));
nir_instr_remove(&instr->instr);
}
@ -860,7 +860,7 @@ lower_intrinsic(nir_builder *b, nir_intrinsic_instr *instr,
* lowering
*/
nir_ssa_def_rewrite_uses(&instr->dest.ssa,
nir_src_for_ssa(nir_imm_int(b, 0)));
nir_imm_int(b, 0));
nir_instr_remove(&instr->instr);
return true;
@ -879,7 +879,7 @@ lower_intrinsic(nir_builder *b, nir_intrinsic_instr *instr,
* lower the desc back to a vec2, as it is what load_ssbo/ubo expects.
*/
nir_ssa_def *desc = nir_vec2(b, instr->src[0].ssa, nir_imm_int(b, 0));
nir_ssa_def_rewrite_uses(&instr->dest.ssa, nir_src_for_ssa(desc));
nir_ssa_def_rewrite_uses(&instr->dest.ssa, desc);
nir_instr_remove(&instr->instr);
return true;
}

2
src/compiler/glsl/gl_nir_lower_buffers.c
View File

@ -220,7 +220,7 @@ lower_buffer_interface_derefs_impl(nir_function_impl *impl,
cast->cast.align_offset = offset % NIR_ALIGN_MUL_MAX;
nir_ssa_def_rewrite_uses(&deref->dest.ssa,
nir_src_for_ssa(&cast->dest.ssa));
&cast->dest.ssa);
nir_deref_instr_remove_if_unused(deref);
break;
}

10
src/compiler/nir/nir.c
View File

@ -1352,7 +1352,7 @@ nir_ssa_dest_init(nir_instr *instr, nir_dest *dest,
}
void
nir_ssa_def_rewrite_uses_ssa(nir_ssa_def *def, nir_ssa_def *new_ssa)
nir_ssa_def_rewrite_uses(nir_ssa_def *def, nir_ssa_def *new_ssa)
{
assert(def != new_ssa);
nir_foreach_use_safe(use_src, def)
@ -1362,17 +1362,11 @@ nir_ssa_def_rewrite_uses_ssa(nir_ssa_def *def, nir_ssa_def *new_ssa)
nir_if_rewrite_condition_ssa(use_src->parent_if, use_src, new_ssa);
}
void
nir_ssa_def_rewrite_uses(nir_ssa_def *def, nir_src new_src)
{
nir_ssa_def_rewrite_uses_src(def, new_src);
}
void
nir_ssa_def_rewrite_uses_src(nir_ssa_def *def, nir_src new_src)
{
if (new_src.is_ssa) {
nir_ssa_def_rewrite_uses_ssa(def, new_src.ssa);
nir_ssa_def_rewrite_uses(def, new_src.ssa);
} else {
nir_foreach_use_safe(use_src, def)
nir_instr_rewrite_src(use_src->parent_instr, use_src, new_src);

3
src/compiler/nir/nir.h
View File

@ -3945,8 +3945,7 @@ nir_ssa_dest_init_for_type(nir_instr *instr, nir_dest *dest,
nir_ssa_dest_init(instr, dest, glsl_get_components(type),
glsl_get_bit_size(type), name);
}
void nir_ssa_def_rewrite_uses(nir_ssa_def *def, nir_src new_src);
void nir_ssa_def_rewrite_uses_ssa(nir_ssa_def *def, nir_ssa_def *new_ssa);
void nir_ssa_def_rewrite_uses(nir_ssa_def *def, nir_ssa_def *new_ssa);
void nir_ssa_def_rewrite_uses_src(nir_ssa_def *def, nir_src new_src);
void nir_ssa_def_rewrite_uses_after(nir_ssa_def *def, nir_src new_src,
nir_instr *after_me);

2
src/compiler/nir/nir_control_flow.c
View File

@ -620,7 +620,7 @@ replace_ssa_def_uses(nir_ssa_def *def, void *void_impl)
nir_ssa_undef_instr_create(mem_ctx, def->num_components,
def->bit_size);
nir_instr_insert_before_cf_list(&impl->body, &undef->instr);
nir_ssa_def_rewrite_uses(def, nir_src_for_ssa(&undef->def));
nir_ssa_def_rewrite_uses(def, &undef->def);
return true;
}

8
src/compiler/nir/nir_deref.c
View File

@ -1021,7 +1021,7 @@ opt_remove_sampler_cast(nir_deref_instr *cast)
/* We're a cast from a more detailed sampler type to a bare sampler */
nir_ssa_def_rewrite_uses(&cast->dest.ssa,
nir_src_for_ssa(&parent->dest.ssa));
&parent->dest.ssa);
nir_instr_remove(&cast->instr);
/* Recursively crawl the deref tree and clean up types */
@ -1059,7 +1059,7 @@ opt_replace_struct_wrapper_cast(nir_builder *b, nir_deref_instr *cast)
return false;
nir_deref_instr *replace = nir_build_deref_struct(b, parent, 0);
nir_ssa_def_rewrite_uses(&cast->dest.ssa, nir_src_for_ssa(&replace->dest.ssa));
nir_ssa_def_rewrite_uses(&cast->dest.ssa, &replace->dest.ssa);
nir_deref_instr_remove_if_unused(cast);
return true;
}
@ -1135,7 +1135,7 @@ opt_deref_ptr_as_array(nir_builder *b, nir_deref_instr *deref)
is_trivial_deref_cast(parent))
parent = nir_deref_instr_parent(parent);
nir_ssa_def_rewrite_uses(&deref->dest.ssa,
nir_src_for_ssa(&parent->dest.ssa));
&parent->dest.ssa);
nir_instr_remove(&deref->instr);
return true;
}
@ -1320,7 +1320,7 @@ opt_known_deref_mode_is(nir_builder *b, nir_intrinsic_instr *intrin)
if (deref_is == NULL)
return false;
nir_ssa_def_rewrite_uses(&intrin->dest.ssa, nir_src_for_ssa(deref_is));
nir_ssa_def_rewrite_uses(&intrin->dest.ssa, deref_is);
nir_instr_remove(&intrin->instr);
return true;
}

4
src/compiler/nir/nir_from_ssa.c
View File

@ -404,7 +404,7 @@ isolate_phi_nodes_block(nir_block *block, void *dead_ctx)
exec_list_push_tail(&block_pcopy->entries, &entry->node);
nir_ssa_def_rewrite_uses(&phi->dest.ssa,
nir_src_for_ssa(&entry->dest.ssa));
&entry->dest.ssa);
nir_instr_rewrite_src(&block_pcopy->instr, &entry->src,
nir_src_for_ssa(&phi->dest.ssa));
@ -970,7 +970,7 @@ nir_lower_phis_to_regs_block(nir_block *block)
b.cursor = nir_after_instr(&phi->instr);
nir_ssa_def *def = nir_load_reg(&b, reg);
nir_ssa_def_rewrite_uses(&phi->dest.ssa, nir_src_for_ssa(def));
nir_ssa_def_rewrite_uses(&phi->dest.ssa, def);
nir_foreach_phi_src(src, phi) {
assert(src->src.is_ssa);

2
src/compiler/nir/nir_inline_functions.c
View File

@ -84,7 +84,7 @@ void nir_inline_function_impl(struct nir_builder *b,
assert(param_idx < impl->function->num_params);
assert(load->dest.is_ssa);
nir_ssa_def_rewrite_uses(&load->dest.ssa,
nir_src_for_ssa(params[param_idx]));
params[param_idx]);
/* Remove any left-over load_param intrinsics because they're soon
* to be in another function and therefore no longer valid.

2
src/compiler/nir/nir_inline_uniforms.c
View File

@ -186,7 +186,7 @@ nir_inline_uniforms(nir_shader *shader, unsigned num_uniforms,
if (offset == uniform_dw_offsets[i] * 4) {
b.cursor = nir_before_instr(&intr->instr);
nir_ssa_def *def = nir_imm_int(&b, uniform_values[i]);
nir_ssa_def_rewrite_uses(&intr->dest.ssa, nir_src_for_ssa(def));
nir_ssa_def_rewrite_uses(&intr->dest.ssa, def);
nir_instr_remove(&intr->instr);
break;
}

2
src/compiler/nir/nir_instr_set.c
View File

@ -821,7 +821,7 @@ nir_instr_set_add_or_rewrite(struct set *instr_set, nir_instr *instr)
if (instr->type == nir_instr_type_alu && nir_instr_as_alu(instr)->exact)
nir_instr_as_alu(match)->exact = true;
nir_ssa_def_rewrite_uses_ssa(def, new_def);
nir_ssa_def_rewrite_uses(def, new_def);
return true;
}

4
src/compiler/nir/nir_linking_helpers.c
View File

@ -945,7 +945,7 @@ replace_constant_input(nir_shader *shader, nir_intrinsic_instr *store_intr)
intr->dest.ssa.bit_size,
out_const->value);
nir_ssa_def_rewrite_uses(&intr->dest.ssa, nir_src_for_ssa(nconst));
nir_ssa_def_rewrite_uses(&intr->dest.ssa, nconst);
progress = true;
}
@ -992,7 +992,7 @@ replace_duplicate_input(nir_shader *shader, nir_variable *input_var,
b.cursor = nir_before_instr(instr);
nir_ssa_def *load = nir_load_var(&b, input_var);
nir_ssa_def_rewrite_uses(&intr->dest.ssa, nir_src_for_ssa(load));
nir_ssa_def_rewrite_uses(&intr->dest.ssa, load);
progress = true;
}

2
src/compiler/nir/nir_lower_alu.c
View File

@ -216,7 +216,7 @@ lower_alu_instr(nir_alu_instr *instr, nir_builder *b)
}
if (lowered) {
nir_ssa_def_rewrite_uses(&instr->dest.dest.ssa, nir_src_for_ssa(lowered));
nir_ssa_def_rewrite_uses(&instr->dest.dest.ssa, lowered);
nir_instr_remove(&instr->instr);
return true;
} else {

2
src/compiler/nir/nir_lower_array_deref_of_vec.c
View File

@ -151,7 +151,7 @@ nir_lower_array_deref_of_vec_impl(nir_function_impl *impl,
nir_vector_extract(&b, &intrin->dest.ssa, index);
if (scalar->parent_instr->type == nir_instr_type_ssa_undef) {
nir_ssa_def_rewrite_uses(&intrin->dest.ssa,
nir_src_for_ssa(scalar));
scalar);
nir_instr_remove(&intrin->instr);
} else {
nir_ssa_def_rewrite_uses_after(&intrin->dest.ssa,

4
src/compiler/nir/nir_lower_atomics_to_ssbo.c
View File

@ -146,9 +146,9 @@ lower_instr(nir_intrinsic_instr *instr, unsigned ssbo_offset, nir_builder *b)
if (instr->intrinsic == nir_intrinsic_atomic_counter_pre_dec) {
b->cursor = nir_after_instr(&new_instr->instr);
nir_ssa_def *result = nir_iadd(b, &new_instr->dest.ssa, temp);
nir_ssa_def_rewrite_uses(&instr->dest.ssa, nir_src_for_ssa(result));
nir_ssa_def_rewrite_uses(&instr->dest.ssa, result);
} else {
nir_ssa_def_rewrite_uses(&instr->dest.ssa, nir_src_for_ssa(&new_instr->dest.ssa));
nir_ssa_def_rewrite_uses(&instr->dest.ssa, &new_instr->dest.ssa);
}
return true;

8
src/compiler/nir/nir_lower_bit_size.c
View File

@ -89,9 +89,9 @@ lower_alu_instr(nir_builder *bld, nir_alu_instr *alu, unsigned bit_size)
dst_bit_size != bit_size) {
nir_alu_type type = nir_op_infos[op].output_type;
nir_ssa_def *dst = nir_convert_to_bit_size(bld, lowered_dst, type, dst_bit_size);
nir_ssa_def_rewrite_uses(&alu->dest.dest.ssa, nir_src_for_ssa(dst));
nir_ssa_def_rewrite_uses(&alu->dest.dest.ssa, dst);
} else {
nir_ssa_def_rewrite_uses(&alu->dest.dest.ssa, nir_src_for_ssa(lowered_dst));
nir_ssa_def_rewrite_uses(&alu->dest.dest.ssa, lowered_dst);
}
}
@ -175,7 +175,7 @@ lower_intrinsic_instr(nir_builder *b, nir_intrinsic_instr *intrin,
intrin->intrinsic != nir_intrinsic_vote_ieq)
res = nir_u2u(b, res, old_bit_size);
nir_ssa_def_rewrite_uses(&intrin->dest.ssa, nir_src_for_ssa(res));
nir_ssa_def_rewrite_uses(&intrin->dest.ssa, res);
break;
}
@ -314,7 +314,7 @@ split_phi(nir_builder *b, nir_phi_instr *phi)
b->cursor = nir_after_phis(nir_cursor_current_block(b->cursor));
nir_ssa_def *merged = nir_pack_64_2x32_split(b, &lowered[0]->dest.ssa, &lowered[1]->dest.ssa);
nir_ssa_def_rewrite_uses(&phi->dest.ssa, nir_src_for_ssa(merged));
nir_ssa_def_rewrite_uses(&phi->dest.ssa, merged);
nir_instr_remove(&phi->instr);
}

2
src/compiler/nir/nir_lower_bool_to_float.c
View File

@ -117,7 +117,7 @@ lower_alu_instr(nir_builder *b, nir_alu_instr *alu)
if (rep) {
/* We've emitted a replacement instruction */
nir_ssa_def_rewrite_uses(&alu->dest.dest.ssa, nir_src_for_ssa(rep));
nir_ssa_def_rewrite_uses(&alu->dest.dest.ssa, rep);
nir_instr_remove(&alu->instr);
} else {
if (alu->dest.dest.ssa.bit_size == 1)

2
src/compiler/nir/nir_lower_cl_images_to_tex.c
View File

@ -132,7 +132,7 @@ lower_cl_images_to_tex_impl(nir_function_impl *impl)
res = nir_channels(&b, res, (1 << num_components) - 1);
}
nir_ssa_def_rewrite_uses(&intrin->dest.ssa, nir_src_for_ssa(res));
nir_ssa_def_rewrite_uses(&intrin->dest.ssa, res);
progress = true;
}
}

2
src/compiler/nir/nir_lower_convert_alu_types.c
View File

@ -63,7 +63,7 @@ lower_convert_alu_types_instr(nir_builder *b, nir_intrinsic_instr *conv)
nir_intrinsic_dest_type(conv),
nir_intrinsic_rounding_mode(conv),
nir_intrinsic_saturate(conv));
nir_ssa_def_rewrite_uses(&conv->dest.ssa, nir_src_for_ssa(val));
nir_ssa_def_rewrite_uses(&conv->dest.ssa, val);
}
static bool

4
src/compiler/nir/nir_lower_discard_or_demote.c
View File

@ -67,7 +67,7 @@ nir_lower_demote_to_discard_instr(nir_builder *b, nir_instr *instr, void *data)
* we can assume there are none */
b->cursor = nir_before_instr(instr);
nir_ssa_def *zero = nir_imm_false(b);
nir_ssa_def_rewrite_uses_ssa(&intrin->dest.ssa, zero);
nir_ssa_def_rewrite_uses(&intrin->dest.ssa, zero);
nir_instr_remove_v(instr);
return true;
}
@ -118,7 +118,7 @@ nir_lower_load_helper_to_is_helper(nir_builder *b, nir_instr *instr, void *data)
* top-level blocks to ensure correct behavior w.r.t. loops */
if (is_helper == NULL)
is_helper = insert_is_helper(b, instr);
nir_ssa_def_rewrite_uses_ssa(&intrin->dest.ssa, is_helper);
nir_ssa_def_rewrite_uses(&intrin->dest.ssa, is_helper);
nir_instr_remove_v(instr);
return true;
default:

4
src/compiler/nir/nir_lower_drawpixels.c
View File

@ -222,7 +222,7 @@ lower_color(lower_drawpixels_state *state, nir_intrinsic_instr *intr)
nir_channel(b, def_zw, 1));
}
nir_ssa_def_rewrite_uses(&intr->dest.ssa, nir_src_for_ssa(def));
nir_ssa_def_rewrite_uses(&intr->dest.ssa, def);
}
static void
@ -231,7 +231,7 @@ lower_texcoord(lower_drawpixels_state *state, nir_intrinsic_instr *intr)
state->b.cursor = nir_before_instr(&intr->instr);
nir_ssa_def *texcoord_const = get_texcoord_const(state);
nir_ssa_def_rewrite_uses(&intr->dest.ssa, nir_src_for_ssa(texcoord_const));
nir_ssa_def_rewrite_uses(&intr->dest.ssa, texcoord_const);
}
static bool

2
src/compiler/nir/nir_lower_fb_read.c
View File

@ -69,7 +69,7 @@ lower_fb_read(nir_builder *b, nir_intrinsic_instr *intr)
nir_ssa_dest_init(&tex->instr, &tex->dest, 4, 32, NULL);
nir_builder_instr_insert(b, &tex->instr);
nir_ssa_def_rewrite_uses(&intr->dest.ssa, nir_src_for_ssa(&tex->dest.ssa));
nir_ssa_def_rewrite_uses(&intr->dest.ssa, &tex->dest.ssa);
}
bool

10
src/compiler/nir/nir_lower_flrp.c
View File

@ -60,7 +60,7 @@ replace_with_strict_ffma(struct nir_builder *bld, struct u_vector *dead_flrp,
nir_ssa_def *const outer_ffma = nir_ffma(bld, b, c, inner_ffma);
nir_instr_as_alu(outer_ffma->parent_instr)->exact = alu->exact;
nir_ssa_def_rewrite_uses(&alu->dest.dest.ssa, nir_src_for_ssa(outer_ffma));
nir_ssa_def_rewrite_uses(&alu->dest.dest.ssa, outer_ffma);
/* DO NOT REMOVE the original flrp yet. Many of the lowering choices are
* based on other uses of the sources. Removing the flrp may cause the
@ -93,7 +93,7 @@ replace_with_single_ffma(struct nir_builder *bld, struct u_vector *dead_flrp,
nir_ssa_def *const final_ffma = nir_ffma(bld, a, one_minus_c, b_times_c);
nir_instr_as_alu(final_ffma->parent_instr)->exact = alu->exact;
nir_ssa_def_rewrite_uses(&alu->dest.dest.ssa, nir_src_for_ssa(final_ffma));
nir_ssa_def_rewrite_uses(&alu->dest.dest.ssa, final_ffma);
/* DO NOT REMOVE the original flrp yet. Many of the lowering choices are
* based on other uses of the sources. Removing the flrp may cause the
@ -129,7 +129,7 @@ replace_with_strict(struct nir_builder *bld, struct u_vector *dead_flrp,
nir_ssa_def *const sum = nir_fadd(bld, first_product, second_product);
nir_instr_as_alu(sum->parent_instr)->exact = alu->exact;
nir_ssa_def_rewrite_uses(&alu->dest.dest.ssa, nir_src_for_ssa(sum));
nir_ssa_def_rewrite_uses(&alu->dest.dest.ssa, sum);
/* DO NOT REMOVE the original flrp yet. Many of the lowering choices are
* based on other uses of the sources. Removing the flrp may cause the
@ -161,7 +161,7 @@ replace_with_fast(struct nir_builder *bld, struct u_vector *dead_flrp,
nir_ssa_def *const sum = nir_fadd(bld, a, product);
nir_instr_as_alu(sum->parent_instr)->exact = alu->exact;
nir_ssa_def_rewrite_uses(&alu->dest.dest.ssa, nir_src_for_ssa(sum));
nir_ssa_def_rewrite_uses(&alu->dest.dest.ssa, sum);
/* DO NOT REMOVE the original flrp yet. Many of the lowering choices are
* based on other uses of the sources. Removing the flrp may cause the
@ -203,7 +203,7 @@ replace_with_expanded_ffma_and_add(struct nir_builder *bld,
nir_ssa_def *const outer_sum = nir_fadd(bld, inner_sum, b_times_c);
nir_instr_as_alu(outer_sum->parent_instr)->exact = alu->exact;
nir_ssa_def_rewrite_uses(&alu->dest.dest.ssa, nir_src_for_ssa(outer_sum));
nir_ssa_def_rewrite_uses(&alu->dest.dest.ssa, outer_sum);
/* DO NOT REMOVE the original flrp yet. Many of the lowering choices are
* based on other uses of the sources. Removing the flrp may cause the

2
src/compiler/nir/nir_lower_frexp.c
View File

@ -180,7 +180,7 @@ lower_frexp_impl(nir_function_impl *impl)
}
nir_ssa_def_rewrite_uses(&alu_instr->dest.dest.ssa,
nir_src_for_ssa(lower));
lower);
nir_instr_remove(instr);
progress = true;
}

4
src/compiler/nir/nir_lower_idiv.c
View File

@ -129,7 +129,7 @@ convert_instr(nir_builder *bld, nir_alu_instr *alu)
}
assert(alu->dest.dest.is_ssa);
nir_ssa_def_rewrite_uses(&alu->dest.dest.ssa, nir_src_for_ssa(q));
nir_ssa_def_rewrite_uses(&alu->dest.dest.ssa, q);
return true;
}
@ -231,7 +231,7 @@ convert_instr_precise(nir_builder *bld, nir_alu_instr *alu)
res = emit_idiv(bld, numer, denom, op);
assert(alu->dest.dest.is_ssa);
nir_ssa_def_rewrite_uses(&alu->dest.dest.ssa, nir_src_for_ssa(res));
nir_ssa_def_rewrite_uses(&alu->dest.dest.ssa, res);
return true;
}

2
src/compiler/nir/nir_lower_indirect_derefs.c
View File

@ -172,7 +172,7 @@ lower_indirect_derefs_block(nir_block *block, nir_builder *b,
nir_ssa_def *result;
emit_load_store_deref(b, intrin, base, &path.path[1],
&result, NULL);
nir_ssa_def_rewrite_uses(&intrin->dest.ssa, nir_src_for_ssa(result));
nir_ssa_def_rewrite_uses(&intrin->dest.ssa, result);
}
nir_deref_path_finish(&path);

4
src/compiler/nir/nir_lower_input_attachments.c
View File

@ -144,10 +144,10 @@ try_lower_input_load(nir_function_impl *impl, nir_intrinsic_instr *load,
nir_ssa_def *res = nir_channels(
&b, &tex->dest.ssa, load_result_mask | 0x10);
nir_ssa_def_rewrite_uses(&load->dest.ssa, nir_src_for_ssa(res));
nir_ssa_def_rewrite_uses(&load->dest.ssa, res);
} else {
nir_ssa_def_rewrite_uses(&load->dest.ssa,
nir_src_for_ssa(&tex->dest.ssa));
&tex->dest.ssa);
}
return true;

2
src/compiler/nir/nir_lower_int_to_float.c
View File

@ -108,7 +108,7 @@ lower_alu_instr(nir_builder *b, nir_alu_instr *alu)
if (rep) {
/* We've emitted a replacement instruction */
nir_ssa_def_rewrite_uses(&alu->dest.dest.ssa, nir_src_for_ssa(rep));
nir_ssa_def_rewrite_uses(&alu->dest.dest.ssa, rep);
nir_instr_remove(&alu->instr);
}

2
src/compiler/nir/nir_lower_interpolation.c
View File

@ -121,7 +121,7 @@ nir_lower_interpolation_block(nir_block *block, nir_builder *b,
comps[i] = val;
}
nir_ssa_def *vec = nir_vec(b, comps, intr->num_components);
nir_ssa_def_rewrite_uses(&intr->dest.ssa, nir_src_for_ssa(vec));
nir_ssa_def_rewrite_uses(&intr->dest.ssa, vec);
progress = true;
}

16
src/compiler/nir/nir_lower_io.c
View File

@ -652,7 +652,7 @@ nir_lower_io_block(nir_block *block,
nir_imm_zero(b, intrin->dest.ssa.num_components,
intrin->dest.ssa.bit_size);
nir_ssa_def_rewrite_uses(&intrin->dest.ssa,
nir_src_for_ssa(zero));
zero);
}
nir_instr_remove(&intrin->instr);
@ -692,7 +692,7 @@ nir_lower_io_block(nir_block *block,
if (replacement) {
nir_ssa_def_rewrite_uses(&intrin->dest.ssa,
nir_src_for_ssa(replacement));
replacement);
}
nir_instr_remove(&intrin->instr);
progress = true;
@ -1771,7 +1771,7 @@ nir_lower_explicit_io_instr(nir_builder *b,
deref->modes, align_mul, align_offset,
intrin->num_components);
}
nir_ssa_def_rewrite_uses(&intrin->dest.ssa, nir_src_for_ssa(value));
nir_ssa_def_rewrite_uses(&intrin->dest.ssa, value);
break;
}
@ -1806,7 +1806,7 @@ nir_lower_explicit_io_instr(nir_builder *b,
deref->modes,
align_mul, align_offset,
intrin->num_components);
nir_ssa_def_rewrite_uses(&intrin->dest.ssa, nir_src_for_ssa(value));
nir_ssa_def_rewrite_uses(&intrin->dest.ssa, value);
break;
}
@ -1823,7 +1823,7 @@ nir_lower_explicit_io_instr(nir_builder *b,
default: {
nir_ssa_def *value =
build_explicit_io_atomic(b, intrin, addr, addr_format, deref->modes);
nir_ssa_def_rewrite_uses(&intrin->dest.ssa, nir_src_for_ssa(value));
nir_ssa_def_rewrite_uses(&intrin->dest.ssa, value);
break;
}
}
@ -1957,7 +1957,7 @@ lower_explicit_io_deref(nir_builder *b, nir_deref_instr *deref,
assert(addr->num_components == deref->dest.ssa.num_components);
nir_instr_remove(&deref->instr);
nir_ssa_def_rewrite_uses(&deref->dest.ssa, nir_src_for_ssa(addr));
nir_ssa_def_rewrite_uses(&deref->dest.ssa, addr);
}
static void
@ -1991,7 +1991,7 @@ lower_explicit_io_array_length(nir_builder *b, nir_intrinsic_instr *intrin,
arr_size = nir_imax(b, nir_isub(b, arr_size, offset), nir_imm_int(b, 0u));
arr_size = nir_idiv(b, arr_size, nir_imm_int(b, stride));
nir_ssa_def_rewrite_uses(&intrin->dest.ssa, nir_src_for_ssa(arr_size));
nir_ssa_def_rewrite_uses(&intrin->dest.ssa, arr_size);
nir_instr_remove(&intrin->instr);
}
@ -2018,7 +2018,7 @@ lower_explicit_io_mode_check(nir_builder *b, nir_intrinsic_instr *intrin,
build_runtime_addr_mode_check(b, addr, addr_format,
nir_intrinsic_memory_modes(intrin));
nir_ssa_def_rewrite_uses(&intrin->dest.ssa, nir_src_for_ssa(is_mode));
nir_ssa_def_rewrite_uses(&intrin->dest.ssa, is_mode);
}
static bool

4
src/compiler/nir/nir_lower_io_arrays_to_elements.c
View File

@ -121,7 +121,7 @@ lower_array(nir_builder *b, nir_intrinsic_instr *intr, nir_variable *var,
nir_ssa_def *zero = nir_imm_zero(b, intr->dest.ssa.num_components,
intr->dest.ssa.bit_size);
nir_ssa_def_rewrite_uses(&intr->dest.ssa,
nir_src_for_ssa(zero));
zero);
}
nir_instr_remove(&intr->instr);
return;
@ -186,7 +186,7 @@ lower_array(nir_builder *b, nir_intrinsic_instr *intr, nir_variable *var,
}
nir_ssa_def_rewrite_uses(&intr->dest.ssa,
nir_src_for_ssa(&element_intr->dest.ssa));
&element_intr->dest.ssa);
} else {
nir_intrinsic_set_write_mask(element_intr,
nir_intrinsic_write_mask(intr));

6
src/compiler/nir/nir_lower_io_to_scalar.c
View File

@ -60,8 +60,7 @@ lower_load_input_to_scalar(nir_builder *b, nir_intrinsic_instr *intr)
}
nir_ssa_def_rewrite_uses(&intr->dest.ssa,
nir_src_for_ssa(nir_vec(b, loads,
intr->num_components)));
nir_vec(b, loads, intr->num_components));
nir_instr_remove(&intr->instr);
}
@ -231,8 +230,7 @@ lower_load_to_scalar_early(nir_builder *b, nir_intrinsic_instr *intr,
}
nir_ssa_def_rewrite_uses(&intr->dest.ssa,
nir_src_for_ssa(nir_vec(b, loads,
intr->num_components)));
nir_vec(b, loads, intr->num_components));
/* Remove the old load intrinsic */
nir_instr_remove(&intr->instr);

2
src/compiler/nir/nir_lower_io_to_temporaries.c
View File

@ -246,7 +246,7 @@ fixup_interpolation_instr(struct lower_io_state *state,
* correct part of the temporary.
*/
nir_ssa_def *load = nir_load_deref(b, nir_src_as_deref(interp->src[0]));
nir_ssa_def_rewrite_uses(&interp->dest.ssa, nir_src_for_ssa(load));
nir_ssa_def_rewrite_uses(&interp->dest.ssa, load);
nir_instr_remove(&interp->instr);
nir_deref_path_finish(&interp_path);

2
src/compiler/nir/nir_lower_load_const_to_scalar.c
View File

@ -59,7 +59,7 @@ lower_load_const_instr_scalar(nir_load_const_instr *lower)
nir_ssa_def *vec = nir_vec(&b, loads, lower->def.num_components);
/* Replace the old load with a reference to our reconstructed vector. */
nir_ssa_def_rewrite_uses(&lower->def, nir_src_for_ssa(vec));
nir_ssa_def_rewrite_uses(&lower->def, vec);
nir_instr_remove(&lower->instr);
return true;
}

2
src/compiler/nir/nir_lower_locals_to_regs.c
View File

@ -206,7 +206,7 @@ lower_locals_to_regs_block(nir_block *block,
intrin->num_components,
intrin->dest.ssa.bit_size, NULL);
nir_ssa_def_rewrite_uses(&intrin->dest.ssa,
nir_src_for_ssa(&mov->dest.dest.ssa));
&mov->dest.dest.ssa);
} else {
nir_dest_copy(&mov->dest.dest, &intrin->dest, &mov->instr);
}

2
src/compiler/nir/nir_lower_multiview.c
View File

@ -306,7 +306,7 @@ nir_lower_multiview(nir_shader *shader, uint32_t view_mask)
switch (intrin->intrinsic) {
case nir_intrinsic_load_view_index: {
assert(intrin->dest.is_ssa);
nir_ssa_def_rewrite_uses(&intrin->dest.ssa, nir_src_for_ssa(view_index));
nir_ssa_def_rewrite_uses(&intrin->dest.ssa, view_index);
break;
}

2
src/compiler/nir/nir_lower_packing.c
View File

@ -136,7 +136,7 @@ lower_pack_impl(nir_function_impl *impl)
unreachable("Impossible opcode");
}
nir_ssa_def_rewrite_uses(&alu_instr->dest.dest.ssa, nir_src_for_ssa(dest));
nir_ssa_def_rewrite_uses(&alu_instr->dest.dest.ssa, dest);
nir_instr_remove(&alu_instr->instr);
progress = true;
}

2
src/compiler/nir/nir_lower_patch_vertices.c
View File

@ -92,7 +92,7 @@ nir_lower_patch_vertices(nir_shader *nir,
progress = true;
nir_ssa_def_rewrite_uses(&intr->dest.ssa,
nir_src_for_ssa(val));
val);
nir_instr_remove(instr);
}
}

2
src/compiler/nir/nir_lower_phis_to_scalar.c
View File

@ -256,7 +256,7 @@ lower_phis_to_scalar_block(nir_block *block,
nir_instr_insert_after(&last_phi->instr, &vec->instr);
nir_ssa_def_rewrite_uses(&phi->dest.ssa,
nir_src_for_ssa(&vec->dest.dest.ssa));
&vec->dest.dest.ssa);
ralloc_steal(state->dead_ctx, phi);
nir_instr_remove(&phi->instr);

2
src/compiler/nir/nir_lower_printf.c
View File

@ -128,7 +128,7 @@ lower_printf_instr(nir_builder *b, nir_instr *instr, void *_options)
nir_pop_if(b, NULL);
nir_ssa_def *ret_val = nir_if_phi(b, printf_succ_val, printf_fail_val);
nir_ssa_def_rewrite_uses(&prntf->dest.ssa, nir_src_for_ssa(ret_val));
nir_ssa_def_rewrite_uses(&prntf->dest.ssa, ret_val);
nir_instr_remove(&prntf->instr);
return true;

3
src/compiler/nir/nir_lower_scratch.c
View File

@ -58,8 +58,7 @@ lower_load_store(nir_builder *b,
if (bit_size == 1)
value = nir_b2b1(b, value);
nir_ssa_def_rewrite_uses(&intrin->dest.ssa,
nir_src_for_ssa(value));
nir_ssa_def_rewrite_uses(&intrin->dest.ssa, value);
} else {
assert(intrin->intrinsic == nir_intrinsic_store_deref);

2
src/compiler/nir/nir_lower_ssbo.c
View File

@ -206,7 +206,7 @@ nir_lower_ssbo(nir_shader *shader)
if (replace) {
nir_ssa_def_rewrite_uses(&intr->dest.ssa,
nir_src_for_ssa(replace));
replace);
}
nir_instr_remove(instr);

8
src/compiler/nir/nir_lower_tex.c
View File

@ -337,7 +337,7 @@ convert_yuv_to_rgb(nir_builder *b, nir_tex_instr *tex,
nir_ssa_def *result =
nir_ffma(b, y, m0, nir_ffma(b, u, m1, nir_ffma(b, v, m2, offset)));
nir_ssa_def_rewrite_uses(&tex->dest.ssa, nir_src_for_ssa(result));
nir_ssa_def_rewrite_uses(&tex->dest.ssa, result);
}
static void
@ -717,7 +717,7 @@ lower_tex_to_txd(nir_builder *b, nir_tex_instr *tex)
nir_ssa_dest_init(&txd->instr, &txd->dest, nir_dest_num_components(tex->dest),
nir_dest_bit_size(tex->dest), NULL);
nir_builder_instr_insert(b, &txd->instr);
nir_ssa_def_rewrite_uses(&tex->dest.ssa, nir_src_for_ssa(&txd->dest.ssa));
nir_ssa_def_rewrite_uses(&tex->dest.ssa, &txd->dest.ssa);
nir_instr_remove(&tex->instr);
return txd;
}
@ -754,7 +754,7 @@ lower_txb_to_txl(nir_builder *b, nir_tex_instr *tex)
nir_ssa_dest_init(&txl->instr, &txl->dest, nir_dest_num_components(tex->dest),
nir_dest_bit_size(tex->dest), NULL);
nir_builder_instr_insert(b, &txl->instr);
nir_ssa_def_rewrite_uses(&tex->dest.ssa, nir_src_for_ssa(&txl->dest.ssa));
nir_ssa_def_rewrite_uses(&tex->dest.ssa, &txl->dest.ssa);
nir_instr_remove(&tex->instr);
return txl;
}
@ -1052,7 +1052,7 @@ lower_tg4_offsets(nir_builder *b, nir_tex_instr *tex)
}
nir_ssa_def *res = nir_vec(b, dest, tex->dest.ssa.num_components);
nir_ssa_def_rewrite_uses(&tex->dest.ssa, nir_src_for_ssa(res));
nir_ssa_def_rewrite_uses(&tex->dest.ssa, res);
nir_instr_remove(&tex->instr);
return true;

2
src/compiler/nir/nir_lower_two_sided_color.c
View File

@ -191,7 +191,7 @@ nir_lower_two_sided_color_block(nir_block *block,
nir_ssa_def *color = nir_bcsel(b, face, front, back);
assert(intr->dest.is_ssa);
nir_ssa_def_rewrite_uses(&intr->dest.ssa, nir_src_for_ssa(color));
nir_ssa_def_rewrite_uses(&intr->dest.ssa, color);
}
return true;

2
src/compiler/nir/nir_lower_undef_to_zero.c
View File

@ -50,7 +50,7 @@ lower_undef_instr_to_zero(nir_builder *b, nir_instr *instr, UNUSED void *_state)
b->cursor = nir_instr_remove(&und->instr);
nir_ssa_def *zero = nir_imm_zero(b, und->def.num_components,
und->def.bit_size);
nir_ssa_def_rewrite_uses(&und->def, nir_src_for_ssa(zero));
nir_ssa_def_rewrite_uses(&und->def, zero);
return true;
}

2
src/compiler/nir/nir_lower_uniforms_to_ubo.c
View File

@ -91,7 +91,7 @@ lower_instr(nir_intrinsic_instr *instr, nir_builder *b, int multiplier)
load->num_components, instr->dest.ssa.bit_size,
instr->dest.ssa.name);
nir_builder_instr_insert(b, &load->instr);
nir_ssa_def_rewrite_uses(&instr->dest.ssa, nir_src_for_ssa(&load->dest.ssa));
nir_ssa_def_rewrite_uses(&instr->dest.ssa, &load->dest.ssa);
nir_intrinsic_set_range_base(load, nir_intrinsic_base(instr) * multiplier);
nir_intrinsic_set_range(load, nir_intrinsic_range(instr) * multiplier);

4
src/compiler/nir/nir_lower_vars_to_ssa.c
View File

@ -577,7 +577,7 @@ rename_variables(struct lower_variables_state *state)
nir_instr_remove(&intrin->instr);
nir_ssa_def_rewrite_uses(&intrin->dest.ssa,
nir_src_for_ssa(&undef->def));
&undef->def);
continue;
}
@ -602,7 +602,7 @@ rename_variables(struct lower_variables_state *state)
nir_instr_remove(&intrin->instr);
nir_ssa_def_rewrite_uses(&intrin->dest.ssa,
nir_src_for_ssa(&mov->dest.dest.ssa));
&mov->dest.dest.ssa);
break;
}

4
src/compiler/nir/nir_opt_comparison_pre.c
View File

@ -193,9 +193,9 @@ rewrite_compare_instruction(nir_builder *bld, nir_alu_instr *orig_cmp,
nir_builder_instr_insert(bld, &mov_cmp->instr);
nir_ssa_def_rewrite_uses(&orig_cmp->dest.dest.ssa,
nir_src_for_ssa(&mov_cmp->dest.dest.ssa));
&mov_cmp->dest.dest.ssa);
nir_ssa_def_rewrite_uses(&orig_add->dest.dest.ssa,
nir_src_for_ssa(&mov_add->dest.dest.ssa));
&mov_add->dest.dest.ssa);
/* We know these have no more uses because we just rewrote them all, so we
* can remove them.

10
src/compiler/nir/nir_opt_constant_folding.c
View File

@ -103,7 +103,7 @@ try_fold_alu(nir_builder *b, nir_alu_instr *alu)
nir_ssa_def *imm = nir_build_imm(b, alu->dest.dest.ssa.num_components,
alu->dest.dest.ssa.bit_size,
dest);
nir_ssa_def_rewrite_uses(&alu->dest.dest.ssa, nir_src_for_ssa(imm));
nir_ssa_def_rewrite_uses(&alu->dest.dest.ssa, imm);
nir_instr_remove(&alu->instr);
ralloc_free(alu);
@ -220,7 +220,7 @@ try_fold_intrinsic(nir_builder *b, nir_intrinsic_instr *intrin,
b->cursor = nir_before_instr(&intrin->instr);
nir_ssa_def *val = nir_build_imm(b, intrin->dest.ssa.num_components,
intrin->dest.ssa.bit_size, v);
nir_ssa_def_rewrite_uses(&intrin->dest.ssa, nir_src_for_ssa(val));
nir_ssa_def_rewrite_uses(&intrin->dest.ssa, val);
nir_instr_remove(&intrin->instr);
return true;
}
@ -259,7 +259,7 @@ try_fold_intrinsic(nir_builder *b, nir_intrinsic_instr *intrin,
val = nir_build_imm(b, intrin->dest.ssa.num_components,
intrin->dest.ssa.bit_size, imm);
}
nir_ssa_def_rewrite_uses(&intrin->dest.ssa, nir_src_for_ssa(val));
nir_ssa_def_rewrite_uses(&intrin->dest.ssa, val);
nir_instr_remove(&intrin->instr);
return true;
}
@ -284,7 +284,7 @@ try_fold_intrinsic(nir_builder *b, nir_intrinsic_instr *intrin,
*/
if (nir_src_is_const(intrin->src[0])) {
nir_ssa_def_rewrite_uses(&intrin->dest.ssa,
nir_src_for_ssa(intrin->src[0].ssa));
intrin->src[0].ssa);
nir_instr_remove(&intrin->instr);
return true;
}
@ -295,7 +295,7 @@ try_fold_intrinsic(nir_builder *b, nir_intrinsic_instr *intrin,
if (nir_src_is_const(intrin->src[0])) {
b->cursor = nir_before_instr(&intrin->instr);
nir_ssa_def_rewrite_uses(&intrin->dest.ssa,
nir_src_for_ssa(nir_imm_true(b)));
nir_imm_true(b));
nir_instr_remove(&intrin->instr);
return true;
}

4
src/compiler/nir/nir_opt_copy_prop_vars.c
View File

@ -939,7 +939,7 @@ copy_prop_vars_block(struct copy_prop_var_state *state,
if (vec_index >= vec_comps) {
b->cursor = nir_instr_remove(instr);
nir_ssa_def *u = nir_ssa_undef(b, 1, intrin->dest.ssa.bit_size);
nir_ssa_def_rewrite_uses(&intrin->dest.ssa, nir_src_for_ssa(u));
nir_ssa_def_rewrite_uses(&intrin->dest.ssa, u);
state->progress = true;
break;
}
@ -968,7 +968,7 @@ copy_prop_vars_block(struct copy_prop_var_state *state,
value.ssa.def[0]->parent_instr);
} else {
nir_ssa_def_rewrite_uses(&intrin->dest.ssa,
nir_src_for_ssa(value.ssa.def[0]));
value.ssa.def[0]);
}
} else {
/* We're turning it into a load of a different variable */

2
src/compiler/nir/nir_opt_copy_propagate.c
View File

@ -93,7 +93,7 @@ rewrite_to_vec(nir_function_impl *impl, nir_alu_instr *mov, nir_alu_instr *vec)
new_vec->src[i] = vec->src[mov->src[0].swizzle[i]];
nir_ssa_def *new = nir_builder_alu_instr_finish_and_insert(&b, new_vec);
nir_ssa_def_rewrite_uses_ssa(&mov->dest.dest.ssa, new);
nir_ssa_def_rewrite_uses(&mov->dest.dest.ssa, new);
/* If we remove "mov" and it's the next instruction in the
* nir_foreach_instr_safe() loop, then we would end copy-propagation early. */

2
src/compiler/nir/nir_opt_dead_cf.c
View File

@ -106,7 +106,7 @@ opt_constant_if(nir_if *if_stmt, bool condition)
assert(def);
assert(phi->dest.is_ssa);
nir_ssa_def_rewrite_uses(&phi->dest.ssa, nir_src_for_ssa(def));
nir_ssa_def_rewrite_uses(&phi->dest.ssa, def);
nir_instr_remove(instr);
}

2
src/compiler/nir/nir_opt_gcm.c
View File

@ -516,7 +516,7 @@ gcm_replace_def_with_undef(nir_ssa_def *def, void *void_state)
nir_ssa_undef_instr_create(state->impl->function->shader,
def->num_components, def->bit_size);
nir_instr_insert(nir_before_cf_list(&state->impl->body), &undef->instr);
nir_ssa_def_rewrite_uses(def, nir_src_for_ssa(&undef->def));
nir_ssa_def_rewrite_uses(def, &undef->def);
return true;
}

2
src/compiler/nir/nir_opt_idiv_const.c
View File

@ -145,7 +145,7 @@ nir_opt_idiv_const_instr(nir_builder *b, nir_alu_instr *alu)
}
nir_ssa_def *qvec = nir_vec(b, q, alu->dest.dest.ssa.num_components);
nir_ssa_def_rewrite_uses(&alu->dest.dest.ssa, nir_src_for_ssa(qvec));
nir_ssa_def_rewrite_uses(&alu->dest.dest.ssa, qvec);
nir_instr_remove(&alu->instr);
return true;

4
src/compiler/nir/nir_opt_if.c
View File

@ -541,7 +541,7 @@ opt_split_alu_of_phi(nir_builder *b, nir_loop *loop)
* result of the phi.
*/
nir_ssa_def_rewrite_uses(&alu->dest.dest.ssa,
nir_src_for_ssa(&phi->dest.ssa));
&phi->dest.ssa);
/* Since the original ALU instruction no longer has any readers, just
* remove it.
@ -714,7 +714,7 @@ opt_simplify_bcsel_of_phi(nir_builder *b, nir_loop *loop)
* the phi.
*/
nir_ssa_def_rewrite_uses(&bcsel->dest.dest.ssa,
nir_src_for_ssa(&phi->dest.ssa));
&phi->dest.ssa);
/* Since the original bcsel instruction no longer has any readers,
* just remove it.

4
src/compiler/nir/nir_opt_intrinsics.c
View File

@ -107,7 +107,7 @@ opt_intrinsics_alu(nir_builder *b, nir_alu_instr *alu,
if (replacement) {
nir_ssa_def_rewrite_uses(&alu->dest.dest.ssa,
nir_src_for_ssa(replacement));
replacement);
nir_instr_remove(&alu->instr);
return true;
} else {
@ -149,7 +149,7 @@ opt_intrinsics_intrin(nir_builder *b, nir_intrinsic_instr *intrin,
new_expr = nir_inot(b, new_expr);
nir_ssa_def_rewrite_uses(&alu->dest.dest.ssa,
nir_src_for_ssa(new_expr));
new_expr);
nir_instr_remove(&alu->instr);
progress = true;
}

2
src/compiler/nir/nir_opt_large_constants.c
View File

@ -363,7 +363,7 @@ nir_opt_large_constants(nir_shader *shader,
b.cursor = nir_after_instr(&intrin->instr);
nir_ssa_def *val = build_constant_load(&b, deref, size_align);
nir_ssa_def_rewrite_uses(&intrin->dest.ssa,
nir_src_for_ssa(val));
val);
nir_instr_remove(&intrin->instr);
nir_deref_instr_remove_if_unused(deref);
}

4
src/compiler/nir/nir_opt_load_store_vectorize.c
View File

@ -734,9 +734,9 @@ vectorize_loads(nir_builder *b, struct vectorize_ctx *ctx,
if (first == low) {
nir_ssa_def_rewrite_uses_after(&low->intrin->dest.ssa, nir_src_for_ssa(low_def),
high_def->parent_instr);
nir_ssa_def_rewrite_uses(&high->intrin->dest.ssa, nir_src_for_ssa(high_def));
nir_ssa_def_rewrite_uses(&high->intrin->dest.ssa, high_def);
} else {
nir_ssa_def_rewrite_uses(&low->intrin->dest.ssa, nir_src_for_ssa(low_def));
nir_ssa_def_rewrite_uses(&low->intrin->dest.ssa, low_def);
nir_ssa_def_rewrite_uses_after(&high->intrin->dest.ssa, nir_src_for_ssa(high_def),
high_def->parent_instr);
}

2
src/compiler/nir/nir_opt_loop_unroll.c
View File

@ -654,7 +654,7 @@ remove_out_of_bounds_induction_use(nir_shader *shader, nir_loop *loop,
nir_ssa_undef(&b, intrin->dest.ssa.num_components,
intrin->dest.ssa.bit_size);
nir_ssa_def_rewrite_uses(&intrin->dest.ssa,
nir_src_for_ssa(undef));
undef);
} else {
nir_instr_remove(instr);
continue;

2
src/compiler/nir/nir_opt_peephole_select.c
View File

@ -437,7 +437,7 @@ nir_opt_peephole_select_block(nir_block *block, nir_shader *shader,
sel->dest.write_mask = (1 << phi->dest.ssa.num_components) - 1;
nir_ssa_def_rewrite_uses(&phi->dest.ssa,
nir_src_for_ssa(&sel->dest.dest.ssa));
&sel->dest.dest.ssa);
nir_instr_insert_before(&phi->instr, &sel->instr);
nir_instr_remove(&phi->instr);

2
src/compiler/nir/nir_opt_remove_phis.c
View File

@ -132,7 +132,7 @@ remove_phis_block(nir_block *block, nir_builder *b)
}
assert(phi->dest.is_ssa);
nir_ssa_def_rewrite_uses(&phi->dest.ssa, nir_src_for_ssa(def));
nir_ssa_def_rewrite_uses(&phi->dest.ssa, def);
nir_instr_remove(instr);
progress = true;

2
src/compiler/nir/nir_opt_shrink_vectors.c
View File

@ -95,7 +95,7 @@ opt_shrink_vectors_alu(nir_builder *b, nir_alu_instr *instr)
srcs[i] = nir_ssa_for_alu_src(b, instr, i);
nir_ssa_def *new_vec = nir_vec(b, srcs, last_bit);
nir_ssa_def_rewrite_uses(def, nir_src_for_ssa(new_vec));
nir_ssa_def_rewrite_uses(def, new_vec);
return true;
}
break;

2
src/compiler/nir/nir_opt_undef.c
View File

@ -91,7 +91,7 @@ opt_undef_vecN(nir_builder *b, nir_alu_instr *alu)
b->cursor = nir_before_instr(&alu->instr);
nir_ssa_def *undef = nir_ssa_undef(b, alu->dest.dest.ssa.num_components,
nir_dest_bit_size(alu->dest.dest));
nir_ssa_def_rewrite_uses(&alu->dest.dest.ssa, nir_src_for_ssa(undef));
nir_ssa_def_rewrite_uses(&alu->dest.dest.ssa, undef);
return true;
}

2
src/compiler/nir/nir_opt_uniform_atomics.c
View File

@ -261,7 +261,7 @@ optimize_and_rewrite_atomic(nir_builder *b, nir_intrinsic_instr *intrin)
if (result) {
assert(result->divergent == original_result_divergent);
nir_ssa_def_rewrite_uses(&old_result, nir_src_for_ssa(result));
nir_ssa_def_rewrite_uses(&old_result, result);
}
}

2
src/compiler/nir/nir_search.c
View File

@ -793,7 +793,7 @@ nir_replace_instr(nir_builder *build, nir_alu_instr *instr,
/* Rewrite the uses of the old SSA value to the new one, and recurse
* through the uses updating the automaton's state.
*/
nir_ssa_def_rewrite_uses_ssa(&instr->dest.dest.ssa, ssa_val);
nir_ssa_def_rewrite_uses(&instr->dest.dest.ssa, ssa_val);
nir_algebraic_update_automaton(ssa_val->parent_instr, algebraic_worklist,
states, pass_op_table);

2
src/compiler/nir/nir_split_per_member_structs.c
View File

@ -145,7 +145,7 @@ rewrite_deref_instr(nir_builder *b, nir_deref_instr *deref,
nir_deref_instr *member_deref =
build_member_deref(b, nir_deref_instr_parent(deref), member);
nir_ssa_def_rewrite_uses(&deref->dest.ssa,
nir_src_for_ssa(&member_deref->dest.ssa));
&member_deref->dest.ssa);
/* The referenced variable is no longer valid, clean up the deref */
nir_deref_instr_remove_if_unused(deref);

6
src/compiler/nir/nir_split_vars.c
View File

@ -291,7 +291,7 @@ split_struct_derefs_impl(nir_function_impl *impl,
assert(new_deref->type == deref->type);
nir_ssa_def_rewrite_uses(&deref->dest.ssa,
nir_src_for_ssa(&new_deref->dest.ssa));
&new_deref->dest.ssa);
nir_deref_instr_remove_if_unused(deref);
}
}
@ -820,7 +820,7 @@ split_array_access_impl(nir_function_impl *impl,
nir_ssa_undef(&b, intrin->dest.ssa.num_components,
intrin->dest.ssa.bit_size);
nir_ssa_def_rewrite_uses(&intrin->dest.ssa,
nir_src_for_ssa(u));
u);
}
nir_instr_remove(&intrin->instr);
for (unsigned i = 0; i < num_derefs; i++)
@ -1549,7 +1549,7 @@ shrink_vec_var_access_impl(nir_function_impl *impl,
nir_ssa_undef(&b, intrin->dest.ssa.num_components,
intrin->dest.ssa.bit_size);
nir_ssa_def_rewrite_uses(&intrin->dest.ssa,
nir_src_for_ssa(u));
u);
}
nir_instr_remove(&intrin->instr);
nir_deref_instr_remove_if_unused(deref);

2
src/freedreno/ir3/ir3_nir.c
View File

@ -411,7 +411,7 @@ ir3_nir_lower_view_layer_id(nir_shader *nir, bool layer_zero, bool view_zero)
b.cursor = nir_before_instr(&intrin->instr);
nir_ssa_def *zero = nir_imm_int(&b, 0);
nir_ssa_def_rewrite_uses(&intrin->dest.ssa,
nir_src_for_ssa(zero));
zero);
nir_instr_remove(&intrin->instr);
progress = true;
}

2
src/freedreno/ir3/ir3_nir_analyze_ubo_ranges.c
View File

@ -333,7 +333,7 @@ lower_ubo_load_to_uniform(nir_intrinsic_instr *instr, nir_builder *b,
nir_load_uniform(b, instr->num_components, instr->dest.ssa.bit_size, uniform_offset, .base = const_offset);
nir_ssa_def_rewrite_uses(&instr->dest.ssa,
nir_src_for_ssa(uniform));
uniform);
nir_instr_remove(&instr->instr);

2
src/freedreno/ir3/ir3_nir_lower_io_offsets.c
View File

@ -244,7 +244,7 @@ lower_offset_for_ssbo(nir_intrinsic_instr *intrinsic, nir_builder *b,
* of the new intrinsic.
*/
nir_ssa_def_rewrite_uses(&intrinsic->dest.ssa,
nir_src_for_ssa(new_dest));
new_dest);
}
/* Finally remove the original intrinsic. */

4
src/freedreno/ir3/ir3_nir_lower_tess.c
View File

@ -164,7 +164,7 @@ replace_intrinsic(nir_builder *b, nir_intrinsic_instr *intr,
nir_builder_instr_insert(b, &new_intr->instr);
if (nir_intrinsic_infos[op].has_dest)
nir_ssa_def_rewrite_uses(&intr->dest.ssa, nir_src_for_ssa(&new_intr->dest.ssa));
nir_ssa_def_rewrite_uses(&intr->dest.ssa, &new_intr->dest.ssa);
nir_instr_remove(&intr->instr);
@ -330,7 +330,7 @@ lower_block_to_explicit_input(nir_block *block, nir_builder *b, struct state *st
b->cursor = nir_before_instr(&intr->instr);
nir_ssa_def *iid = build_invocation_id(b, state);
nir_ssa_def_rewrite_uses(&intr->dest.ssa, nir_src_for_ssa(iid));
nir_ssa_def_rewrite_uses(&intr->dest.ssa, iid);
nir_instr_remove(&intr->instr);
break;
}

6
src/freedreno/vulkan/tu_shader.c
View File

@ -198,7 +198,7 @@ lower_load_push_constant(nir_builder *b, nir_intrinsic_instr *instr,
nir_ushr(b, instr->src[0].ssa, nir_imm_int(b, 2)),
.base = base / 4);
nir_ssa_def_rewrite_uses(&instr->dest.ssa, nir_src_for_ssa(load));
nir_ssa_def_rewrite_uses(&instr->dest.ssa, load);
nir_instr_remove(&instr->instr);
}
@ -235,7 +235,7 @@ lower_vulkan_resource_index(nir_builder *b, nir_intrinsic_instr *instr,
nir_iadd(b, nir_imm_int(b, base), vulkan_idx),
nir_imm_int(b, 0));
nir_ssa_def_rewrite_uses(&instr->dest.ssa, nir_src_for_ssa(def));
nir_ssa_def_rewrite_uses(&instr->dest.ssa, def);
nir_instr_remove(&instr->instr);
}
@ -319,7 +319,7 @@ lower_ssbo_ubo_intrinsic(nir_builder *b, nir_intrinsic_instr *intrin)
}
if (info->has_dest)
nir_ssa_def_rewrite_uses(&intrin->dest.ssa, nir_src_for_ssa(result));
nir_ssa_def_rewrite_uses(&intrin->dest.ssa, result);
nir_instr_remove(&intrin->instr);
}

4
src/gallium/auxiliary/nir/nir_to_tgsi.c
View File

@ -2522,7 +2522,7 @@ nir_to_tgsi_lower_64bit_intrinsic(nir_builder *b, nir_intrinsic_instr *instr)
second->num_components > 1 ? nir_channel(b, &second->dest.ssa, 1) : NULL,
};
nir_ssa_def *new = nir_vec(b, channels, instr->num_components);
nir_ssa_def_rewrite_uses(&instr->dest.ssa, nir_src_for_ssa(new));
nir_ssa_def_rewrite_uses(&instr->dest.ssa, new);
} else {
/* Split the src value across the two stores. */
b->cursor = nir_before_instr(&instr->instr);
@ -2614,7 +2614,7 @@ nir_to_tgsi_lower_64bit_load_const(nir_builder *b, nir_load_const_instr *instr)
num_components == 4 ? nir_channel(b, &second->def, 1) : NULL,
};
nir_ssa_def *new = nir_vec(b, channels, num_components);
nir_ssa_def_rewrite_uses(&instr->def, nir_src_for_ssa(new));
nir_ssa_def_rewrite_uses(&instr->def, new);
nir_instr_remove(&instr->instr);
return true;

6
src/gallium/drivers/d3d12/d3d12_nir_passes.c
View File

@ -129,7 +129,7 @@ lower_load_face(nir_builder *b, struct nir_instr *instr, nir_variable *var)
nir_ssa_def *load = nir_load_var(b, var);
nir_ssa_def_rewrite_uses(&intr->dest.ssa, nir_src_for_ssa(load));
nir_ssa_def_rewrite_uses(&intr->dest.ssa, load);
nir_instr_remove(instr);
}
@ -295,7 +295,7 @@ lower_load_first_vertex(nir_builder *b, nir_instr *instr, nir_variable **first_v
nir_ssa_def *load = get_state_var(b, D3D12_STATE_VAR_FIRST_VERTEX, "d3d12_FirstVertex",
glsl_uint_type(), first_vertex);
nir_ssa_def_rewrite_uses(&intr->dest.ssa, nir_src_for_ssa(load));
nir_ssa_def_rewrite_uses(&intr->dest.ssa, load);
nir_instr_remove(instr);
return true;
@ -447,7 +447,7 @@ lower_instr(nir_intrinsic_instr *instr, nir_builder *b,
.range = ~0,
);
nir_ssa_def_rewrite_uses(&instr->dest.ssa, nir_src_for_ssa(load));
nir_ssa_def_rewrite_uses(&instr->dest.ssa, load);
/* Remove the old load_* instruction and any parent derefs */
nir_instr_remove(&instr->instr);

4
src/gallium/drivers/etnaviv/etnaviv_compiler_nir.c
View File

@ -824,7 +824,7 @@ lower_alu(struct etna_compile *c, nir_alu_instr *alu)
nir_ssa_def *def = nir_build_imm(&b, num_components, 32, value);
if (num_components == info->num_inputs) {
nir_ssa_def_rewrite_uses(&alu->dest.dest.ssa, nir_src_for_ssa(def));
nir_ssa_def_rewrite_uses(&alu->dest.dest.ssa, def);
nir_instr_remove(&alu->instr);
return;
}
@ -927,7 +927,7 @@ emit_shader(struct etna_compile *c, unsigned *num_temps, unsigned *num_consts)
b.cursor = nir_after_instr(instr);
nir_ssa_def *def = nir_build_imm(&b, intr->dest.ssa.num_components, 32, value);
nir_ssa_def_rewrite_uses(&intr->dest.ssa, nir_src_for_ssa(def));
nir_ssa_def_rewrite_uses(&intr->dest.ssa, def);
nir_instr_remove(instr);
} break;
default:

2
src/gallium/drivers/etnaviv/etnaviv_nir_lower_ubo_to_uniform.c
View File

@ -69,7 +69,7 @@ lower_ubo_to_uniform(nir_builder *b, nir_instr *instr, void *_data)
.range = nir_intrinsic_range(intr) / 16,
.dest_type = nir_type_float32);
nir_ssa_def_rewrite_uses(&intr->dest.ssa, nir_src_for_ssa(uniform));
nir_ssa_def_rewrite_uses(&intr->dest.ssa, uniform);
return uniform;
}

4
src/gallium/drivers/iris/iris_program.c
View File

@ -451,7 +451,7 @@ iris_setup_uniforms(const struct brw_compiler *compiler,
intrin->dest.ssa.bit_size);
nir_ssa_def_rewrite_uses(&intrin->dest.ssa,
nir_src_for_ssa(data));
data);
continue;
}
case nir_intrinsic_load_user_clip_plane: {
@ -574,7 +574,7 @@ iris_setup_uniforms(const struct brw_compiler *compiler,
.range = ~0);
nir_ssa_def_rewrite_uses(&intrin->dest.ssa,
nir_src_for_ssa(load));
load);
nir_instr_remove(instr);
}
}

3
src/gallium/drivers/lima/ir/lima_nir_lower_uniform_to_scalar.c
View File

@ -52,8 +52,7 @@ lower_load_uniform_to_scalar(nir_builder *b, nir_intrinsic_instr *intr)
}
nir_ssa_def_rewrite_uses(&intr->dest.ssa,
nir_src_for_ssa(nir_vec(b, loads,
intr->num_components)));
nir_vec(b, loads, intr->num_components));
nir_instr_remove(&intr->instr);
}

2
src/gallium/drivers/lima/ir/lima_nir_split_load_input.c
View File

@ -85,7 +85,7 @@ lima_nir_split_load_input_block(nir_block *block, nir_builder *b)
nir_builder_instr_insert(b, &new_intrin->instr);
nir_ssa_def_rewrite_uses(&alu->dest.dest.ssa,
nir_src_for_ssa(&new_intrin->dest.ssa));
&new_intrin->dest.ssa);
nir_instr_remove(&alu->instr);
progress = true;
}

2
src/gallium/drivers/r600/sfn/sfn_nir.cpp
View File

@ -695,7 +695,7 @@ r600_lower_shared_io_impl(nir_function *func)
load->src[0] = nir_src_for_ssa(addr);
nir_ssa_dest_init(&load->instr, &load->dest,
load->num_components, 32, NULL);
nir_ssa_def_rewrite_uses(&op->dest.ssa, nir_src_for_ssa(&load->dest.ssa));
nir_ssa_def_rewrite_uses(&op->dest.ssa, &load->dest.ssa);
nir_builder_instr_insert(&b, &load->instr);
} else {
nir_ssa_def *addr = op->src[1].ssa;

6
src/gallium/drivers/r600/sfn/sfn_nir_lower_tess_io.cpp
View File

@ -221,7 +221,7 @@ static void replace_load_instr(nir_builder *b, nir_intrinsic_instr *op, nir_ssa_
}
}
auto new_load_remixed = nir_vec(b, remix, comps);
nir_ssa_def_rewrite_uses(&op->dest.ssa, nir_src_for_ssa(new_load_remixed));
nir_ssa_def_rewrite_uses(&op->dest.ssa, new_load_remixed);
}
nir_instr_remove(&op->instr);
}
@ -317,7 +317,7 @@ r600_lower_tess_io_impl(nir_builder *b, nir_instr *instr, enum pipe_prim_type pr
auto base = emit_load_param_base(b, nir_intrinsic_load_tcs_in_param_base_r600);
vertices_in = nir_channel(b, base, 2);
}
nir_ssa_def_rewrite_uses(&op->dest.ssa, nir_src_for_ssa(vertices_in));
nir_ssa_def_rewrite_uses(&op->dest.ssa, vertices_in);
nir_instr_remove(&op->instr);
return true;
}
@ -384,7 +384,7 @@ r600_lower_tess_io_impl(nir_builder *b, nir_instr *instr, enum pipe_prim_type pr
tf->num_components, 32, NULL);
nir_builder_instr_insert(b, &tf->instr);
nir_ssa_def_rewrite_uses(&op->dest.ssa, nir_src_for_ssa(&tf->dest.ssa));
nir_ssa_def_rewrite_uses(&op->dest.ssa, &tf->dest.ssa);
nir_instr_remove(instr);
return true;
}

2
src/gallium/drivers/r600/sfn/sfn_nir_vectorize_vs_inputs.c
View File

@ -166,7 +166,7 @@ r600_create_new_load(nir_builder *b, nir_intrinsic_instr *intr, nir_variable *va
for (unsigned i = 0; i < old_num_comps; ++i)
channels[i] = comp - var->data.location_frac + i;
nir_ssa_def *load = nir_swizzle(b, &new_intr->dest.ssa, channels, old_num_comps);
nir_ssa_def_rewrite_uses(&intr->dest.ssa, nir_src_for_ssa(load));
nir_ssa_def_rewrite_uses(&intr->dest.ssa, load);
/* Remove the old load intrinsic */
nir_instr_remove(&intr->instr);

2
src/gallium/drivers/radeonsi/si_shader_nir.c
View File

@ -650,7 +650,7 @@ static void si_nir_lower_color(nir_shader *nir)
continue;
}
nir_ssa_def_rewrite_uses(&intrin->dest.ssa, nir_src_for_ssa(def));
nir_ssa_def_rewrite_uses(&intrin->dest.ssa, def);
nir_instr_remove(instr);
}
}

2
src/gallium/drivers/vc4/vc4_nir_lower_io.c
View File

@ -49,7 +49,7 @@ replace_intrinsic_with_vec(nir_builder *b, nir_intrinsic_instr *intr,
/* Replace the old intrinsic with a reference to our reconstructed
* vector.
*/
nir_ssa_def_rewrite_uses(&intr->dest.ssa, nir_src_for_ssa(vec));
nir_ssa_def_rewrite_uses(&intr->dest.ssa, vec);
nir_instr_remove(&intr->instr);
}

2
src/gallium/drivers/zink/zink_compiler.c
View File

@ -275,7 +275,7 @@ lower_drawid_instr(nir_builder *b, nir_instr *in, void *data)
nir_ssa_dest_init(&load->instr, &load->dest, 1, 32, "draw_id");
nir_builder_instr_insert(b, &load->instr);
nir_ssa_def_rewrite_uses(&instr->dest.ssa, nir_src_for_ssa(&load->dest.ssa));
nir_ssa_def_rewrite_uses(&instr->dest.ssa, &load->dest.ssa);
return true;
}

2
src/gallium/frontends/clover/nir/invocation.cpp
View File

@ -134,7 +134,7 @@ clover_nir_lower_images(nir_shader *shader)
nir_ssa_def *loc =
nir_imm_intN_t(&b, deref->var->data.driver_location,
deref->dest.ssa.bit_size);
nir_ssa_def_rewrite_uses(&deref->dest.ssa, nir_src_for_ssa(loc));
nir_ssa_def_rewrite_uses(&deref->dest.ssa, loc);
progress = true;
break;
}

2
src/intel/compiler/brw_fs.cpp
View File

@ -8953,7 +8953,7 @@ brw_nir_demote_sample_qualifiers(nir_shader *nir)
nir_load_barycentric(&b, nir_intrinsic_load_barycentric_centroid,
nir_intrinsic_interp_mode(intrin));
nir_ssa_def_rewrite_uses(&intrin->dest.ssa,
nir_src_for_ssa(centroid));
centroid);
nir_instr_remove(instr);
progress = true;
}

4
src/intel/compiler/brw_nir.c
View File

@ -75,7 +75,7 @@ remap_tess_levels(nir_builder *b, nir_intrinsic_instr *intr,
if (nir_intrinsic_infos[intr->intrinsic].has_dest) {
b->cursor = nir_before_instr(&intr->instr);
nir_ssa_def *undef = nir_ssa_undef(b, 1, 32);
nir_ssa_def_rewrite_uses(&intr->dest.ssa, nir_src_for_ssa(undef));
nir_ssa_def_rewrite_uses(&intr->dest.ssa, undef);
}
nir_instr_remove(&intr->instr);
}
@ -258,7 +258,7 @@ brw_nir_lower_vs_inputs(nir_shader *nir,
nir_builder_instr_insert(&b, &load->instr);
nir_ssa_def_rewrite_uses(&intrin->dest.ssa,
nir_src_for_ssa(&load->dest.ssa));
&load->dest.ssa);
nir_instr_remove(&intrin->instr);
break;
}

2
src/intel/compiler/brw_nir_lower_conversions.c
View File

@ -58,7 +58,7 @@ split_conversion(nir_builder *b, nir_alu_instr *alu, nir_op op1, nir_op op2)
nir_ssa_def *src = nir_ssa_for_alu_src(b, alu, 0);
nir_ssa_def *tmp = nir_build_alu(b, op1, src, NULL, NULL, NULL);
nir_ssa_def *res = nir_build_alu(b, op2, tmp, NULL, NULL, NULL);
nir_ssa_def_rewrite_uses(&alu->dest.dest.ssa, nir_src_for_ssa(res));
nir_ssa_def_rewrite_uses(&alu->dest.dest.ssa, res);
nir_instr_remove(&alu->instr);
}

2
src/intel/compiler/brw_nir_lower_cs_intrinsics.c
View File

@ -187,7 +187,7 @@ lower_cs_intrinsics_convert_block(struct lower_intrinsics_state *state,
if (intrinsic->dest.ssa.bit_size == 64)
sysval = nir_u2u64(b, sysval);
nir_ssa_def_rewrite_uses(&intrinsic->dest.ssa, nir_src_for_ssa(sysval));
nir_ssa_def_rewrite_uses(&intrinsic->dest.ssa, sysval);
nir_instr_remove(&intrinsic->instr);
state->progress = true;

12
src/intel/compiler/brw_nir_lower_image_load_store.c
View File

@ -379,7 +379,7 @@ lower_image_load_instr(nir_builder *b,
* conversion.
*/
nir_ssa_def *placeholder = nir_ssa_undef(b, 4, 32);
nir_ssa_def_rewrite_uses(&intrin->dest.ssa, nir_src_for_ssa(placeholder));
nir_ssa_def_rewrite_uses(&intrin->dest.ssa, placeholder);
intrin->num_components = isl_format_get_num_channels(lower_fmt);
intrin->dest.ssa.num_components = intrin->num_components;
@ -391,7 +391,7 @@ lower_image_load_instr(nir_builder *b,
image_fmt, lower_fmt,
dest_components);
nir_ssa_def_rewrite_uses(placeholder, nir_src_for_ssa(color));
nir_ssa_def_rewrite_uses(placeholder, color);
nir_instr_remove(placeholder->parent_instr);
} else {
const struct isl_format_layout *image_fmtl =
@ -439,7 +439,7 @@ lower_image_load_instr(nir_builder *b,
image_fmt, raw_fmt,
dest_components);
nir_ssa_def_rewrite_uses(&intrin->dest.ssa, nir_src_for_ssa(color));
nir_ssa_def_rewrite_uses(&intrin->dest.ssa, color);
}
return true;
@ -604,7 +604,7 @@ lower_image_atomic_instr(nir_builder *b,
/* Use an undef to hold the uses of the load conversion. */
nir_ssa_def *placeholder = nir_ssa_undef(b, 4, 32);
nir_ssa_def_rewrite_uses(&intrin->dest.ssa, nir_src_for_ssa(placeholder));
nir_ssa_def_rewrite_uses(&intrin->dest.ssa, placeholder);
/* Check the first component of the size field to find out if the
* image is bound. Necessary on IVB for typed atomics because
@ -620,7 +620,7 @@ lower_image_atomic_instr(nir_builder *b,
nir_pop_if(b, NULL);
nir_ssa_def *result = nir_if_phi(b, &intrin->dest.ssa, zero);
nir_ssa_def_rewrite_uses(placeholder, nir_src_for_ssa(result));
nir_ssa_def_rewrite_uses(placeholder, result);
return true;
}
@ -669,7 +669,7 @@ lower_image_size_instr(nir_builder *b,
comps[c] = nir_imm_int(b, 1);
nir_ssa_def *vec = nir_vec(b, comps, intrin->dest.ssa.num_components);
nir_ssa_def_rewrite_uses(&intrin->dest.ssa, nir_src_for_ssa(vec));
nir_ssa_def_rewrite_uses(&intrin->dest.ssa, vec);
return true;
}

6
src/intel/compiler/brw_nir_lower_intersection_shader.c
View File

@ -96,13 +96,13 @@ lower_any_hit_for_intersection(nir_shader *any_hit)
case nir_intrinsic_load_ray_t_max:
nir_ssa_def_rewrite_uses(&intrin->dest.ssa,
nir_src_for_ssa(hit_t));
hit_t);
nir_instr_remove(&intrin->instr);
break;
case nir_intrinsic_load_ray_hit_kind:
nir_ssa_def_rewrite_uses(&intrin->dest.ssa,
nir_src_for_ssa(hit_kind));
hit_kind);
nir_instr_remove(&intrin->instr);
break;
@ -231,7 +231,7 @@ brw_nir_lower_intersection_shader(nir_shader *intersection,
nir_ssa_def *accepted = nir_load_var(b, commit_tmp);
nir_ssa_def_rewrite_uses(&intrin->dest.ssa,
nir_src_for_ssa(accepted));
accepted);
break;
}

2
src/intel/compiler/brw_nir_lower_mem_access_bit_sizes.c
View File

@ -144,7 +144,7 @@ lower_mem_load_bit_size(nir_builder *b, nir_intrinsic_instr *intrin,
}
nir_ssa_def_rewrite_uses(&intrin->dest.ssa,
nir_src_for_ssa(result));
result);
nir_instr_remove(&intrin->instr);
return true;

2
src/intel/compiler/brw_nir_lower_rt_intrinsics.c
View File

@ -365,7 +365,7 @@ lower_rt_intrinsics_impl(nir_function_impl *impl,
if (sysval) {
nir_ssa_def_rewrite_uses(&intrin->dest.ssa,
nir_src_for_ssa(sysval));
sysval);
nir_instr_remove(&intrin->instr);
}
}

2
src/intel/compiler/brw_nir_lower_shader_calls.c
View File

@ -847,7 +847,7 @@ rewrite_phis_to_pred(nir_block *block, nir_block *pred)
if (phi_src->pred == pred) {
found = true;
assert(phi_src->src.is_ssa);
nir_ssa_def_rewrite_uses(&phi->dest.ssa, phi_src->src);
nir_ssa_def_rewrite_uses(&phi->dest.ssa, phi_src->src.ssa);
break;
}
}

2
src/intel/compiler/brw_nir_opt_peephole_ffma.c
View File

@ -253,7 +253,7 @@ brw_nir_opt_peephole_ffma_block(nir_builder *b, nir_block *block)
bit_size,
add->dest.dest.ssa.name);
nir_ssa_def_rewrite_uses(&add->dest.dest.ssa,
nir_src_for_ssa(&ffma->dest.dest.ssa));
&ffma->dest.dest.ssa);
nir_builder_instr_insert(b, &ffma->instr);
assert(list_is_empty(&add->dest.dest.ssa.uses));

6
src/intel/compiler/brw_nir_rt.c
View File

@ -122,7 +122,7 @@ lower_rt_io_derefs(nir_shader *shader)
nir_var_function_temp,
deref->var->type, 0);
nir_ssa_def_rewrite_uses(&deref->dest.ssa,
nir_src_for_ssa(&cast->dest.ssa));
&cast->dest.ssa);
nir_instr_remove(&deref->instr);
progress = true;
}
@ -135,7 +135,7 @@ lower_rt_io_derefs(nir_shader *shader)
nir_var_function_temp,
deref->type, 0);
nir_ssa_def_rewrite_uses(&deref->dest.ssa,
nir_src_for_ssa(&cast->dest.ssa));
&cast->dest.ssa);
nir_instr_remove(&deref->instr);
progress = true;
}
@ -502,7 +502,7 @@ brw_nir_create_raygen_trampoline(const struct brw_compiler *compiler,
load_trampoline_param(&b, rt_disp_globals_addr, 1, 64);
assert(intrin->dest.is_ssa);
nir_ssa_def_rewrite_uses(&intrin->dest.ssa,
nir_src_for_ssa(global_arg_addr));
global_arg_addr);
nir_instr_remove(instr);
}
}

12
src/intel/vulkan/anv_nir_apply_pipeline_layout.c
View File

@ -431,7 +431,7 @@ lower_res_index_intrinsic(nir_intrinsic_instr *intrin,
}
assert(intrin->dest.is_ssa);
nir_ssa_def_rewrite_uses(&intrin->dest.ssa, nir_src_for_ssa(index));
nir_ssa_def_rewrite_uses(&intrin->dest.ssa, index);
nir_instr_remove(&intrin->instr);
}
@ -488,7 +488,7 @@ lower_res_reindex_intrinsic(nir_intrinsic_instr *intrin,
}
assert(intrin->dest.is_ssa);
nir_ssa_def_rewrite_uses(&intrin->dest.ssa, nir_src_for_ssa(new_index));
nir_ssa_def_rewrite_uses(&intrin->dest.ssa, new_index);
nir_instr_remove(&intrin->instr);
}
@ -659,7 +659,7 @@ lower_load_vulkan_descriptor(nir_intrinsic_instr *intrin,
}
assert(intrin->dest.is_ssa);
nir_ssa_def_rewrite_uses(&intrin->dest.ssa, nir_src_for_ssa(desc));
nir_ssa_def_rewrite_uses(&intrin->dest.ssa, desc);
nir_instr_remove(&intrin->instr);
}
@ -682,7 +682,7 @@ lower_get_ssbo_size(nir_intrinsic_instr *intrin,
if (state->pdevice->has_a64_buffer_access) {
nir_ssa_def *desc = build_ssbo_descriptor_load(desc_type, index, state);
nir_ssa_def *size = nir_channel(b, desc, 2);
nir_ssa_def_rewrite_uses(&intrin->dest.ssa, nir_src_for_ssa(size));
nir_ssa_def_rewrite_uses(&intrin->dest.ssa, size);
nir_instr_remove(&intrin->instr);
} else {
/* We're following the nir_address_format_32bit_index_offset model so
@ -765,7 +765,7 @@ lower_image_intrinsic(nir_intrinsic_instr *intrin,
intrin->dest.ssa.num_components,
intrin->dest.ssa.bit_size, state);
nir_ssa_def_rewrite_uses(&intrin->dest.ssa, nir_src_for_ssa(desc));
nir_ssa_def_rewrite_uses(&intrin->dest.ssa, desc);
} else if (binding_offset > MAX_BINDING_TABLE_SIZE) {
const bool write_only =
(var->data.access & ACCESS_NON_READABLE) != 0;
@ -837,7 +837,7 @@ lower_load_constant(nir_intrinsic_instr *intrin,
.range = nir_intrinsic_range(intrin));
}
nir_ssa_def_rewrite_uses(&intrin->dest.ssa, nir_src_for_ssa(data));
nir_ssa_def_rewrite_uses(&intrin->dest.ssa, data);
}
static void

Some files were not shown because too many files have changed in this diff Show More