From cc6e3b84cbb3097321da0cf06344270fb9007bd2 Mon Sep 17 00:00:00 2001 From: Alyssa Rosenzweig Date: Thu, 31 Jul 2025 09:49:36 -0400 Subject: [PATCH] treewide: use nir_def_as_* MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Via Coccinelle patch: @@ expression definition; @@ -nir_instr_as_alu(definition->parent_instr) +nir_def_as_alu(definition) @@ expression definition; @@ -nir_instr_as_intrinsic(definition->parent_instr) +nir_def_as_intrinsic(definition) @@ expression definition; @@ -nir_instr_as_phi(definition->parent_instr) +nir_def_as_phi(definition) @@ expression definition; @@ -nir_instr_as_load_const(definition->parent_instr) +nir_def_as_load_const(definition) @@ expression definition; @@ -nir_instr_as_deref(definition->parent_instr) +nir_def_as_deref(definition) @@ expression definition; @@ -nir_instr_as_tex(definition->parent_instr) +nir_def_as_tex(definition) Signed-off-by: Alyssa Rosenzweig Reviewed-by: Emma Anholt Reviewed-by: Marek Olšák Acked-by: Karol Herbst Acked-by: Konstantin Seurer Part-of: --- src/amd/common/nir/ac_nir.c | 2 +- .../common/nir/ac_nir_lower_global_access.c | 2 +- .../nir/ac_nir_lower_image_opcodes_cdna.c | 2 +- .../nir/ac_nir_lower_intrinsics_to_args.c | 2 +- src/amd/common/nir/ac_nir_lower_ps_early.c | 2 +- src/amd/common/nir/ac_nir_lower_tex.c | 10 +-- src/amd/common/nir/ac_nir_meta_ps_resolve.c | 2 +- .../instruction_selection/aco_select_nir.cpp | 2 +- .../nir/radv_nir_apply_pipeline_layout.c | 14 ++-- .../nir/radv_nir_lower_cooperative_matrix.c | 2 +- .../vulkan/nir/radv_nir_lower_ray_queries.c | 2 +- .../vulkan/nir/radv_nir_opt_tid_function.c | 4 +- src/amd/vulkan/radv_shader_info.c | 2 +- src/asahi/compiler/agx_nir_lower_texture.c | 2 +- src/broadcom/compiler/nir_to_vir.c | 2 +- src/broadcom/compiler/vir.c | 2 +- src/broadcom/vulkan/v3dv_pipeline.c | 6 +- src/compiler/glsl/gl_nir_linker.c | 6 +- src/compiler/nir/nir.c | 8 +- src/compiler/nir/nir_builder.h | 8 +- src/compiler/nir/nir_inline_uniforms.c | 4 +- src/compiler/nir/nir_legacy.c | 2 +- src/compiler/nir/nir_linking_helpers.c | 10 +-- src/compiler/nir/nir_loop_analyze.c | 12 +-- src/compiler/nir/nir_loop_analyze.h | 4 +- src/compiler/nir/nir_lower_bit_size.c | 2 +- src/compiler/nir/nir_lower_flatshade.c | 4 +- src/compiler/nir/nir_lower_flrp.c | 80 +++++++++---------- src/compiler/nir/nir_lower_image.c | 2 +- src/compiler/nir/nir_lower_interpolation.c | 2 +- src/compiler/nir/nir_lower_locals_to_regs.c | 2 +- src/compiler/nir/nir_lower_mediump.c | 4 +- src/compiler/nir/nir_lower_point_smooth.c | 2 +- .../nir/nir_lower_reg_intrinsics_to_ssa.c | 4 +- src/compiler/nir/nir_lower_robust_access.c | 4 +- src/compiler/nir/nir_lower_samplers.c | 4 +- src/compiler/nir/nir_lower_tex_shadow.c | 2 +- src/compiler/nir/nir_lower_ubo_vec4.c | 2 +- src/compiler/nir/nir_lower_uniforms_to_ubo.c | 2 +- src/compiler/nir/nir_lower_var_copies.c | 4 +- src/compiler/nir/nir_lower_vec_to_regs.c | 2 +- src/compiler/nir/nir_mod_analysis.c | 4 +- src/compiler/nir/nir_opt_if.c | 12 +-- .../nir/nir_opt_load_store_vectorize.c | 2 +- src/compiler/nir/nir_opt_loop.c | 2 +- src/compiler/nir/nir_opt_loop_unroll.c | 4 +- src/compiler/nir/nir_opt_offsets.c | 2 +- src/compiler/nir/nir_opt_ray_queries.c | 9 +-- src/compiler/nir/nir_opt_reassociate.c | 2 +- src/compiler/nir/nir_opt_remove_phis.c | 4 +- src/compiler/nir/nir_opt_shrink_vectors.c | 2 +- src/compiler/nir/nir_opt_uniform_atomics.c | 2 +- src/compiler/nir/nir_opt_varyings.c | 25 +++--- src/compiler/nir/nir_print.c | 2 +- src/compiler/nir/nir_range_analysis.c | 12 +-- src/compiler/nir/nir_remove_tex_shadow.c | 2 +- src/compiler/nir/nir_repair_ssa.c | 2 +- src/compiler/nir/nir_search.c | 8 +- src/compiler/nir/nir_serialize.c | 2 +- .../nir/nir_split_64bit_vec3_and_vec4.c | 4 +- src/compiler/nir/nir_split_var_copies.c | 4 +- src/compiler/nir/nir_to_lcssa.c | 2 +- src/compiler/nir/nir_validate.c | 4 +- .../nir/tests/nir_opt_varyings_test.h | 12 +-- src/compiler/spirv/vtn_alu.c | 2 +- src/compiler/spirv/vtn_opencl.c | 2 +- src/compiler/spirv/vtn_variables.c | 4 +- src/freedreno/ir3/ir3_compiler_nir.c | 4 +- src/freedreno/ir3/ir3_nir.h | 2 +- .../ir3/ir3_nir_analyze_ubo_ranges.c | 2 +- .../ir3/ir3_nir_lower_tex_prefetch.c | 2 +- src/freedreno/ir3/ir3_nir_opt_preamble.c | 10 +-- .../vulkan/tu_nir_lower_ray_query.cc | 8 +- src/freedreno/vulkan/tu_shader.cc | 2 +- .../auxiliary/gallivm/lp_bld_nir_aos.c | 4 +- .../auxiliary/gallivm/lp_bld_nir_soa.c | 6 +- src/gallium/auxiliary/nir/nir_to_tgsi.c | 6 +- src/gallium/drivers/crocus/crocus_program.c | 2 +- .../drivers/etnaviv/etnaviv_compiler_nir.c | 2 +- src/gallium/drivers/etnaviv/etnaviv_nir.c | 4 +- .../etnaviv/etnaviv_nir_lower_source_mods.c | 2 +- .../drivers/lima/ir/lima_nir_lower_txp.c | 2 +- .../lima/ir/lima_nir_split_load_input.c | 2 +- .../drivers/llvmpipe/lp_state_fs_analysis.c | 4 +- src/gallium/drivers/r300/compiler/nir_to_rc.c | 6 +- .../si_nir_lower_color_inputs_to_sysvals.c | 2 +- src/gallium/drivers/vc4/vc4_program.c | 6 +- .../drivers/zink/nir_to_spirv/nir_to_spirv.c | 2 +- src/gallium/drivers/zink/zink_compiler.c | 13 +-- .../zink/zink_lower_cubemap_to_array.c | 4 +- .../lavapipe/nir/lvp_nir_lower_ray_queries.c | 4 +- src/gallium/frontends/rusticl/rusticl_nir.c | 4 +- src/intel/compiler/brw_from_nir.cpp | 2 +- src/intel/compiler/brw_nir.c | 4 +- src/intel/compiler/brw_nir.h | 6 +- .../brw_nir_lower_immediate_offsets.c | 4 +- src/intel/compiler/brw_nir_wa_18019110168.c | 2 +- src/intel/compiler/elk/elk_fs_nir.cpp | 8 +- src/intel/compiler/elk/elk_nir.c | 2 +- src/intel/compiler/elk/elk_nir.h | 6 +- .../intel_nir_clamp_per_vertex_loads.c | 2 +- ..._lower_non_uniform_barycentric_at_sample.c | 2 +- src/intel/compiler/intel_nir_lower_sparse.c | 4 +- .../compiler/intel_nir_opt_peephole_ffma.c | 2 +- .../vulkan/anv_nir_push_descriptor_analysis.c | 2 +- src/mesa/main/ff_fragment_shader.c | 2 +- src/mesa/program/prog_to_nir.c | 2 +- src/mesa/state_tracker/st_atifs_to_nir.c | 2 +- .../state_tracker/st_nir_unlower_io_to_vars.c | 2 +- src/microsoft/clc/clc_compiler.c | 3 +- src/microsoft/compiler/dxil_nir.c | 4 +- .../compiler/dxil_nir_lower_int_cubemaps.c | 2 +- .../compiler/dxil_nir_lower_int_samplers.c | 4 +- src/nouveau/compiler/nak_nir_lower_cmat.c | 2 +- .../nak_nir_lower_kepler_shared_atomics.c | 2 +- src/nouveau/compiler/nak_nir_lower_tex.c | 2 +- .../nak_nir_rematerialize_load_const.c | 2 +- src/nouveau/vulkan/nvk_cmd_indirect.c | 2 +- .../vulkan/nvk_nir_lower_descriptors.c | 2 +- src/panfrost/midgard/midgard_address.c | 2 +- 120 files changed, 276 insertions(+), 278 deletions(-) diff --git a/src/amd/common/nir/ac_nir.c b/src/amd/common/nir/ac_nir.c index c68c2c645ff..9ee85ea59c7 100644 --- a/src/amd/common/nir/ac_nir.c +++ b/src/amd/common/nir/ac_nir.c @@ -163,7 +163,7 @@ ac_nir_load_arg_upper_bound(nir_builder *b, const struct ac_shader_args *ac_args unsigned upper_bound) { nir_def *value = ac_nir_load_arg_at_offset(b, ac_args, arg, 0); - nir_intrinsic_set_arg_upper_bound_u32_amd(nir_instr_as_intrinsic(value->parent_instr), + nir_intrinsic_set_arg_upper_bound_u32_amd(nir_def_as_intrinsic(value), upper_bound); return value; } diff --git a/src/amd/common/nir/ac_nir_lower_global_access.c b/src/amd/common/nir/ac_nir_lower_global_access.c index 3db1b3ed2cf..76d56d7191d 100644 --- a/src/amd/common/nir/ac_nir_lower_global_access.c +++ b/src/amd/common/nir/ac_nir_lower_global_access.c @@ -29,7 +29,7 @@ try_extract_additions(nir_builder *b, nir_scalar scalar, uint64_t *out_const, if (!nir_scalar_is_alu(scalar) || nir_scalar_alu_op(scalar) != nir_op_iadd) return NULL; - nir_alu_instr *alu = nir_instr_as_alu(scalar.def->parent_instr); + nir_alu_instr *alu = nir_def_as_alu(scalar.def); nir_scalar src0 = nir_scalar_chase_alu_src(scalar, 0); nir_scalar src1 = nir_scalar_chase_alu_src(scalar, 1); diff --git a/src/amd/common/nir/ac_nir_lower_image_opcodes_cdna.c b/src/amd/common/nir/ac_nir_lower_image_opcodes_cdna.c index d863a00c15d..de80dbc8092 100644 --- a/src/amd/common/nir/ac_nir_lower_image_opcodes_cdna.c +++ b/src/amd/common/nir/ac_nir_lower_image_opcodes_cdna.c @@ -329,7 +329,7 @@ static bool lower_image_opcodes(nir_builder *b, nir_instr *instr, void *data) case nir_intrinsic_image_deref_load: case nir_intrinsic_image_deref_store: - deref = nir_instr_as_deref(intr->src[0].ssa->parent_instr); + deref = nir_def_as_deref(intr->src[0].ssa); access = nir_deref_instr_get_variable(deref)->data.access; dim = glsl_get_sampler_dim(deref->type); if (dim == GLSL_SAMPLER_DIM_BUF) diff --git a/src/amd/common/nir/ac_nir_lower_intrinsics_to_args.c b/src/amd/common/nir/ac_nir_lower_intrinsics_to_args.c index 853613e30d5..04d1d6d0dc4 100644 --- a/src/amd/common/nir/ac_nir_lower_intrinsics_to_args.c +++ b/src/amd/common/nir/ac_nir_lower_intrinsics_to_args.c @@ -405,7 +405,7 @@ lower_intrinsic_to_arg(nir_builder *b, nir_intrinsic_instr *intrin, void *state) * to optimize some multiplications (in address calculations) so that * constant additions can be added to the const offset in memory load instructions. */ - nir_intrinsic_set_arg_upper_bound_u32_amd(nir_instr_as_intrinsic(replacement->parent_instr), + nir_intrinsic_set_arg_upper_bound_u32_amd(nir_def_as_intrinsic(replacement), 2048 / b->shader->info.tess.tcs_vertices_out); } } diff --git a/src/amd/common/nir/ac_nir_lower_ps_early.c b/src/amd/common/nir/ac_nir_lower_ps_early.c index 78481a43387..5b37474def6 100644 --- a/src/amd/common/nir/ac_nir_lower_ps_early.c +++ b/src/amd/common/nir/ac_nir_lower_ps_early.c @@ -427,7 +427,7 @@ lower_ps_intrinsic(nir_builder *b, nir_intrinsic_instr *intrin, void *state) if (s->options->ps_iter_samples >= 2 && sample_id->parent_instr->type == nir_instr_type_intrinsic && - nir_instr_as_intrinsic(sample_id->parent_instr)->intrinsic == nir_intrinsic_load_sample_id) { + nir_def_as_intrinsic(sample_id)->intrinsic == nir_intrinsic_load_sample_id) { nir_def_replace(&intrin->def, nir_load_barycentric_sample(b, 32, .interp_mode = mode)); return true; } diff --git a/src/amd/common/nir/ac_nir_lower_tex.c b/src/amd/common/nir/ac_nir_lower_tex.c index 394ddd1e5ea..90998fea46c 100644 --- a/src/amd/common/nir/ac_nir_lower_tex.c +++ b/src/amd/common/nir/ac_nir_lower_tex.c @@ -233,7 +233,7 @@ can_move_coord(nir_scalar scalar, coord_info *info) if (!nir_scalar_is_intrinsic(scalar)) return false; - nir_intrinsic_instr *intrin = nir_instr_as_intrinsic(scalar.def->parent_instr); + nir_intrinsic_instr *intrin = nir_def_as_intrinsic(scalar.def); if (intrin->intrinsic == nir_intrinsic_load_input || intrin->intrinsic == nir_intrinsic_load_per_primitive_input) { info->bary = NULL; @@ -250,8 +250,8 @@ can_move_coord(nir_scalar scalar, coord_info *info) !nir_scalar_is_intrinsic(coord_y) || coord_y.comp != 1) return false; - nir_intrinsic_instr *intrin_x = nir_instr_as_intrinsic(coord_x.def->parent_instr); - nir_intrinsic_instr *intrin_y = nir_instr_as_intrinsic(coord_y.def->parent_instr); + nir_intrinsic_instr *intrin_x = nir_def_as_intrinsic(coord_x.def); + nir_intrinsic_instr *intrin_y = nir_def_as_intrinsic(coord_y.def); if (intrin_x->intrinsic != intrin_y->intrinsic || (intrin_x->intrinsic != nir_intrinsic_load_barycentric_sample && intrin_x->intrinsic != nir_intrinsic_load_barycentric_pixel && @@ -291,7 +291,7 @@ build_coordinate(struct move_tex_coords_state *state, nir_scalar scalar, coord_i } else { res = nir_load_input(b, 1, 32, zero); } - nir_intrinsic_instr *intrin = nir_instr_as_intrinsic(res->parent_instr); + nir_intrinsic_instr *intrin = nir_def_as_intrinsic(res); nir_intrinsic_set_base(intrin, nir_intrinsic_base(info.load)); nir_intrinsic_set_component(intrin, nir_intrinsic_component(info.load) + scalar.comp); nir_intrinsic_set_dest_type(intrin, nir_intrinsic_dest_type(info.load)); @@ -398,7 +398,7 @@ move_ddxy(struct move_tex_coords_state *state, nir_function_impl *impl, nir_intr nir_def *def = nir_vec_scalars(&state->toplevel_b, components, num_components); def = _nir_build_ddx(&state->toplevel_b, def->bit_size, def); - nir_instr_as_intrinsic(def->parent_instr)->intrinsic = instr->intrinsic; + nir_def_as_intrinsic(def)->intrinsic = instr->intrinsic; nir_def_rewrite_uses(&instr->def, def); state->num_wqm_vgprs += num_components; diff --git a/src/amd/common/nir/ac_nir_meta_ps_resolve.c b/src/amd/common/nir/ac_nir_meta_ps_resolve.c index d70f0d84602..024d730c112 100644 --- a/src/amd/common/nir/ac_nir_meta_ps_resolve.c +++ b/src/amd/common/nir/ac_nir_meta_ps_resolve.c @@ -14,7 +14,7 @@ build_tex_load_ms(nir_builder *b, unsigned num_components, unsigned bit_size, nir_deref_instr *tex_deref, nir_def *coord, nir_def *sample_index) { nir_def *result = nir_txf_ms(b, coord, sample_index, .texture_deref = tex_deref); - nir_tex_instr *tex = nir_instr_as_tex(result->parent_instr); + nir_tex_instr *tex = nir_def_as_tex(result); assert(bit_size == 32 || bit_size == 16); if (bit_size == 16) { diff --git a/src/amd/compiler/instruction_selection/aco_select_nir.cpp b/src/amd/compiler/instruction_selection/aco_select_nir.cpp index da183ad841c..17ccbc3f91c 100644 --- a/src/amd/compiler/instruction_selection/aco_select_nir.cpp +++ b/src/amd/compiler/instruction_selection/aco_select_nir.cpp @@ -67,7 +67,7 @@ get_const_vec(nir_def* vec, nir_const_value* cv[4]) { if (vec->parent_instr->type != nir_instr_type_alu) return; - nir_alu_instr* vec_instr = nir_instr_as_alu(vec->parent_instr); + nir_alu_instr* vec_instr = nir_def_as_alu(vec); if (vec_instr->op != nir_op_vec(vec->num_components)) return; diff --git a/src/amd/vulkan/nir/radv_nir_apply_pipeline_layout.c b/src/amd/vulkan/nir/radv_nir_apply_pipeline_layout.c index c0a603c9536..08975df80ae 100644 --- a/src/amd/vulkan/nir/radv_nir_apply_pipeline_layout.c +++ b/src/amd/vulkan/nir/radv_nir_apply_pipeline_layout.c @@ -76,10 +76,10 @@ visit_vulkan_resource_index(nir_builder *b, apply_layout_state *state, nir_intri } nir_def *binding_ptr = nir_imul_imm(b, intrin->src[0].ssa, stride); - nir_instr_as_alu(binding_ptr->parent_instr)->no_unsigned_wrap = true; + nir_def_as_alu(binding_ptr)->no_unsigned_wrap = true; binding_ptr = nir_iadd_imm(b, binding_ptr, offset); - nir_instr_as_alu(binding_ptr->parent_instr)->no_unsigned_wrap = true; + nir_def_as_alu(binding_ptr)->no_unsigned_wrap = true; if (layout->binding[binding].type == VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR) { assert(stride == 16); @@ -99,7 +99,7 @@ visit_vulkan_resource_reindex(nir_builder *b, apply_layout_state *state, nir_int nir_def *binding_ptr = nir_unpack_64_2x32_split_y(b, intrin->src[0].ssa); nir_def *index = nir_imul_imm(b, intrin->src[1].ssa, 16); - nir_instr_as_alu(index->parent_instr)->no_unsigned_wrap = true; + nir_def_as_alu(index)->no_unsigned_wrap = true; binding_ptr = nir_iadd_nuw(b, binding_ptr, index); @@ -111,7 +111,7 @@ visit_vulkan_resource_reindex(nir_builder *b, apply_layout_state *state, nir_int nir_def *stride = nir_channel(b, intrin->src[0].ssa, 2); nir_def *index = nir_imul(b, intrin->src[1].ssa, stride); - nir_instr_as_alu(index->parent_instr)->no_unsigned_wrap = true; + nir_def_as_alu(index)->no_unsigned_wrap = true; binding_ptr = nir_iadd_nuw(b, binding_ptr, index); @@ -258,11 +258,11 @@ get_sampler_desc(nir_builder *b, apply_layout_state *state, nir_deref_instr *der nir_def *tmp = nir_imul_imm(b, deref->arr.index.ssa, array_size); if (tmp != deref->arr.index.ssa) - nir_instr_as_alu(tmp->parent_instr)->no_unsigned_wrap = true; + nir_def_as_alu(tmp)->no_unsigned_wrap = true; if (index) { index = nir_iadd(b, tmp, index); - nir_instr_as_alu(index->parent_instr)->no_unsigned_wrap = true; + nir_def_as_alu(index)->no_unsigned_wrap = true; } else { index = tmp; } @@ -272,7 +272,7 @@ get_sampler_desc(nir_builder *b, apply_layout_state *state, nir_deref_instr *der nir_def *index_offset = index ? nir_iadd_imm(b, index, offset) : nir_imm_int(b, offset); if (index && index_offset != index) - nir_instr_as_alu(index_offset->parent_instr)->no_unsigned_wrap = true; + nir_def_as_alu(index_offset)->no_unsigned_wrap = true; if (non_uniform) return nir_iadd(b, load_desc_ptr(b, state, desc_set), index_offset); diff --git a/src/amd/vulkan/nir/radv_nir_lower_cooperative_matrix.c b/src/amd/vulkan/nir/radv_nir_lower_cooperative_matrix.c index edbc25dd9f9..4b66dc40393 100644 --- a/src/amd/vulkan/nir/radv_nir_lower_cooperative_matrix.c +++ b/src/amd/vulkan/nir/radv_nir_lower_cooperative_matrix.c @@ -82,7 +82,7 @@ radv_nir_cmat_length_mul(struct glsl_cmat_description desc, const lower_cmat_par static nir_def * radv_nir_load_cmat(nir_builder *b, const lower_cmat_params *params, nir_def *src) { - nir_deref_instr *deref = nir_instr_as_deref(src->parent_instr); + nir_deref_instr *deref = nir_def_as_deref(src); struct glsl_cmat_description desc = *glsl_get_cmat_description(deref->type); return nir_build_load_deref(b, radv_nir_cmat_length(desc, params), radv_nir_cmat_bits(desc), src, 0); } diff --git a/src/amd/vulkan/nir/radv_nir_lower_ray_queries.c b/src/amd/vulkan/nir/radv_nir_lower_ray_queries.c index 798643d865e..16f237eb1a2 100644 --- a/src/amd/vulkan/nir/radv_nir_lower_ray_queries.c +++ b/src/amd/vulkan/nir/radv_nir_lower_ray_queries.c @@ -639,7 +639,7 @@ radv_nir_lower_ray_queries(struct nir_shader *shader, struct radv_device *device if (!nir_intrinsic_is_ray_query(intrinsic->intrinsic)) continue; - nir_deref_instr *ray_query_deref = nir_instr_as_deref(intrinsic->src[0].ssa->parent_instr); + nir_deref_instr *ray_query_deref = nir_def_as_deref(intrinsic->src[0].ssa); struct ray_query_vars *vars = (struct ray_query_vars *)_mesa_hash_table_search(query_ht, nir_deref_instr_get_variable(ray_query_deref)) diff --git a/src/amd/vulkan/nir/radv_nir_opt_tid_function.c b/src/amd/vulkan/nir/radv_nir_opt_tid_function.c index 29b1d093a4a..7e1417e4b90 100644 --- a/src/amd/vulkan/nir/radv_nir_opt_tid_function.c +++ b/src/amd/vulkan/nir/radv_nir_opt_tid_function.c @@ -145,7 +145,7 @@ constant_fold_scalar(nir_scalar s, unsigned invocation_id, nir_shader *shader, n memset(dest, 0, sizeof(*dest)); if (nir_scalar_is_alu(s)) { - nir_alu_instr *alu = nir_instr_as_alu(s.def->parent_instr); + nir_alu_instr *alu = nir_def_as_alu(s.def); nir_const_value sources[NIR_ALU_MAX_INPUTS][NIR_MAX_VEC_COMPONENTS]; const nir_op_info *op_info = &nir_op_infos[alu->op]; @@ -221,7 +221,7 @@ constant_fold_scalar(nir_scalar s, unsigned invocation_id, nir_shader *shader, n return true; } case nir_intrinsic_inverse_ballot: { - nir_def *src = nir_instr_as_intrinsic(s.def->parent_instr)->src[0].ssa; + nir_def *src = nir_def_as_intrinsic(s.def)->src[0].ssa; unsigned comp = invocation_id / src->bit_size; unsigned bit = invocation_id % src->bit_size; if (!constant_fold_scalar(nir_get_scalar(src, comp), invocation_id, shader, dest, depth + 1)) diff --git a/src/amd/vulkan/radv_shader_info.c b/src/amd/vulkan/radv_shader_info.c index f9c4983abd6..79f9872aec9 100644 --- a/src/amd/vulkan/radv_shader_info.c +++ b/src/amd/vulkan/radv_shader_info.c @@ -290,7 +290,7 @@ gather_intrinsic_info(const nir_shader *nir, const nir_intrinsic_instr *instr, s case nir_intrinsic_image_deref_atomic_swap: case nir_intrinsic_image_deref_size: case nir_intrinsic_image_deref_samples: { - nir_variable *var = nir_deref_instr_get_variable(nir_instr_as_deref(instr->src[0].ssa->parent_instr)); + nir_variable *var = nir_deref_instr_get_variable(nir_def_as_deref(instr->src[0].ssa)); mark_sampler_desc(var, info); break; } diff --git a/src/asahi/compiler/agx_nir_lower_texture.c b/src/asahi/compiler/agx_nir_lower_texture.c index be8d00e2cff..616d0b0e9d1 100644 --- a/src/asahi/compiler/agx_nir_lower_texture.c +++ b/src/asahi/compiler/agx_nir_lower_texture.c @@ -190,7 +190,7 @@ lower_buffer_texture(nir_builder *b, nir_tex_instr *tex) /* Put it together with a phi */ nir_def *phi = nir_if_phi(b, rgb32, &tex->def); nir_def_rewrite_uses(&tex->def, phi); - nir_phi_instr *phi_instr = nir_instr_as_phi(phi->parent_instr); + nir_phi_instr *phi_instr = nir_def_as_phi(phi); nir_phi_src *else_src = nir_phi_get_src_from_block(phi_instr, else_block); nir_src_rewrite(&else_src->src, &tex->def); return true; diff --git a/src/broadcom/compiler/nir_to_vir.c b/src/broadcom/compiler/nir_to_vir.c index 2475f858a72..77fac5b5060 100644 --- a/src/broadcom/compiler/nir_to_vir.c +++ b/src/broadcom/compiler/nir_to_vir.c @@ -1233,7 +1233,7 @@ ntq_get_alu_parent(nir_src src) { if (src.ssa->parent_instr->type != nir_instr_type_alu) return NULL; - nir_alu_instr *instr = nir_instr_as_alu(src.ssa->parent_instr); + nir_alu_instr *instr = nir_def_as_alu(src.ssa); if (!instr) return NULL; diff --git a/src/broadcom/compiler/vir.c b/src/broadcom/compiler/vir.c index 0fe816751be..754981186c9 100644 --- a/src/broadcom/compiler/vir.c +++ b/src/broadcom/compiler/vir.c @@ -633,7 +633,7 @@ v3d_nir_lower_null_pointers_cb(nir_builder *b, if (src->ssa->parent_instr->type != nir_instr_type_alu) return false; - nir_alu_instr *alu = nir_instr_as_alu(src->ssa->parent_instr); + nir_alu_instr *alu = nir_def_as_alu(src->ssa); if (alu->op != nir_op_bcsel) return false; diff --git a/src/broadcom/vulkan/v3dv_pipeline.c b/src/broadcom/vulkan/v3dv_pipeline.c index 54ea07cb25f..789162fce86 100644 --- a/src/broadcom/vulkan/v3dv_pipeline.c +++ b/src/broadcom/vulkan/v3dv_pipeline.c @@ -623,10 +623,10 @@ lower_tex_src(nir_builder *b, uint8_t plane = tex_instr_get_and_remove_plane_src(instr); /* We compute first the offsets */ - nir_deref_instr *deref = nir_instr_as_deref(src->src.ssa->parent_instr); + nir_deref_instr *deref = nir_def_as_deref(src->src.ssa); while (deref->deref_type != nir_deref_type_var) { nir_deref_instr *parent = - nir_instr_as_deref(deref->parent.ssa->parent_instr); + nir_def_as_deref(deref->parent.ssa); assert(deref->deref_type == nir_deref_type_array); @@ -757,7 +757,7 @@ lower_image_deref(nir_builder *b, while (deref->deref_type != nir_deref_type_var) { nir_deref_instr *parent = - nir_instr_as_deref(deref->parent.ssa->parent_instr); + nir_def_as_deref(deref->parent.ssa); assert(deref->deref_type == nir_deref_type_array); diff --git a/src/compiler/glsl/gl_nir_linker.c b/src/compiler/glsl/gl_nir_linker.c index 66f30855d1a..5889fcbbaf1 100644 --- a/src/compiler/glsl/gl_nir_linker.c +++ b/src/compiler/glsl/gl_nir_linker.c @@ -189,9 +189,9 @@ gl_nir_inline_functions(nir_shader *shader) if (intr->src[0].src_type == nir_tex_src_sampler_deref_intrinsic) { assert(intr->src[1].src_type == nir_tex_src_texture_deref_intrinsic); nir_intrinsic_instr *intrin = - nir_instr_as_intrinsic(intr->src[0].src.ssa->parent_instr); + nir_def_as_intrinsic(intr->src[0].src.ssa); nir_deref_instr *deref = - nir_instr_as_deref(intrin->src[0].ssa->parent_instr); + nir_def_as_deref(intrin->src[0].ssa); /* check for bindless handles */ if (!nir_deref_mode_is(deref, nir_var_uniform) || @@ -3145,7 +3145,7 @@ validate_sampler_array_indexing(const struct pipe_screen *screen, nir_tex_instr_src_index(tex_instr, nir_tex_src_sampler_deref); if (sampler_idx >= 0) { nir_deref_instr *deref = - nir_instr_as_deref(tex_instr->src[sampler_idx].src.ssa->parent_instr); + nir_def_as_deref(tex_instr->src[sampler_idx].src.ssa); if (is_sampler_array_accessed_indirectly(deref)) { uses_indirect_sampler_array_indexing = true; break; diff --git a/src/compiler/nir/nir.c b/src/compiler/nir/nir.c index c45e50befdd..f20747ff950 100644 --- a/src/compiler/nir/nir.c +++ b/src/compiler/nir/nir.c @@ -1449,7 +1449,7 @@ nir_src_as_const_value(nir_src src) if (src.ssa->parent_instr->type != nir_instr_type_load_const) return NULL; - nir_load_const_instr *load = nir_instr_as_load_const(src.ssa->parent_instr); + nir_load_const_instr *load = nir_def_as_load_const(src.ssa); return load->value; } @@ -1469,7 +1469,7 @@ nir_src_is_always_uniform(nir_src src) return true; if (src.ssa->parent_instr->type == nir_instr_type_intrinsic) { - nir_intrinsic_instr *intr = nir_instr_as_intrinsic(src.ssa->parent_instr); + nir_intrinsic_instr *intr = nir_def_as_intrinsic(src.ssa); /* As are uniform variables */ if (intr->intrinsic == nir_intrinsic_load_uniform && nir_src_is_always_uniform(intr->src[0])) @@ -1487,7 +1487,7 @@ nir_src_is_always_uniform(nir_src src) /* Operating together uniform expressions produces a uniform result */ if (src.ssa->parent_instr->type == nir_instr_type_alu) { - nir_alu_instr *alu = nir_instr_as_alu(src.ssa->parent_instr); + nir_alu_instr *alu = nir_def_as_alu(src.ssa); for (int i = 0; i < nir_op_infos[alu->op].num_inputs; i++) { if (!nir_src_is_always_uniform(alu->src[i].src)) return false; @@ -2928,7 +2928,7 @@ nir_scalar nir_scalar_chase_movs(nir_scalar s) { while (nir_scalar_is_alu(s)) { - nir_alu_instr *alu = nir_instr_as_alu(s.def->parent_instr); + nir_alu_instr *alu = nir_def_as_alu(s.def); if (alu->op == nir_op_mov) { s.def = alu->src[0].src.ssa; s.comp = alu->src[0].swizzle[s.comp]; diff --git a/src/compiler/nir/nir_builder.h b/src/compiler/nir/nir_builder.h index 76efcd96247..9467bce0a2c 100644 --- a/src/compiler/nir/nir_builder.h +++ b/src/compiler/nir/nir_builder.h @@ -999,7 +999,7 @@ nir_iadd_imm_nuw(nir_builder *b, nir_def *x, uint64_t y) { nir_def *d = nir_iadd_imm(b, x, y); if (d != x && d->parent_instr->type == nir_instr_type_alu) - nir_instr_as_alu(d->parent_instr)->no_unsigned_wrap = true; + nir_def_as_alu(d)->no_unsigned_wrap = true; return d; } @@ -1007,7 +1007,7 @@ static inline nir_def * nir_iadd_nuw(nir_builder *b, nir_def *x, nir_def *y) { nir_def *d = nir_iadd(b, x, y); - nir_instr_as_alu(d->parent_instr)->no_unsigned_wrap = true; + nir_def_as_alu(d)->no_unsigned_wrap = true; return d; } @@ -2155,13 +2155,13 @@ nir_build_deriv(nir_builder *b, nir_def *x, nir_intrinsic_op intrin) for (unsigned i = 0; i < x->num_components; ++i) { res[i] = _nir_build_ddx(b, x->bit_size, nir_channel(b, x, i)); - nir_instr_as_intrinsic(res[i]->parent_instr)->intrinsic = intrin; + nir_def_as_intrinsic(res[i])->intrinsic = intrin; } return nir_vec(b, res, x->num_components); } else { nir_def *res = _nir_build_ddx(b, x->bit_size, x); - nir_instr_as_intrinsic(res->parent_instr)->intrinsic = intrin; + nir_def_as_intrinsic(res)->intrinsic = intrin; return res; } } diff --git a/src/compiler/nir/nir_inline_uniforms.c b/src/compiler/nir/nir_inline_uniforms.c index 0b33600ed8c..b59600ec9a5 100644 --- a/src/compiler/nir/nir_inline_uniforms.c +++ b/src/compiler/nir/nir_inline_uniforms.c @@ -241,7 +241,7 @@ nir_add_inlinable_uniforms(const nir_src *cond, nir_loop_info *info, if (nir_scalar_alu_op(cond_scalar) == nir_op_inot) cond_scalar = nir_scalar_chase_alu_src(cond_scalar, 0); - nir_alu_instr *alu = nir_instr_as_alu(cond_scalar.def->parent_instr); + nir_alu_instr *alu = nir_def_as_alu(cond_scalar.def); /* One side of comparison is induction variable, the other side is * only uniform. @@ -442,7 +442,7 @@ nir_inline_uniforms_impl(nir_builder *b, nir_intrinsic_instr *intr, void *state) intr->src[0].ssa, nir_imm_int(b, scalar_offset)); nir_intrinsic_instr *load = - nir_instr_as_intrinsic(components[i]->parent_instr); + nir_def_as_intrinsic(components[i]); nir_intrinsic_set_align(load, NIR_ALIGN_MUL_MAX, scalar_offset); nir_intrinsic_set_range_base(load, scalar_offset); nir_intrinsic_set_range(load, 4); diff --git a/src/compiler/nir/nir_legacy.c b/src/compiler/nir/nir_legacy.c index 075b22d890b..dcd64dc2c31 100644 --- a/src/compiler/nir/nir_legacy.c +++ b/src/compiler/nir/nir_legacy.c @@ -70,7 +70,7 @@ chase_source_mod(nir_def **ssa, nir_op op, uint8_t *swizzle) if ((*ssa)->parent_instr->type != nir_instr_type_alu) return false; - nir_alu_instr *alu = nir_instr_as_alu((*ssa)->parent_instr); + nir_alu_instr *alu = nir_def_as_alu((*ssa)); if (alu->op != op) return false; diff --git a/src/compiler/nir/nir_linking_helpers.c b/src/compiler/nir/nir_linking_helpers.c index ddf6c22f6c4..74e729768b3 100644 --- a/src/compiler/nir/nir_linking_helpers.c +++ b/src/compiler/nir/nir_linking_helpers.c @@ -1061,7 +1061,7 @@ replace_varying_input_by_constant_load(nir_shader *shader, b.cursor = nir_before_instr(instr); nir_load_const_instr *out_const = - nir_instr_as_load_const(store_intr->src[1].ssa->parent_instr); + nir_def_as_load_const(store_intr->src[1].ssa); /* Add new const to replace the input */ nir_def *nconst = nir_build_imm(&b, store_intr->num_components, @@ -1144,7 +1144,7 @@ is_direct_uniform_load(nir_def *def, nir_scalar *s) if (ssa->parent_instr->type != nir_instr_type_intrinsic) return false; - nir_intrinsic_instr *intr = nir_instr_as_intrinsic(ssa->parent_instr); + nir_intrinsic_instr *intr = nir_def_as_intrinsic(ssa); if (intr->intrinsic != nir_intrinsic_load_deref) return false; @@ -1213,13 +1213,13 @@ nir_clone_deref_instr(nir_builder *b, nir_variable *var, * we don't implement cloning the index SSA here. */ nir_load_const_instr *index = - nir_instr_as_load_const(deref->arr.index.ssa->parent_instr); + nir_def_as_load_const(deref->arr.index.ssa); return nir_build_deref_array_imm(b, parent, index->value->i64); } } case nir_deref_type_ptr_as_array: { nir_load_const_instr *index = - nir_instr_as_load_const(deref->arr.index.ssa->parent_instr); + nir_def_as_load_const(deref->arr.index.ssa); nir_def *ssa = nir_imm_intN_t(b, index->value->i64, parent->def.bit_size); return nir_build_deref_ptr_as_array(b, parent, ssa); @@ -1243,7 +1243,7 @@ replace_varying_input_by_uniform_load(nir_shader *shader, nir_variable *out_var = nir_intrinsic_get_var(store_intr, 0); - nir_intrinsic_instr *load = nir_instr_as_intrinsic(scalar->def->parent_instr); + nir_intrinsic_instr *load = nir_def_as_intrinsic(scalar->def); nir_deref_instr *deref = nir_src_as_deref(load->src[0]); nir_variable *uni_var = nir_deref_instr_get_variable(deref); uni_var = nir_clone_uniform_variable(shader, uni_var, false); diff --git a/src/compiler/nir/nir_loop_analyze.c b/src/compiler/nir/nir_loop_analyze.c index 33bab84d072..2784defc0fd 100644 --- a/src/compiler/nir/nir_loop_analyze.c +++ b/src/compiler/nir/nir_loop_analyze.c @@ -179,7 +179,7 @@ phi_instr_as_alu(nir_phi_instr *phi) if (src->src.ssa->parent_instr->type != nir_instr_type_alu) return NULL; - nir_alu_instr *alu = nir_instr_as_alu(src->src.ssa->parent_instr); + nir_alu_instr *alu = nir_def_as_alu(src->src.ssa); if (first == NULL) { first = alu; } else { @@ -267,7 +267,7 @@ compute_induction_information(loop_info_state *state) * of an unnested if rather than in a loop block. */ if (src->parent_instr->type == nir_instr_type_phi) { - nir_phi_instr *src_phi = nir_instr_as_phi(src->parent_instr); + nir_phi_instr *src_phi = nir_def_as_phi(src); nir_alu_instr *src_phi_alu = phi_instr_as_alu(src_phi); if (src_phi_alu) { src = &src_phi_alu->def; @@ -276,7 +276,7 @@ compute_induction_information(loop_info_state *state) if (src->parent_instr->type == nir_instr_type_alu && !var.update_src) { var.def = src; - nir_alu_instr *alu = nir_instr_as_alu(src->parent_instr); + nir_alu_instr *alu = nir_def_as_alu(src); /* Check for unsupported alu operations */ if (alu->op != nir_op_iadd && alu->op != nir_op_fadd && @@ -589,7 +589,7 @@ try_eval_const_alu(nir_const_value *dest, nir_scalar alu_s, const nir_scalar *or const nir_const_value *replacements, unsigned num_replacements, unsigned execution_mode) { - nir_alu_instr *alu = nir_instr_as_alu(alu_s.def->parent_instr); + nir_alu_instr *alu = nir_def_as_alu(alu_s.def); if (nir_op_infos[alu->op].output_size) return false; @@ -889,7 +889,7 @@ calculate_iterations(nir_scalar basis, nir_scalar limit_basis, * condition and if so we assume we need to step the initial value. */ unsigned trip_offset = 0; - nir_alu_instr *cond_alu = nir_instr_as_alu(cond.def->parent_instr); + nir_alu_instr *cond_alu = nir_def_as_alu(cond.def); if (cond_alu->src[0].src.ssa == &alu->def || cond_alu->src[1].src.ssa == &alu->def) { trip_offset = 1; @@ -1305,7 +1305,7 @@ force_unroll_heuristics(loop_info_state *state, nir_block *block) if (sampler_idx >= 0) { nir_deref_instr *deref = - nir_instr_as_deref(tex_instr->src[sampler_idx].src.ssa->parent_instr); + nir_def_as_deref(tex_instr->src[sampler_idx].src.ssa); if (force_unroll_array_access(state, deref, true)) return true; } diff --git a/src/compiler/nir/nir_loop_analyze.h b/src/compiler/nir/nir_loop_analyze.h index 8750731d51d..cd88142b893 100644 --- a/src/compiler/nir/nir_loop_analyze.h +++ b/src/compiler/nir/nir_loop_analyze.h @@ -99,7 +99,7 @@ nir_is_terminator_condition_with_two_inputs(nir_scalar cond) if (!nir_scalar_is_alu(cond)) return false; - nir_alu_instr *alu = nir_instr_as_alu(cond.def->parent_instr); + nir_alu_instr *alu = nir_def_as_alu(cond.def); return nir_alu_instr_is_comparison(alu) && nir_op_infos[alu->op].num_inputs == 2; } @@ -110,7 +110,7 @@ nir_is_supported_terminator_condition(nir_scalar cond) if (!nir_scalar_is_alu(cond)) return false; - nir_alu_instr *alu = nir_instr_as_alu(cond.def->parent_instr); + nir_alu_instr *alu = nir_def_as_alu(cond.def); return nir_alu_instr_is_comparison(alu) && (nir_op_infos[alu->op].num_inputs == 2 || (alu->op == nir_op_inot && diff --git a/src/compiler/nir/nir_lower_bit_size.c b/src/compiler/nir/nir_lower_bit_size.c index 91214d25c8e..b8df2ac8091 100644 --- a/src/compiler/nir/nir_lower_bit_size.c +++ b/src/compiler/nir/nir_lower_bit_size.c @@ -70,7 +70,7 @@ before_conversion(nir_builder *bld, nir_alu_type type, unsigned bit_size, nir_de if (def->parent_instr->type != nir_instr_type_alu) { return NULL; } - nir_alu_instr *alu_instr = nir_instr_as_alu(def->parent_instr); + nir_alu_instr *alu_instr = nir_def_as_alu(def); if (alu_instr->op != nir_type_conversion_op((nir_alu_type)(type | bit_size), (nir_alu_type)(type | def->bit_size), nir_rounding_mode_undef) || diff --git a/src/compiler/nir/nir_lower_flatshade.c b/src/compiler/nir/nir_lower_flatshade.c index fd587333e7e..58566144549 100644 --- a/src/compiler/nir/nir_lower_flatshade.c +++ b/src/compiler/nir/nir_lower_flatshade.c @@ -43,13 +43,13 @@ lower_input_io(nir_builder *b, nir_intrinsic_instr *intr, void *data) if (!check_location(sem.location)) return false; nir_def *interp = intr->src[0].ssa; - nir_intrinsic_instr *interp_intr = nir_instr_as_intrinsic(interp->parent_instr); + nir_intrinsic_instr *interp_intr = nir_def_as_intrinsic(interp); if (nir_intrinsic_interp_mode(interp_intr) != INTERP_MODE_NONE) return false; b->cursor = nir_before_instr(&intr->instr); nir_def *load = nir_load_input(b, intr->num_components, intr->def.bit_size, intr->src[1].ssa); - nir_intrinsic_instr *new_intr = nir_instr_as_intrinsic(load->parent_instr); + nir_intrinsic_instr *new_intr = nir_def_as_intrinsic(load); nir_intrinsic_copy_const_indices(new_intr, intr); nir_def_replace(&intr->def, load); return true; diff --git a/src/compiler/nir/nir_lower_flrp.c b/src/compiler/nir/nir_lower_flrp.c index 57416129927..6a03d1d03b8 100644 --- a/src/compiler/nir/nir_lower_flrp.c +++ b/src/compiler/nir/nir_lower_flrp.c @@ -52,16 +52,16 @@ replace_with_strict_ffma(struct nir_builder *bld, struct u_vector *dead_flrp, nir_def *const c = nir_ssa_for_alu_src(bld, alu, 2); nir_def *const neg_a = nir_fneg(bld, a); - nir_instr_as_alu(neg_a->parent_instr)->exact = alu->exact; - nir_instr_as_alu(neg_a->parent_instr)->fp_fast_math = alu->fp_fast_math; + nir_def_as_alu(neg_a)->exact = alu->exact; + nir_def_as_alu(neg_a)->fp_fast_math = alu->fp_fast_math; nir_def *const inner_ffma = nir_ffma(bld, neg_a, c, a); - nir_instr_as_alu(inner_ffma->parent_instr)->exact = alu->exact; - nir_instr_as_alu(inner_ffma->parent_instr)->fp_fast_math = alu->fp_fast_math; + nir_def_as_alu(inner_ffma)->exact = alu->exact; + nir_def_as_alu(inner_ffma)->fp_fast_math = alu->fp_fast_math; nir_def *const outer_ffma = nir_ffma(bld, b, c, inner_ffma); - nir_instr_as_alu(outer_ffma->parent_instr)->exact = alu->exact; - nir_instr_as_alu(outer_ffma->parent_instr)->fp_fast_math = alu->fp_fast_math; + nir_def_as_alu(outer_ffma)->exact = alu->exact; + nir_def_as_alu(outer_ffma)->fp_fast_math = alu->fp_fast_math; nir_def_rewrite_uses(&alu->def, outer_ffma); @@ -84,21 +84,21 @@ replace_with_single_ffma(struct nir_builder *bld, struct u_vector *dead_flrp, nir_def *const c = nir_ssa_for_alu_src(bld, alu, 2); nir_def *const neg_c = nir_fneg(bld, c); - nir_instr_as_alu(neg_c->parent_instr)->exact = alu->exact; - nir_instr_as_alu(neg_c->parent_instr)->fp_fast_math = alu->fp_fast_math; + nir_def_as_alu(neg_c)->exact = alu->exact; + nir_def_as_alu(neg_c)->fp_fast_math = alu->fp_fast_math; nir_def *const one_minus_c = nir_fadd(bld, nir_imm_floatN_t(bld, 1.0f, c->bit_size), neg_c); - nir_instr_as_alu(one_minus_c->parent_instr)->exact = alu->exact; - nir_instr_as_alu(one_minus_c->parent_instr)->fp_fast_math = alu->fp_fast_math; + nir_def_as_alu(one_minus_c)->exact = alu->exact; + nir_def_as_alu(one_minus_c)->fp_fast_math = alu->fp_fast_math; nir_def *const b_times_c = nir_fmul(bld, b, c); - nir_instr_as_alu(b_times_c->parent_instr)->exact = alu->exact; - nir_instr_as_alu(b_times_c->parent_instr)->fp_fast_math = alu->fp_fast_math; + nir_def_as_alu(b_times_c)->exact = alu->exact; + nir_def_as_alu(b_times_c)->fp_fast_math = alu->fp_fast_math; nir_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_instr_as_alu(final_ffma->parent_instr)->fp_fast_math = alu->fp_fast_math; + nir_def_as_alu(final_ffma)->exact = alu->exact; + nir_def_as_alu(final_ffma)->fp_fast_math = alu->fp_fast_math; nir_def_rewrite_uses(&alu->def, final_ffma); @@ -121,25 +121,25 @@ replace_with_strict(struct nir_builder *bld, struct u_vector *dead_flrp, nir_def *const c = nir_ssa_for_alu_src(bld, alu, 2); nir_def *const neg_c = nir_fneg(bld, c); - nir_instr_as_alu(neg_c->parent_instr)->exact = alu->exact; - nir_instr_as_alu(neg_c->parent_instr)->fp_fast_math = alu->fp_fast_math; + nir_def_as_alu(neg_c)->exact = alu->exact; + nir_def_as_alu(neg_c)->fp_fast_math = alu->fp_fast_math; nir_def *const one_minus_c = nir_fadd(bld, nir_imm_floatN_t(bld, 1.0f, c->bit_size), neg_c); - nir_instr_as_alu(one_minus_c->parent_instr)->exact = alu->exact; - nir_instr_as_alu(one_minus_c->parent_instr)->fp_fast_math = alu->fp_fast_math; + nir_def_as_alu(one_minus_c)->exact = alu->exact; + nir_def_as_alu(one_minus_c)->fp_fast_math = alu->fp_fast_math; nir_def *const first_product = nir_fmul(bld, a, one_minus_c); - nir_instr_as_alu(first_product->parent_instr)->exact = alu->exact; - nir_instr_as_alu(first_product->parent_instr)->fp_fast_math = alu->fp_fast_math; + nir_def_as_alu(first_product)->exact = alu->exact; + nir_def_as_alu(first_product)->fp_fast_math = alu->fp_fast_math; nir_def *const second_product = nir_fmul(bld, b, c); - nir_instr_as_alu(second_product->parent_instr)->exact = alu->exact; - nir_instr_as_alu(second_product->parent_instr)->fp_fast_math = alu->fp_fast_math; + nir_def_as_alu(second_product)->exact = alu->exact; + nir_def_as_alu(second_product)->fp_fast_math = alu->fp_fast_math; nir_def *const sum = nir_fadd(bld, first_product, second_product); - nir_instr_as_alu(sum->parent_instr)->exact = alu->exact; - nir_instr_as_alu(sum->parent_instr)->fp_fast_math = alu->fp_fast_math; + nir_def_as_alu(sum)->exact = alu->exact; + nir_def_as_alu(sum)->fp_fast_math = alu->fp_fast_math; nir_def_rewrite_uses(&alu->def, sum); @@ -162,20 +162,20 @@ replace_with_fast(struct nir_builder *bld, struct u_vector *dead_flrp, nir_def *const c = nir_ssa_for_alu_src(bld, alu, 2); nir_def *const neg_a = nir_fneg(bld, a); - nir_instr_as_alu(neg_a->parent_instr)->exact = alu->exact; - nir_instr_as_alu(neg_a->parent_instr)->fp_fast_math = alu->fp_fast_math; + nir_def_as_alu(neg_a)->exact = alu->exact; + nir_def_as_alu(neg_a)->fp_fast_math = alu->fp_fast_math; nir_def *const b_minus_a = nir_fadd(bld, b, neg_a); - nir_instr_as_alu(b_minus_a->parent_instr)->exact = alu->exact; - nir_instr_as_alu(b_minus_a->parent_instr)->fp_fast_math = alu->fp_fast_math; + nir_def_as_alu(b_minus_a)->exact = alu->exact; + nir_def_as_alu(b_minus_a)->fp_fast_math = alu->fp_fast_math; nir_def *const product = nir_fmul(bld, c, b_minus_a); - nir_instr_as_alu(product->parent_instr)->exact = alu->exact; - nir_instr_as_alu(product->parent_instr)->fp_fast_math = alu->fp_fast_math; + nir_def_as_alu(product)->exact = alu->exact; + nir_def_as_alu(product)->fp_fast_math = alu->fp_fast_math; nir_def *const sum = nir_fadd(bld, a, product); - nir_instr_as_alu(sum->parent_instr)->exact = alu->exact; - nir_instr_as_alu(sum->parent_instr)->fp_fast_math = alu->fp_fast_math; + nir_def_as_alu(sum)->exact = alu->exact; + nir_def_as_alu(sum)->fp_fast_math = alu->fp_fast_math; nir_def_rewrite_uses(&alu->def, sum); @@ -201,27 +201,27 @@ replace_with_expanded_ffma_and_add(struct nir_builder *bld, nir_def *const c = nir_ssa_for_alu_src(bld, alu, 2); nir_def *const b_times_c = nir_fmul(bld, b, c); - nir_instr_as_alu(b_times_c->parent_instr)->exact = alu->exact; - nir_instr_as_alu(b_times_c->parent_instr)->fp_fast_math = alu->fp_fast_math; + nir_def_as_alu(b_times_c)->exact = alu->exact; + nir_def_as_alu(b_times_c)->fp_fast_math = alu->fp_fast_math; nir_def *inner_sum; if (subtract_c) { nir_def *const neg_c = nir_fneg(bld, c); - nir_instr_as_alu(neg_c->parent_instr)->exact = alu->exact; - nir_instr_as_alu(neg_c->parent_instr)->fp_fast_math = alu->fp_fast_math; + nir_def_as_alu(neg_c)->exact = alu->exact; + nir_def_as_alu(neg_c)->fp_fast_math = alu->fp_fast_math; inner_sum = nir_fadd(bld, a, neg_c); } else { inner_sum = nir_fadd(bld, a, c); } - nir_instr_as_alu(inner_sum->parent_instr)->exact = alu->exact; - nir_instr_as_alu(inner_sum->parent_instr)->fp_fast_math = alu->fp_fast_math; + nir_def_as_alu(inner_sum)->exact = alu->exact; + nir_def_as_alu(inner_sum)->fp_fast_math = alu->fp_fast_math; nir_def *const outer_sum = nir_fadd(bld, inner_sum, b_times_c); - nir_instr_as_alu(outer_sum->parent_instr)->exact = alu->exact; - nir_instr_as_alu(outer_sum->parent_instr)->fp_fast_math = alu->fp_fast_math; + nir_def_as_alu(outer_sum)->exact = alu->exact; + nir_def_as_alu(outer_sum)->fp_fast_math = alu->fp_fast_math; nir_def_rewrite_uses(&alu->def, outer_sum); diff --git a/src/compiler/nir/nir_lower_image.c b/src/compiler/nir/nir_lower_image.c index 3ee0f8bedf8..15e60485aa4 100644 --- a/src/compiler/nir/nir_lower_image.c +++ b/src/compiler/nir/nir_lower_image.c @@ -108,7 +108,7 @@ lower_image_to_fragment_mask_load(nir_builder *b, nir_intrinsic_instr *intrin) .access = nir_intrinsic_access(intrin)); /* fix intrinsic op */ - nir_intrinsic_instr *fmask_load = nir_instr_as_intrinsic(fmask->parent_instr); + nir_intrinsic_instr *fmask_load = nir_def_as_intrinsic(fmask); fmask_load->intrinsic = fmask_op; /* extract real color buffer index from fmask buffer */ diff --git a/src/compiler/nir/nir_lower_interpolation.c b/src/compiler/nir/nir_lower_interpolation.c index aea5d897833..8369eeb4b88 100644 --- a/src/compiler/nir/nir_lower_interpolation.c +++ b/src/compiler/nir/nir_lower_interpolation.c @@ -49,7 +49,7 @@ nir_lower_interpolation_instr(nir_builder *b, nir_instr *instr, void *cb_data) return false; nir_intrinsic_instr *bary_intrinsic = - nir_instr_as_intrinsic(intr->src[0].ssa->parent_instr); + nir_def_as_intrinsic(intr->src[0].ssa); /* Leave VARYING_SLOT_POS alone */ if (nir_intrinsic_base(intr) == VARYING_SLOT_POS) diff --git a/src/compiler/nir/nir_lower_locals_to_regs.c b/src/compiler/nir/nir_lower_locals_to_regs.c index f366fd0015d..6996eefb34b 100644 --- a/src/compiler/nir/nir_lower_locals_to_regs.c +++ b/src/compiler/nir/nir_lower_locals_to_regs.c @@ -147,7 +147,7 @@ get_deref_reg_location(nir_deref_instr *deref, nir_builder *b = &state->builder; nir_def *reg = get_reg_for_deref(deref, state); - nir_intrinsic_instr *decl = nir_instr_as_intrinsic(reg->parent_instr); + nir_intrinsic_instr *decl = nir_def_as_intrinsic(reg); /* It is possible for a user to create a shader that has an array with a * single element and then proceed to access it indirectly. Indirectly diff --git a/src/compiler/nir/nir_lower_mediump.c b/src/compiler/nir/nir_lower_mediump.c index 54080465b54..13b0c3b4530 100644 --- a/src/compiler/nir/nir_lower_mediump.c +++ b/src/compiler/nir/nir_lower_mediump.c @@ -95,7 +95,7 @@ nir_lower_mediump_io(nir_shader *nir, nir_variable_mode modes, sem.location == FRAG_RESULT_DEPTH); if (!sem.medium_precision && (is_varying || is_fragdepth || val->parent_instr->type != nir_instr_type_alu || - nir_instr_as_alu(val->parent_instr)->op != upconvert_op)) { + nir_def_as_alu(val)->op != upconvert_op)) { continue; } @@ -521,7 +521,7 @@ can_opt_16bit_src(nir_def *ssa, nir_alu_type src_type, bool sext_matters) else if (opt_i16_u16) can_opt &= (const_is_u16(comp) || const_is_i16(comp)); } else if (nir_scalar_is_alu(comp)) { - nir_alu_instr *alu = nir_instr_as_alu(comp.def->parent_instr); + nir_alu_instr *alu = nir_def_as_alu(comp.def); bool is_16bit = alu->src[0].src.ssa->bit_size == 16; if ((alu->op == nir_op_f2f32 && is_16bit) || diff --git a/src/compiler/nir/nir_lower_point_smooth.c b/src/compiler/nir/nir_lower_point_smooth.c index 2f3e3e6d8b6..ff72572bd48 100644 --- a/src/compiler/nir/nir_lower_point_smooth.c +++ b/src/compiler/nir/nir_lower_point_smooth.c @@ -96,7 +96,7 @@ lower_point_smooth(nir_builder *b, nir_intrinsic_instr *intr, void *state) */ if (s->found_baryc) { nir_intrinsic_instr *baryc_intr = - nir_instr_as_intrinsic(baryc->parent_instr); + nir_def_as_intrinsic(baryc); /* Overwrite the intrinsic we just created. */ baryc_intr->intrinsic = s->found_baryc->intrinsic; diff --git a/src/compiler/nir/nir_lower_reg_intrinsics_to_ssa.c b/src/compiler/nir/nir_lower_reg_intrinsics_to_ssa.c index 9ab9b96c74a..448edf58ea7 100644 --- a/src/compiler/nir/nir_lower_reg_intrinsics_to_ssa.c +++ b/src/compiler/nir/nir_lower_reg_intrinsics_to_ssa.c @@ -68,7 +68,7 @@ rewrite_load(nir_intrinsic_instr *load, struct regs_to_ssa_state *state) if (!value) return; - nir_intrinsic_instr *decl = nir_instr_as_intrinsic(reg->parent_instr); + nir_intrinsic_instr *decl = nir_def_as_intrinsic(reg); nir_def *def = nir_phi_builder_value_get_block_def(value, block); nir_def_replace(&load->def, def); @@ -88,7 +88,7 @@ rewrite_store(nir_intrinsic_instr *store, struct regs_to_ssa_state *state) if (!value) return; - nir_intrinsic_instr *decl = nir_instr_as_intrinsic(reg->parent_instr); + nir_intrinsic_instr *decl = nir_def_as_intrinsic(reg); unsigned num_components = nir_intrinsic_num_components(decl); unsigned write_mask = nir_intrinsic_write_mask(store); diff --git a/src/compiler/nir/nir_lower_robust_access.c b/src/compiler/nir/nir_lower_robust_access.c index 73661070d1d..fa58516046d 100644 --- a/src/compiler/nir/nir_lower_robust_access.c +++ b/src/compiler/nir/nir_lower_robust_access.c @@ -125,7 +125,7 @@ lower_image(nir_builder *b, nir_intrinsic_instr *instr, bool deref) instr->src[0].ssa, nir_imm_int(b, 0), .image_array = is_array, .image_dim = dim); if (deref) { - nir_instr_as_intrinsic(size->parent_instr)->intrinsic = + nir_def_as_intrinsic(size)->intrinsic = nir_intrinsic_image_deref_size; } @@ -143,7 +143,7 @@ lower_image(nir_builder *b, nir_intrinsic_instr *instr, bool deref) nir_def *samples = nir_image_samples(b, 32, instr->src[0].ssa, .image_array = is_array, .image_dim = dim); if (deref) { - nir_instr_as_intrinsic(samples->parent_instr)->intrinsic = + nir_def_as_intrinsic(samples)->intrinsic = nir_intrinsic_image_deref_samples; } diff --git a/src/compiler/nir/nir_lower_samplers.c b/src/compiler/nir/nir_lower_samplers.c index 8d7b9b57509..3685df5c3e1 100644 --- a/src/compiler/nir/nir_lower_samplers.c +++ b/src/compiler/nir/nir_lower_samplers.c @@ -37,10 +37,10 @@ lower_tex_src_to_offset(nir_builder *b, bool is_sampler = src->src_type == nir_tex_src_sampler_deref; /* We compute first the offsets */ - nir_deref_instr *deref = nir_instr_as_deref(src->src.ssa->parent_instr); + nir_deref_instr *deref = nir_def_as_deref(src->src.ssa); while (deref->deref_type != nir_deref_type_var) { nir_deref_instr *parent = - nir_instr_as_deref(deref->parent.ssa->parent_instr); + nir_def_as_deref(deref->parent.ssa); assert(deref->deref_type == nir_deref_type_array); diff --git a/src/compiler/nir/nir_lower_tex_shadow.c b/src/compiler/nir/nir_lower_tex_shadow.c index 7e772f5570c..90e00b96821 100644 --- a/src/compiler/nir/nir_lower_tex_shadow.c +++ b/src/compiler/nir/nir_lower_tex_shadow.c @@ -92,7 +92,7 @@ nir_lower_tex_shadow_impl(nir_builder *b, nir_instr *instr, void *options) int sampler_index = nir_tex_instr_src_index(tex, nir_tex_src_sampler_deref); if (sampler_index >= 0) { - sampler_deref = nir_instr_as_deref(tex->src[sampler_index].src.ssa->parent_instr); + sampler_deref = nir_def_as_deref(tex->src[sampler_index].src.ssa); sampler = nir_deref_instr_get_variable(sampler_deref); sampler_binding = sampler ? sampler->data.binding : 0; } diff --git a/src/compiler/nir/nir_lower_ubo_vec4.c b/src/compiler/nir/nir_lower_ubo_vec4.c index 6d387955e11..d05970ac6be 100644 --- a/src/compiler/nir/nir_lower_ubo_vec4.c +++ b/src/compiler/nir/nir_lower_ubo_vec4.c @@ -77,7 +77,7 @@ create_load(nir_builder *b, nir_def *block, nir_def *offset, unsigned bit_size, unsigned num_components) { nir_def *def = nir_load_ubo_vec4(b, num_components, bit_size, block, offset); - return nir_instr_as_intrinsic(def->parent_instr); + return nir_def_as_intrinsic(def); } static nir_def * diff --git a/src/compiler/nir/nir_lower_uniforms_to_ubo.c b/src/compiler/nir/nir_lower_uniforms_to_ubo.c index 148cb21bead..717b87d97a9 100644 --- a/src/compiler/nir/nir_lower_uniforms_to_ubo.c +++ b/src/compiler/nir/nir_lower_uniforms_to_ubo.c @@ -86,7 +86,7 @@ nir_lower_uniforms_to_ubo_instr(nir_builder *b, nir_instr *instr, void *data) ubo_idx, nir_iadd_imm(b, nir_amul_imm(b, uniform_offset, multiplier), nir_intrinsic_base(intr) * multiplier)); - nir_intrinsic_instr *load = nir_instr_as_intrinsic(load_result->parent_instr); + nir_intrinsic_instr *load = nir_def_as_intrinsic(load_result); /* If it's const, set the alignment to our known constant offset. If * not, set it to a pessimistic value based on the multiplier (or the diff --git a/src/compiler/nir/nir_lower_var_copies.c b/src/compiler/nir/nir_lower_var_copies.c index 9fd07cbbb2a..6c5ddc3b013 100644 --- a/src/compiler/nir/nir_lower_var_copies.c +++ b/src/compiler/nir/nir_lower_var_copies.c @@ -96,8 +96,8 @@ nir_lower_deref_copy_instr(nir_builder *b, nir_intrinsic_instr *copy) /* Unfortunately, there's just no good way to handle wildcards except to * flip the chain around and walk the list from variable to final pointer. */ - nir_deref_instr *dst = nir_instr_as_deref(copy->src[0].ssa->parent_instr); - nir_deref_instr *src = nir_instr_as_deref(copy->src[1].ssa->parent_instr); + nir_deref_instr *dst = nir_def_as_deref(copy->src[0].ssa); + nir_deref_instr *src = nir_def_as_deref(copy->src[1].ssa); nir_deref_path dst_path, src_path; nir_deref_path_init(&dst_path, dst, NULL); diff --git a/src/compiler/nir/nir_lower_vec_to_regs.c b/src/compiler/nir/nir_lower_vec_to_regs.c index 1974621516b..a0a5e4765ed 100644 --- a/src/compiler/nir/nir_lower_vec_to_regs.c +++ b/src/compiler/nir/nir_lower_vec_to_regs.c @@ -89,7 +89,7 @@ try_coalesce(nir_builder *b, nir_def *reg, nir_alu_instr *vec, return 0; nir_alu_instr *src_alu = - nir_instr_as_alu(vec->src[start_idx].src.ssa->parent_instr); + nir_def_as_alu(vec->src[start_idx].src.ssa); if (has_replicated_dest(src_alu)) { /* The fdot instruction is special: It replicates its result to all diff --git a/src/compiler/nir/nir_mod_analysis.c b/src/compiler/nir/nir_mod_analysis.c index ad5d79db516..252711a3737 100644 --- a/src/compiler/nir/nir_mod_analysis.c +++ b/src/compiler/nir/nir_mod_analysis.c @@ -57,7 +57,7 @@ nir_mod_analysis(nir_scalar val, nir_alu_type val_type, unsigned div, unsigned * switch (val.def->parent_instr->type) { case nir_instr_type_load_const: { nir_load_const_instr *load = - nir_instr_as_load_const(val.def->parent_instr); + nir_def_as_load_const(val.def); nir_alu_type base_type = nir_alu_type_get_base_type(val_type); if (base_type == nir_type_uint) { @@ -83,7 +83,7 @@ nir_mod_analysis(nir_scalar val, nir_alu_type val_type, unsigned div, unsigned * } case nir_instr_type_alu: { - nir_alu_instr *alu = nir_instr_as_alu(val.def->parent_instr); + nir_alu_instr *alu = nir_def_as_alu(val.def); if (alu->def.num_components != 1) return false; diff --git a/src/compiler/nir/nir_opt_if.c b/src/compiler/nir/nir_opt_if.c index 077a8b22646..9557919a2fc 100644 --- a/src/compiler/nir/nir_opt_if.c +++ b/src/compiler/nir/nir_opt_if.c @@ -162,7 +162,7 @@ opt_peel_loop_initial_if(nir_loop *loop) if (cond->parent_instr->type != nir_instr_type_phi) return false; - nir_phi_instr *cond_phi = nir_instr_as_phi(cond->parent_instr); + nir_phi_instr *cond_phi = nir_def_as_phi(cond); if (cond->parent_instr->block != header_block) return false; @@ -296,7 +296,7 @@ is_trivial_bcsel(const nir_instr *instr, bool allow_non_phi_src) } } - nir_foreach_phi_src(src, nir_instr_as_phi(bcsel->src[0].src.ssa->parent_instr)) { + nir_foreach_phi_src(src, nir_def_as_phi(bcsel->src[0].src.ssa)) { if (!nir_src_is_const(src->src)) return false; } @@ -636,7 +636,7 @@ opt_simplify_bcsel_of_phi(nir_builder *b, nir_loop *loop) nir_alu_instr *const bcsel = nir_instr_as_alu(instr); nir_phi_instr *const cond_phi = - nir_instr_as_phi(bcsel->src[0].src.ssa->parent_instr); + nir_def_as_phi(bcsel->src[0].src.ssa); bool entry_val = false, continue_val = false; if (!phi_has_constant_from_outside_and_one_from_inside_loop(cond_phi, @@ -662,12 +662,12 @@ opt_simplify_bcsel_of_phi(nir_builder *b, nir_loop *loop) nir_block *continue_block = find_continue_block(loop); nir_phi_instr *const phi = nir_phi_instr_create(b->shader); nir_phi_instr_add_src(phi, prev_block, - nir_phi_get_src_from_block(nir_instr_as_phi(bcsel->src[entry_src].src.ssa->parent_instr), + nir_phi_get_src_from_block(nir_def_as_phi(bcsel->src[entry_src].src.ssa), prev_block) ->src.ssa); nir_phi_instr_add_src(phi, continue_block, - nir_phi_get_src_from_block(nir_instr_as_phi(bcsel->src[continue_src].src.ssa->parent_instr), + nir_phi_get_src_from_block(nir_def_as_phi(bcsel->src[continue_src].src.ssa), continue_block) ->src.ssa); @@ -1089,7 +1089,7 @@ opt_if_rewrite_uniform_uses(nir_builder *b, nir_if *nif, nir_scalar cond, unsign if (!nir_scalar_is_intrinsic(src_uni)) continue; - nir_intrinsic_instr *intrin = nir_instr_as_intrinsic(src_uni.def->parent_instr); + nir_intrinsic_instr *intrin = nir_def_as_intrinsic(src_uni.def); if (intrin->intrinsic != nir_intrinsic_read_first_invocation && intrin->intrinsic != nir_intrinsic_read_invocation && (intrin->intrinsic != nir_intrinsic_reduce || nir_intrinsic_cluster_size(intrin))) diff --git a/src/compiler/nir/nir_opt_load_store_vectorize.c b/src/compiler/nir/nir_opt_load_store_vectorize.c index 6bc670afced..e364611892b 100644 --- a/src/compiler/nir/nir_opt_load_store_vectorize.c +++ b/src/compiler/nir/nir_opt_load_store_vectorize.c @@ -344,7 +344,7 @@ parse_offset(nir_scalar *base, uint64_t *base_mul, uint64_t *offset) } while (progress); if (base->def->parent_instr->type == nir_instr_type_intrinsic) { - nir_intrinsic_instr *intrin = nir_instr_as_intrinsic(base->def->parent_instr); + nir_intrinsic_instr *intrin = nir_def_as_intrinsic(base->def); if (intrin->intrinsic == nir_intrinsic_load_vulkan_descriptor) base->def = NULL; } diff --git a/src/compiler/nir/nir_opt_loop.c b/src/compiler/nir/nir_opt_loop.c index 12532244012..72c850bb0f6 100644 --- a/src/compiler/nir/nir_opt_loop.c +++ b/src/compiler/nir/nir_opt_loop.c @@ -319,7 +319,7 @@ can_constant_fold(nir_scalar scalar, nir_block *loop_header) return false; nir_block *preheader = nir_block_cf_tree_prev(loop_header); - nir_phi_instr *phi = nir_instr_as_phi(scalar.def->parent_instr); + nir_phi_instr *phi = nir_def_as_phi(scalar.def); nir_phi_src *src = nir_phi_get_src_from_block(phi, preheader); return can_constant_fold(nir_get_scalar(src->src.ssa, 0), loop_header); } diff --git a/src/compiler/nir/nir_opt_loop_unroll.c b/src/compiler/nir/nir_opt_loop_unroll.c index 77dcf194447..3ea4b6c1e67 100644 --- a/src/compiler/nir/nir_opt_loop_unroll.c +++ b/src/compiler/nir/nir_opt_loop_unroll.c @@ -642,7 +642,7 @@ comparison_contains_instr(nir_scalar cond_scalar, nir_instr *instr) { if (nir_is_terminator_condition_with_two_inputs(cond_scalar)) { nir_alu_instr *comparison = - nir_instr_as_alu(cond_scalar.def->parent_instr); + nir_def_as_alu(cond_scalar.def); return comparison->src[0].src.ssa->parent_instr == instr || comparison->src[1].src.ssa->parent_instr == instr; } @@ -691,7 +691,7 @@ remove_out_of_bounds_induction_use(nir_shader *shader, nir_loop *loop, trip_count)) { if (intrin->intrinsic == nir_intrinsic_load_deref) { nir_alu_instr *term_alu = - nir_instr_as_alu(term->nif->condition.ssa->parent_instr); + nir_def_as_alu(term->nif->condition.ssa); b.cursor = nir_before_instr(term->nif->condition.ssa->parent_instr); /* If the out of bounds load is used in the comparison of the diff --git a/src/compiler/nir/nir_opt_offsets.c b/src/compiler/nir/nir_opt_offsets.c index eb8d8767209..562078491c1 100644 --- a/src/compiler/nir/nir_opt_offsets.c +++ b/src/compiler/nir/nir_opt_offsets.c @@ -43,7 +43,7 @@ try_extract_const_addition(nir_builder *b, nir_scalar val, opt_offsets_state *st if (!nir_scalar_is_alu(val)) return val; - nir_alu_instr *alu = nir_instr_as_alu(val.def->parent_instr); + nir_alu_instr *alu = nir_def_as_alu(val.def); if (alu->op != nir_op_iadd) return val; diff --git a/src/compiler/nir/nir_opt_ray_queries.c b/src/compiler/nir/nir_opt_ray_queries.c index aab10b2acd3..6d98cc73338 100644 --- a/src/compiler/nir/nir_opt_ray_queries.c +++ b/src/compiler/nir/nir_opt_ray_queries.c @@ -44,13 +44,12 @@ mark_query_read(struct set *queries, nir_variable *query; if (rq_def->parent_instr->type == nir_instr_type_intrinsic) { nir_intrinsic_instr *load_deref = - nir_instr_as_intrinsic(rq_def->parent_instr); + nir_def_as_intrinsic(rq_def); assert(load_deref->intrinsic == nir_intrinsic_load_deref); query = nir_intrinsic_get_var(load_deref, 0); } else if (rq_def->parent_instr->type == nir_instr_type_deref) { - query = nir_deref_instr_get_variable( - nir_instr_as_deref(rq_def->parent_instr)); + query = nir_deref_instr_get_variable(nir_def_as_deref(rq_def)); } else { return; } @@ -280,7 +279,7 @@ nir_opt_ray_query_ranges(nir_shader *shader) continue; nir_deref_instr *ray_query_deref = - nir_instr_as_deref(intrinsic->src[0].ssa->parent_instr); + nir_def_as_deref(intrinsic->src[0].ssa); if (ray_query_deref->deref_type != nir_deref_type_var) continue; @@ -397,7 +396,7 @@ nir_opt_ray_query_ranges(nir_shader *shader) util_dynarray_foreach(&range->instrs, nir_instr *, instr) { nir_intrinsic_instr *intrinsic = nir_instr_as_intrinsic(*instr); nir_deref_instr *ray_query_deref = - nir_instr_as_deref(intrinsic->src[0].ssa->parent_instr); + nir_def_as_deref(intrinsic->src[0].ssa); if (ray_query_deref->var != range->variable) { ray_query_deref->var = range->variable; progress = true; diff --git a/src/compiler/nir/nir_opt_reassociate.c b/src/compiler/nir/nir_opt_reassociate.c index 370e0329826..b2788e53309 100644 --- a/src/compiler/nir/nir_opt_reassociate.c +++ b/src/compiler/nir/nir_opt_reassociate.c @@ -214,7 +214,7 @@ can_reassociate(nir_alu_instr *alu) static void build_chain(struct chain *c, nir_scalar def, unsigned reserved_count) { - nir_alu_instr *alu = nir_instr_as_alu(def.def->parent_instr); + nir_alu_instr *alu = nir_def_as_alu(def.def); /* Conservative fast math handling: if ANY instruction along the chain is * exact, treat the whole chain as exact. Likewise for float controls. diff --git a/src/compiler/nir/nir_opt_remove_phis.c b/src/compiler/nir/nir_opt_remove_phis.c index 7f126a79834..501e170f0f7 100644 --- a/src/compiler/nir/nir_opt_remove_phis.c +++ b/src/compiler/nir/nir_opt_remove_phis.c @@ -46,8 +46,8 @@ phi_srcs_equal(nir_def *a, nir_def *b) /* nir_instrs_equal ignores exact/fast_math */ if (a->parent_instr->type == nir_instr_type_alu) { - nir_alu_instr *a_alu = nir_instr_as_alu(a->parent_instr); - nir_alu_instr *b_alu = nir_instr_as_alu(b->parent_instr); + nir_alu_instr *a_alu = nir_def_as_alu(a); + nir_alu_instr *b_alu = nir_def_as_alu(b); if (a_alu->exact != b_alu->exact || a_alu->fp_fast_math != b_alu->fp_fast_math) return false; } diff --git a/src/compiler/nir/nir_opt_shrink_vectors.c b/src/compiler/nir/nir_opt_shrink_vectors.c index e3ce2d624b3..235499d62b8 100644 --- a/src/compiler/nir/nir_opt_shrink_vectors.c +++ b/src/compiler/nir/nir_opt_shrink_vectors.c @@ -95,7 +95,7 @@ shrink_dest_to_read_mask(nir_def *def, bool shrink_start) nir_src *offset_src = NULL; if (def->parent_instr->type == nir_instr_type_intrinsic) { - intr = nir_instr_as_intrinsic(def->parent_instr); + intr = nir_def_as_intrinsic(def); offset_src = nir_get_io_offset_src(intr); } diff --git a/src/compiler/nir/nir_opt_uniform_atomics.c b/src/compiler/nir/nir_opt_uniform_atomics.c index 75b57e1dd0d..3cf385f5619 100644 --- a/src/compiler/nir/nir_opt_uniform_atomics.c +++ b/src/compiler/nir/nir_opt_uniform_atomics.c @@ -133,7 +133,7 @@ match_invocation_comparison(nir_scalar scalar) if (!nir_scalar_chase_alu_src(scalar, 1).def->divergent) return get_dim(nir_scalar_chase_alu_src(scalar, 0)); } else if (scalar.def->parent_instr->type == nir_instr_type_intrinsic) { - nir_intrinsic_instr *intrin = nir_instr_as_intrinsic(scalar.def->parent_instr); + nir_intrinsic_instr *intrin = nir_def_as_intrinsic(scalar.def); if (intrin->intrinsic == nir_intrinsic_elect) { return 0x8; } else if (intrin->intrinsic == nir_intrinsic_inverse_ballot) { diff --git a/src/compiler/nir/nir_opt_varyings.c b/src/compiler/nir/nir_opt_varyings.c index b1dff725163..113863e1b30 100644 --- a/src/compiler/nir/nir_opt_varyings.c +++ b/src/compiler/nir/nir_opt_varyings.c @@ -969,7 +969,7 @@ color_uses_shade_model(struct linkage_info *linkage, unsigned i) assert(iter->instr->intrinsic == nir_intrinsic_load_interpolated_input); nir_intrinsic_instr *baryc = - nir_instr_as_intrinsic(iter->instr->src[0].ssa->parent_instr); + nir_def_as_intrinsic(iter->instr->src[0].ssa); if (nir_intrinsic_interp_mode(baryc) == INTERP_MODE_NONE) return true; } @@ -985,7 +985,7 @@ get_interp_vec4_type(struct linkage_info *linkage, unsigned slot, assert(load->intrinsic == nir_intrinsic_load_interpolated_input); nir_intrinsic_instr *baryc = - nir_instr_as_intrinsic(load->src[0].ssa->parent_instr); + nir_def_as_intrinsic(load->src[0].ssa); enum fs_vec4_type base; if (color_uses_shade_model(linkage, slot)) @@ -1038,7 +1038,7 @@ build_convert_inf_to_nan(nir_builder *b, nir_def *x) { /* Do x*0 + x. The multiplication by 0 can't be optimized out. */ nir_def *fma = nir_ffma_imm1(b, x, 0, x); - nir_instr_as_alu(fma->parent_instr)->exact = true; + nir_def_as_alu(fma)->exact = true; return fma; } @@ -1053,7 +1053,7 @@ is_sysval(nir_instr *instr, gl_system_value sysval) if (intr->intrinsic == nir_intrinsic_load_deref) { nir_deref_instr *deref = - nir_instr_as_deref(intr->src[0].ssa->parent_instr); + nir_def_as_deref(intr->src[0].ssa); return nir_deref_mode_is_one_of(deref, nir_var_system_value) && nir_deref_instr_get_variable(deref)->data.location == sysval; @@ -2230,7 +2230,7 @@ clone_ssa_impl(struct linkage_info *linkage, nir_builder *b, nir_def *ssa) switch (ssa->parent_instr->type) { case nir_instr_type_load_const: clone = nir_build_imm(b, ssa->num_components, ssa->bit_size, - nir_instr_as_load_const(ssa->parent_instr)->value); + nir_def_as_load_const(ssa)->value); break; case nir_instr_type_undef: @@ -2238,7 +2238,7 @@ clone_ssa_impl(struct linkage_info *linkage, nir_builder *b, nir_def *ssa) break; case nir_instr_type_alu: { - nir_alu_instr *alu = nir_instr_as_alu(ssa->parent_instr); + nir_alu_instr *alu = nir_def_as_alu(ssa); if (alu->instr.pass_flags & FLAG_ALU_IS_TES_INTERP_LOAD) { /* We are cloning an interpolated TES load in the producer for @@ -2256,7 +2256,7 @@ clone_ssa_impl(struct linkage_info *linkage, nir_builder *b, nir_def *ssa) src[i] = clone_ssa_impl(linkage, b, alu->src[i].src.ssa); clone = nir_build_alu(b, alu->op, src[0], src[1], src[2], src[3]); - nir_alu_instr *alu_clone = nir_instr_as_alu(clone->parent_instr); + nir_alu_instr *alu_clone = nir_def_as_alu(clone); alu_clone->exact = alu->exact; alu_clone->no_signed_wrap = alu->no_signed_wrap; @@ -2275,12 +2275,12 @@ clone_ssa_impl(struct linkage_info *linkage, nir_builder *b, nir_def *ssa) /* Clone load_deref of uniform or ubo. It's the only thing that can * occur here. */ - nir_intrinsic_instr *intr = nir_instr_as_intrinsic(ssa->parent_instr); + nir_intrinsic_instr *intr = nir_def_as_intrinsic(ssa); switch (intr->intrinsic) { case nir_intrinsic_load_deref: { nir_def *ssa = clone_ssa_impl(linkage, b, intr->src[0].ssa); - clone = nir_load_deref(b, nir_instr_as_deref(ssa->parent_instr)); + clone = nir_load_deref(b, nir_def_as_deref(ssa)); break; } @@ -2304,7 +2304,7 @@ clone_ssa_impl(struct linkage_info *linkage, nir_builder *b, nir_def *ssa) } case nir_instr_type_deref: { - nir_deref_instr *deref = nir_instr_as_deref(ssa->parent_instr); + nir_deref_instr *deref = nir_def_as_deref(ssa); assert(nir_deref_mode_is_one_of(deref, nir_var_uniform | nir_var_mem_ubo)); /* Get the uniform from the original shader. */ @@ -2323,8 +2323,7 @@ clone_ssa_impl(struct linkage_info *linkage, nir_builder *b, nir_def *ssa) } else { nir_deref_instr *parent_orig = nir_deref_instr_parent(deref); nir_deref_instr *parent_clone = - nir_instr_as_deref(clone_ssa_impl(linkage, b, &parent_orig->def) - ->parent_instr); + nir_def_as_deref(clone_ssa_impl(linkage, b, &parent_orig->def)); switch (deref->deref_type) { case nir_deref_type_array: { @@ -2642,7 +2641,7 @@ get_input_qualifier(struct linkage_info *linkage, unsigned i) baryc->intrinsic == nir_intrinsic_load_barycentric_at_sample) { list_for_each_entry(struct list_node, iter, &slot->consumer.loads, head) { nir_intrinsic_instr *bar = - nir_instr_as_intrinsic(iter->instr->src[0].ssa->parent_instr); + nir_def_as_intrinsic(iter->instr->src[0].ssa); if (bar->intrinsic != nir_intrinsic_load_barycentric_centroid && bar->intrinsic != nir_intrinsic_load_barycentric_at_offset && diff --git a/src/compiler/nir/nir_print.c b/src/compiler/nir/nir_print.c index 7d65432c75e..8fed1ce2229 100644 --- a/src/compiler/nir/nir_print.c +++ b/src/compiler/nir/nir_print.c @@ -1012,7 +1012,7 @@ print_deref_link(const nir_deref_instr *instr, bool whole_chain, print_state *st } nir_deref_instr *parent = - nir_instr_as_deref(instr->parent.ssa->parent_instr); + nir_def_as_deref(instr->parent.ssa); /* Is the parent we're going to print a bare cast? */ const bool is_parent_cast = diff --git a/src/compiler/nir/nir_range_analysis.c b/src/compiler/nir/nir_range_analysis.c index ba20b21f873..b09cb959ce7 100644 --- a/src/compiler/nir/nir_range_analysis.c +++ b/src/compiler/nir/nir_range_analysis.c @@ -169,7 +169,7 @@ analyze_constant(const struct nir_alu_instr *instr, unsigned src, swizzle[i] = instr->src[src].swizzle[i]; const nir_load_const_instr *const load = - nir_instr_as_load_const(instr->src[src].src.ssa->parent_instr); + nir_def_as_load_const(instr->src[src].src.ssa); struct ssa_result_range r = { unknown, false, false, false }; @@ -497,7 +497,7 @@ get_fp_key(struct analysis_query *q) return 0; uintptr_t type_encoding; - uintptr_t ptr = (uintptr_t)nir_instr_as_alu(src->ssa->parent_instr); + uintptr_t ptr = (uintptr_t) nir_def_as_alu(src->ssa); /* The low 2 bits have to be zero or this whole scheme falls apart. */ assert((ptr & 0x3) == 0); @@ -596,7 +596,7 @@ process_fp_query(struct analysis_state *state, struct analysis_query *aq, uint32 } const struct nir_alu_instr *const alu = - nir_instr_as_alu(instr->src[src].src.ssa->parent_instr); + nir_def_as_alu(instr->src[src].src.ssa); /* Bail if the type of the instruction generating the value does not match * the type the value will be interpreted as. int/uint/bool can be @@ -1483,7 +1483,7 @@ search_phi_bcsel(nir_scalar scalar, nir_scalar *buf, unsigned buf_size, struct s _mesa_set_add(visited, scalar.def); if (scalar.def->parent_instr->type == nir_instr_type_phi) { - nir_phi_instr *phi = nir_instr_as_phi(scalar.def->parent_instr); + nir_phi_instr *phi = nir_def_as_phi(scalar.def); unsigned num_sources_left = exec_list_length(&phi->srcs); if (buf_size >= num_sources_left) { unsigned total_added = 0; @@ -1608,7 +1608,7 @@ get_intrinsic_uub(struct analysis_state *state, struct uub_query q, uint32_t *re nir_shader *shader = state->shader; const nir_unsigned_upper_bound_config *config = state->config; - nir_intrinsic_instr *intrin = nir_instr_as_intrinsic(q.scalar.def->parent_instr); + nir_intrinsic_instr *intrin = nir_def_as_intrinsic(q.scalar.def); switch (intrin->intrinsic) { case nir_intrinsic_load_local_invocation_index: /* The local invocation index is used under the hood by RADV for @@ -2017,7 +2017,7 @@ get_alu_uub(struct analysis_state *state, struct uub_query q, uint32_t *result, static void get_phi_uub(struct analysis_state *state, struct uub_query q, uint32_t *result, const uint32_t *src) { - nir_phi_instr *phi = nir_instr_as_phi(q.scalar.def->parent_instr); + nir_phi_instr *phi = nir_def_as_phi(q.scalar.def); if (exec_list_is_empty(&phi->srcs)) return; diff --git a/src/compiler/nir/nir_remove_tex_shadow.c b/src/compiler/nir/nir_remove_tex_shadow.c index 9e1e1ba128c..0a271d8cb5c 100644 --- a/src/compiler/nir/nir_remove_tex_shadow.c +++ b/src/compiler/nir/nir_remove_tex_shadow.c @@ -80,7 +80,7 @@ remove_tex_shadow(struct nir_builder *b, nir_instr *instr, void *data) nir_variable *sampler = NULL; int sampler_src_index = nir_tex_instr_src_index(tex, nir_tex_src_sampler_deref); if (sampler_src_index >= 0) { - sampler_deref = nir_instr_as_deref(tex->src[sampler_src_index].src.ssa->parent_instr); + sampler_deref = nir_def_as_deref(tex->src[sampler_src_index].src.ssa); sampler = nir_deref_instr_get_variable(sampler_deref); sampler->type = strip_shadow_with_array(sampler->type); sampler_deref->type = sampler->type; diff --git a/src/compiler/nir/nir_repair_ssa.c b/src/compiler/nir/nir_repair_ssa.c index 811fb69b61b..dc511b3a8ee 100644 --- a/src/compiler/nir/nir_repair_ssa.c +++ b/src/compiler/nir/nir_repair_ssa.c @@ -120,7 +120,7 @@ repair_ssa_def(nir_def *def, void *void_state) nir_deref_instr_create(state->impl->function->shader, nir_deref_type_cast); - nir_deref_instr *deref = nir_instr_as_deref(def->parent_instr); + nir_deref_instr *deref = nir_def_as_deref(def); cast->modes = deref->modes; cast->type = deref->type; cast->parent = nir_src_for_ssa(block_def); diff --git a/src/compiler/nir/nir_search.c b/src/compiler/nir/nir_search.c index d670f4a0657..d2859451ab1 100644 --- a/src/compiler/nir/nir_search.c +++ b/src/compiler/nir/nir_search.c @@ -83,7 +83,7 @@ src_is_type(nir_src src, nir_alu_type type) assert(type != nir_type_invalid); if (src.ssa->parent_instr->type == nir_instr_type_alu) { - nir_alu_instr *src_alu = nir_instr_as_alu(src.ssa->parent_instr); + nir_alu_instr *src_alu = nir_def_as_alu(src.ssa); nir_alu_type output_type = nir_op_infos[src_alu->op].output_type; if (type == nir_type_bool) { @@ -102,7 +102,7 @@ src_is_type(nir_src src, nir_alu_type type) return nir_alu_type_get_base_type(output_type) == type; } else if (src.ssa->parent_instr->type == nir_instr_type_intrinsic) { - nir_intrinsic_instr *intr = nir_instr_as_intrinsic(src.ssa->parent_instr); + nir_intrinsic_instr *intr = nir_def_as_intrinsic(src.ssa); if (type == nir_type_bool) { return intr->intrinsic == nir_intrinsic_load_front_face || @@ -267,7 +267,7 @@ match_value(const nir_algebraic_table *table, return false; return match_expression(table, nir_search_value_as_expression(value), - nir_instr_as_alu(instr->src[src].src.ssa->parent_instr), + nir_def_as_alu(instr->src[src].src.ssa), num_components, new_swizzle, state); case nir_search_value_variable: { @@ -320,7 +320,7 @@ match_value(const nir_algebraic_table *table, switch (const_val->type) { case nir_type_float: { nir_load_const_instr *const load = - nir_instr_as_load_const(instr->src[src].src.ssa->parent_instr); + nir_def_as_load_const(instr->src[src].src.ssa); /* There are 8-bit and 1-bit integer types, but there are no 8-bit or * 1-bit float types. This prevents potential assertion failures in diff --git a/src/compiler/nir/nir_serialize.c b/src/compiler/nir/nir_serialize.c index cd5eca5a5cb..f92aea6e123 100644 --- a/src/compiler/nir/nir_serialize.c +++ b/src/compiler/nir/nir_serialize.c @@ -1031,7 +1031,7 @@ read_deref(read_ctx *ctx, union packed_instr header) } else if (deref->deref_type == nir_deref_type_cast) { deref->modes = decode_deref_modes(header.deref.modes); } else { - deref->modes = nir_instr_as_deref(deref->parent.ssa->parent_instr)->modes; + deref->modes = nir_def_as_deref(deref->parent.ssa)->modes; } return deref; diff --git a/src/compiler/nir/nir_split_64bit_vec3_and_vec4.c b/src/compiler/nir/nir_split_64bit_vec3_and_vec4.c index 5b41aaa32fc..53900d26524 100644 --- a/src/compiler/nir/nir_split_64bit_vec3_and_vec4.c +++ b/src/compiler/nir/nir_split_64bit_vec3_and_vec4.c @@ -273,7 +273,7 @@ nir_split_64bit_vec3_and_vec4_impl(nir_builder *b, nir_instr *instr, void *d) case nir_intrinsic_load_deref: { nir_deref_instr *deref = - nir_instr_as_deref(intr->src[0].ssa->parent_instr); + nir_def_as_deref(intr->src[0].ssa); if (deref->deref_type == nir_deref_type_var) return split_load_deref(b, intr, NULL, split_vars); else if (deref->deref_type == nir_deref_type_array) { @@ -284,7 +284,7 @@ nir_split_64bit_vec3_and_vec4_impl(nir_builder *b, nir_instr *instr, void *d) case nir_intrinsic_store_deref: { nir_deref_instr *deref = - nir_instr_as_deref(intr->src[0].ssa->parent_instr); + nir_def_as_deref(intr->src[0].ssa); if (deref->deref_type == nir_deref_type_var) return split_store_deref(b, intr, NULL, split_vars); else if (deref->deref_type == nir_deref_type_array) diff --git a/src/compiler/nir/nir_split_var_copies.c b/src/compiler/nir/nir_split_var_copies.c index bb4e1e813ca..facdf7bf9a6 100644 --- a/src/compiler/nir/nir_split_var_copies.c +++ b/src/compiler/nir/nir_split_var_copies.c @@ -91,8 +91,8 @@ split_var_copies_instr(nir_builder *b, nir_intrinsic_instr *copy, b->cursor = nir_instr_remove(©->instr); - nir_deref_instr *dst = nir_instr_as_deref(copy->src[0].ssa->parent_instr); - nir_deref_instr *src = nir_instr_as_deref(copy->src[1].ssa->parent_instr); + nir_deref_instr *dst = nir_def_as_deref(copy->src[0].ssa); + nir_deref_instr *src = nir_def_as_deref(copy->src[1].ssa); split_deref_copy_instr(b, dst, src, nir_intrinsic_dst_access(copy), nir_intrinsic_src_access(copy)); diff --git a/src/compiler/nir/nir_to_lcssa.c b/src/compiler/nir/nir_to_lcssa.c index cd80be54139..cebbb483fe6 100644 --- a/src/compiler/nir/nir_to_lcssa.c +++ b/src/compiler/nir/nir_to_lcssa.c @@ -224,7 +224,7 @@ convert_loop_exit_for_ssa(nir_def *def, void *void_state) return true; if (def->parent_instr->type == nir_instr_type_deref) { - nir_rematerialize_deref_in_use_blocks(nir_instr_as_deref(def->parent_instr)); + nir_rematerialize_deref_in_use_blocks(nir_def_as_deref(def)); return true; } diff --git a/src/compiler/nir/nir_validate.c b/src/compiler/nir/nir_validate.c index 09dd4f8c4a0..6eee325c0d0 100644 --- a/src/compiler/nir/nir_validate.c +++ b/src/compiler/nir/nir_validate.c @@ -911,9 +911,9 @@ validate_tex_instr(nir_tex_instr *instr, validate_state *state) case nir_tex_src_sampler_deref_intrinsic: case nir_tex_src_texture_deref_intrinsic: { nir_intrinsic_instr *intrin = - nir_instr_as_intrinsic(instr->src[i].src.ssa->parent_instr); + nir_def_as_intrinsic(instr->src[i].src.ssa); nir_deref_instr *deref = - nir_instr_as_deref(intrin->src[0].ssa->parent_instr); + nir_def_as_deref(intrin->src[0].ssa); if (!validate_assert(state, deref)) break; diff --git a/src/compiler/nir/tests/nir_opt_varyings_test.h b/src/compiler/nir/tests/nir_opt_varyings_test.h index ec294ec78db..672bda10cef 100644 --- a/src/compiler/nir/tests/nir_opt_varyings_test.h +++ b/src/compiler/nir/tests/nir_opt_varyings_test.h @@ -398,7 +398,7 @@ load_input_output(nir_builder *b, gl_varying_slot slot, unsigned component, def = nir_load_input(b, 1, bit_size, zero); } - nir_intrinsic_instr *intr = nir_instr_as_intrinsic(def->parent_instr); + nir_intrinsic_instr *intr = nir_def_as_intrinsic(def); nir_intrinsic_set_base(intr, 0); /* we don't care */ nir_intrinsic_set_range(intr, 1); nir_intrinsic_set_component(intr, component); @@ -456,21 +456,21 @@ load_input_interp(nir_builder *b, gl_varying_slot slot, unsigned component, case INTERP_PERSP_CENTROID: case INTERP_PERSP_SAMPLE: case INTERP_PERSP_AT_OFFSET: - nir_intrinsic_set_interp_mode(nir_instr_as_intrinsic(baryc->parent_instr), + nir_intrinsic_set_interp_mode(nir_def_as_intrinsic(baryc), INTERP_MODE_SMOOTH); break; case INTERP_LINEAR_PIXEL: case INTERP_LINEAR_CENTROID: case INTERP_LINEAR_SAMPLE: case INTERP_LINEAR_AT_OFFSET: - nir_intrinsic_set_interp_mode(nir_instr_as_intrinsic(baryc->parent_instr), + nir_intrinsic_set_interp_mode(nir_def_as_intrinsic(baryc), INTERP_MODE_NOPERSPECTIVE); break; case INTERP_COLOR_PIXEL: case INTERP_COLOR_CENTROID: case INTERP_COLOR_SAMPLE: case INTERP_COLOR_AT_OFFSET: - nir_intrinsic_set_interp_mode(nir_instr_as_intrinsic(baryc->parent_instr), + nir_intrinsic_set_interp_mode(nir_def_as_intrinsic(baryc), INTERP_MODE_NONE); break; default: @@ -479,7 +479,7 @@ load_input_interp(nir_builder *b, gl_varying_slot slot, unsigned component, nir_def *def = nir_load_interpolated_input(b, 1, bit_size, baryc, zero); - nir_intrinsic_instr *intr = nir_instr_as_intrinsic(def->parent_instr); + nir_intrinsic_instr *intr = nir_def_as_intrinsic(def); nir_intrinsic_set_base(intr, 0); /* we don't care */ nir_intrinsic_set_component(intr, component); nir_intrinsic_set_dest_type(intr, type); @@ -532,7 +532,7 @@ load_interpolated_input_tes(nir_builder *b, gl_varying_slot slot, def[i] = nir_load_per_vertex_input(b, 1, bit_size, nir_imm_int(b, i), zero); - nir_intrinsic_instr *intr = nir_instr_as_intrinsic(def[i]->parent_instr); + nir_intrinsic_instr *intr = nir_def_as_intrinsic(def[i]); nir_intrinsic_set_base(intr, 0); /* we don't care */ nir_intrinsic_set_range(intr, 1); nir_intrinsic_set_component(intr, component); diff --git a/src/compiler/spirv/vtn_alu.c b/src/compiler/spirv/vtn_alu.c index 2bfbab789bc..d5803f71c00 100644 --- a/src/compiler/spirv/vtn_alu.c +++ b/src/compiler/spirv/vtn_alu.c @@ -1147,7 +1147,7 @@ vtn_handle_alu(struct vtn_builder *b, SpvOp opcode, case SpvOpISub: case SpvOpShiftLeftLogical: case SpvOpSNegate: { - nir_alu_instr *alu = nir_instr_as_alu(dest->def->parent_instr); + nir_alu_instr *alu = nir_def_as_alu(dest->def); vtn_foreach_decoration(b, dest_val, handle_no_wrap, alu); break; } diff --git a/src/compiler/spirv/vtn_opencl.c b/src/compiler/spirv/vtn_opencl.c index b3b354fa68c..103d4742009 100644 --- a/src/compiler/spirv/vtn_opencl.c +++ b/src/compiler/spirv/vtn_opencl.c @@ -899,7 +899,7 @@ vtn_add_printf_string(struct vtn_builder *b, uint32_t id, u_printf_info *info) break; } vtn_assert(parent.comp == 0); - deref = nir_instr_as_deref(parent.def->parent_instr); + deref = nir_def_as_deref(parent.def); } vtn_fail_if(deref == NULL || !nir_deref_mode_is(deref, nir_var_mem_constant), diff --git a/src/compiler/spirv/vtn_variables.c b/src/compiler/spirv/vtn_variables.c index 9002ae94e67..94e1927ca07 100644 --- a/src/compiler/spirv/vtn_variables.c +++ b/src/compiler/spirv/vtn_variables.c @@ -594,12 +594,12 @@ get_deref_tail(nir_deref_instr *deref) return deref; nir_deref_instr *parent = - nir_instr_as_deref(deref->parent.ssa->parent_instr); + nir_def_as_deref(deref->parent.ssa); if (parent->deref_type == nir_deref_type_cast && parent->parent.ssa->parent_instr->type == nir_instr_type_deref) { nir_deref_instr *grandparent = - nir_instr_as_deref(parent->parent.ssa->parent_instr); + nir_def_as_deref(parent->parent.ssa); if (glsl_type_is_cmat(grandparent->type)) return grandparent; diff --git a/src/freedreno/ir3/ir3_compiler_nir.c b/src/freedreno/ir3/ir3_compiler_nir.c index ac93412b0d0..d9b3ec5ad60 100644 --- a/src/freedreno/ir3/ir3_compiler_nir.c +++ b/src/freedreno/ir3/ir3_compiler_nir.c @@ -4351,7 +4351,7 @@ get_branch_condition(struct ir3_context *ctx, nir_src *src, unsigned comp, struct ir3_instruction *condition = ir3_get_src(ctx, src)[comp]; if (src->ssa->parent_instr->type == nir_instr_type_alu) { - nir_alu_instr *nir_cond = nir_instr_as_alu(src->ssa->parent_instr); + nir_alu_instr *nir_cond = nir_def_as_alu(src->ssa); if (nir_cond->op == nir_op_inot) { struct ir3_instruction *inv_cond = get_branch_condition( @@ -4376,7 +4376,7 @@ fold_conditional_branch(struct ir3_context *ctx, struct nir_src *nir_cond) if (nir_cond->ssa->parent_instr->type != nir_instr_type_alu) return NULL; - nir_alu_instr *alu_cond = nir_instr_as_alu(nir_cond->ssa->parent_instr); + nir_alu_instr *alu_cond = nir_def_as_alu(nir_cond->ssa); if ((alu_cond->op != nir_op_iand) && (alu_cond->op != nir_op_ior)) return NULL; diff --git a/src/freedreno/ir3/ir3_nir.h b/src/freedreno/ir3/ir3_nir.h index 668bd2b85e8..7d42a6f11e6 100644 --- a/src/freedreno/ir3/ir3_nir.h +++ b/src/freedreno/ir3/ir3_nir.h @@ -153,7 +153,7 @@ ir3_bindless_resource(nir_src src) if (src.ssa->parent_instr->type != nir_instr_type_intrinsic) return NULL; - nir_intrinsic_instr *intrin = nir_instr_as_intrinsic(src.ssa->parent_instr); + nir_intrinsic_instr *intrin = nir_def_as_intrinsic(src.ssa); if (intrin->intrinsic != nir_intrinsic_bindless_resource_ir3) return NULL; diff --git a/src/freedreno/ir3/ir3_nir_analyze_ubo_ranges.c b/src/freedreno/ir3/ir3_nir_analyze_ubo_ranges.c index baa07943215..d15ee24776c 100644 --- a/src/freedreno/ir3/ir3_nir_analyze_ubo_ranges.c +++ b/src/freedreno/ir3/ir3_nir_analyze_ubo_ranges.c @@ -217,7 +217,7 @@ handle_partial_const(nir_builder *b, nir_def **srcp, int *offp) if ((*srcp)->parent_instr->type != nir_instr_type_alu) return; - nir_alu_instr *alu = nir_instr_as_alu((*srcp)->parent_instr); + nir_alu_instr *alu = nir_def_as_alu((*srcp)); if (alu->op == nir_op_imad24_ir3) { /* This case is slightly more complicated as we need to diff --git a/src/freedreno/ir3/ir3_nir_lower_tex_prefetch.c b/src/freedreno/ir3/ir3_nir_lower_tex_prefetch.c index a29313bc8f1..e536e1707da 100644 --- a/src/freedreno/ir3/ir3_nir_lower_tex_prefetch.c +++ b/src/freedreno/ir3/ir3_nir_lower_tex_prefetch.c @@ -72,7 +72,7 @@ coord_offset(nir_def *ssa, gl_system_value *bary_type) return -1; nir_intrinsic_instr *interp = - nir_instr_as_intrinsic(input->src[0].ssa->parent_instr); + nir_def_as_intrinsic(input->src[0].ssa); if (interp->intrinsic != nir_intrinsic_load_barycentric_pixel && interp->intrinsic != nir_intrinsic_load_barycentric_sample && diff --git a/src/freedreno/ir3/ir3_nir_opt_preamble.c b/src/freedreno/ir3/ir3_nir_opt_preamble.c index fc39cb0fd36..ff1e854a067 100644 --- a/src/freedreno/ir3/ir3_nir_opt_preamble.c +++ b/src/freedreno/ir3/ir3_nir_opt_preamble.c @@ -363,7 +363,7 @@ ir3_def_is_rematerializable_for_preamble(nir_def *def, case nir_instr_type_load_const: return true; case nir_instr_type_intrinsic: { - nir_intrinsic_instr *intrin = nir_instr_as_intrinsic(def->parent_instr); + nir_intrinsic_instr *intrin = nir_def_as_intrinsic(def); switch (intrin->intrinsic) { case nir_intrinsic_load_ubo: return ir3_def_is_rematerializable_for_preamble(intrin->src[0].ssa, @@ -383,7 +383,7 @@ ir3_def_is_rematerializable_for_preamble(nir_def *def, } } case nir_instr_type_alu: { - nir_alu_instr *alu = nir_instr_as_alu(def->parent_instr); + nir_alu_instr *alu = nir_def_as_alu(def); for (unsigned i = 0; i < nir_op_infos[alu->op].num_inputs; i++) { if (!ir3_def_is_rematerializable_for_preamble(alu->src[i].src.ssa, preamble_defs)) @@ -455,7 +455,7 @@ _rematerialize_def(nir_builder *b, struct hash_table *remap_ht, case nir_instr_type_load_const: break; case nir_instr_type_intrinsic: { - nir_intrinsic_instr *intrin = nir_instr_as_intrinsic(def->parent_instr); + nir_intrinsic_instr *intrin = nir_def_as_intrinsic(def); if (intrin->intrinsic == nir_intrinsic_load_preamble) { _mesa_hash_table_insert(remap_ht, def, preamble_defs[nir_intrinsic_base(intrin)]); @@ -469,7 +469,7 @@ _rematerialize_def(nir_builder *b, struct hash_table *remap_ht, break; } case nir_instr_type_alu: { - nir_alu_instr *alu = nir_instr_as_alu(def->parent_instr); + nir_alu_instr *alu = nir_def_as_alu(def); for (unsigned i = 0; i < nir_op_infos[alu->op].num_inputs; i++) _rematerialize_def(b, remap_ht, instr_set, preamble_defs, alu->src[i].src.ssa); @@ -676,7 +676,7 @@ emit_descriptor_prefetch(nir_builder *b, nir_instr *instr, nir_def **descs, static unsigned get_preamble_offset(nir_def *def) { - return nir_intrinsic_base(nir_instr_as_intrinsic(def->parent_instr)); + return nir_intrinsic_base(nir_def_as_intrinsic(def)); } /* Prefetch descriptors in the preamble. This is an optimization introduced on diff --git a/src/freedreno/vulkan/tu_nir_lower_ray_query.cc b/src/freedreno/vulkan/tu_nir_lower_ray_query.cc index 012bed98343..c240d7eaf91 100644 --- a/src/freedreno/vulkan/tu_nir_lower_ray_query.cc +++ b/src/freedreno/vulkan/tu_nir_lower_ray_query.cc @@ -131,7 +131,7 @@ static nir_deref_instr * get_rq_deref(nir_builder *b, struct hash_table *ht, nir_def *def, struct rq_var **rq_var_out) { - nir_deref_instr *deref = nir_instr_as_deref(def->parent_instr); + nir_deref_instr *deref = nir_def_as_deref(def); nir_deref_path path; nir_deref_path_init(&path, deref, NULL); @@ -170,7 +170,7 @@ static nir_def * get_rq_initialize_uav_index(nir_intrinsic_instr *intr, struct rq_var *var) { if (intr->src[1].ssa->parent_instr->type == nir_instr_type_intrinsic && - nir_instr_as_intrinsic(intr->src[1].ssa->parent_instr)->intrinsic == + nir_def_as_intrinsic(intr->src[1].ssa)->intrinsic == nir_intrinsic_load_vulkan_descriptor) { return intr->src[1].ssa; } else { @@ -205,7 +205,7 @@ calc_uav_index(nir_function_impl *impl, struct hash_table *ht) continue; } - nir_deref_instr *deref = nir_instr_as_deref(rq_def->parent_instr); + nir_deref_instr *deref = nir_def_as_deref(rq_def); if (deref->deref_type != nir_deref_type_var) continue; @@ -302,7 +302,7 @@ lower_rq_initialize(nir_builder *b, struct hash_table *ht, struct rq_var *var; nir_deref_instr *rq = get_rq_deref(b, ht, intr->src[0].ssa, &var); - if (nir_instr_as_deref(intr->src[0].ssa->parent_instr)->deref_type == + if (nir_def_as_deref(intr->src[0].ssa)->deref_type == nir_deref_type_var) { var->initialization = intr; } else { diff --git a/src/freedreno/vulkan/tu_shader.cc b/src/freedreno/vulkan/tu_shader.cc index fcffe32ba4e..832ac189c79 100644 --- a/src/freedreno/vulkan/tu_shader.cc +++ b/src/freedreno/vulkan/tu_shader.cc @@ -1118,7 +1118,7 @@ lower_ssbo_descriptor_instr(nir_builder *b, nir_intrinsic_instr *intrin, nir_def *buffer = intrin->src[buffer_src].ssa; assert(buffer->parent_instr->type == nir_instr_type_intrinsic); nir_intrinsic_instr *bindless = - nir_instr_as_intrinsic(buffer->parent_instr); + nir_def_as_intrinsic(buffer); assert(bindless->intrinsic == nir_intrinsic_bindless_resource_ir3); nir_def *descriptor_idx = bindless->src[0].ssa; descriptor_idx = nir_iadd_imm(b, descriptor_idx, 1); diff --git a/src/gallium/auxiliary/gallivm/lp_bld_nir_aos.c b/src/gallium/auxiliary/gallivm/lp_bld_nir_aos.c index c163d6522d7..16c7d8a494f 100644 --- a/src/gallium/auxiliary/gallivm/lp_bld_nir_aos.c +++ b/src/gallium/auxiliary/gallivm/lp_bld_nir_aos.c @@ -628,7 +628,7 @@ visit_load_var(struct lp_build_nir_aos_context *bld, nir_intrinsic_instr *instr, LLVMValueRef result[NIR_MAX_VEC_COMPONENTS]) { - nir_deref_instr *deref = nir_instr_as_deref(instr->src[0].ssa->parent_instr); + nir_deref_instr *deref = nir_def_as_deref(instr->src[0].ssa); nir_variable *var = nir_deref_instr_get_variable(deref); assert(util_bitcount(deref->modes) == 1); nir_variable_mode mode = deref->modes; @@ -640,7 +640,7 @@ static void visit_store_var(struct lp_build_nir_aos_context *bld, nir_intrinsic_instr *instr) { - nir_deref_instr *deref = nir_instr_as_deref(instr->src[0].ssa->parent_instr); + nir_deref_instr *deref = nir_def_as_deref(instr->src[0].ssa); nir_variable *var = nir_deref_instr_get_variable(deref); assert(util_bitcount(deref->modes) == 1); nir_variable_mode mode = deref->modes; diff --git a/src/gallium/auxiliary/gallivm/lp_bld_nir_soa.c b/src/gallium/auxiliary/gallivm/lp_bld_nir_soa.c index a94b238edbe..9fbe3890eae 100644 --- a/src/gallium/auxiliary/gallivm/lp_bld_nir_soa.c +++ b/src/gallium/auxiliary/gallivm/lp_bld_nir_soa.c @@ -3970,7 +3970,7 @@ visit_load_var(struct lp_build_nir_soa_context *bld, nir_intrinsic_instr *instr, LLVMValueRef result[NIR_MAX_VEC_COMPONENTS]) { - nir_deref_instr *deref = nir_instr_as_deref(instr->src[0].ssa->parent_instr); + nir_deref_instr *deref = nir_def_as_deref(instr->src[0].ssa); nir_variable *var = nir_deref_instr_get_variable(deref); assert(util_bitcount(deref->modes) == 1); nir_variable_mode mode = deref->modes; @@ -4018,7 +4018,7 @@ static void visit_store_var(struct lp_build_nir_soa_context *bld, nir_intrinsic_instr *instr) { - nir_deref_instr *deref = nir_instr_as_deref(instr->src[0].ssa->parent_instr); + nir_deref_instr *deref = nir_def_as_deref(instr->src[0].ssa); nir_variable *var = nir_deref_instr_get_variable(deref); assert(util_bitcount(deref->modes) == 1); nir_variable_mode mode = deref->modes; @@ -4818,7 +4818,7 @@ visit_interp(struct lp_build_nir_soa_context *bld, nir_intrinsic_instr *instr, LLVMValueRef result[NIR_MAX_VEC_COMPONENTS]) { - nir_deref_instr *deref = nir_instr_as_deref(instr->src[0].ssa->parent_instr); + nir_deref_instr *deref = nir_def_as_deref(instr->src[0].ssa); unsigned num_components = instr->def.num_components; nir_variable *var = nir_deref_instr_get_variable(deref); unsigned const_index; diff --git a/src/gallium/auxiliary/nir/nir_to_tgsi.c b/src/gallium/auxiliary/nir/nir_to_tgsi.c index a42df407de2..81d321ec8ee 100644 --- a/src/gallium/auxiliary/nir/nir_to_tgsi.c +++ b/src/gallium/auxiliary/nir/nir_to_tgsi.c @@ -554,7 +554,7 @@ ntt_extract_const_src_offset(nir_src *src) nir_scalar s = nir_get_scalar(src->ssa, 0); while (nir_scalar_is_alu(s)) { - nir_alu_instr *alu = nir_instr_as_alu(s.def->parent_instr); + nir_alu_instr *alu = nir_def_as_alu(s.def); if (alu->op == nir_op_iadd) { for (int i = 0; i < 2; i++) { @@ -1225,7 +1225,7 @@ ntt_get_chased_src(struct ntt_compile *c, nir_legacy_src *src) { if (src->is_ssa) { if (src->ssa->parent_instr->type == nir_instr_type_load_const) - return ntt_get_load_const_src(c, nir_instr_as_load_const(src->ssa->parent_instr)); + return ntt_get_load_const_src(c, nir_def_as_load_const(src->ssa)); return c->ssa_temp[src->ssa->index]; } else { @@ -2276,7 +2276,7 @@ ntt_emit_load_input(struct ntt_compile *c, nir_intrinsic_instr *instr) input = ntt_ureg_src_indirect(c, input, instr->src[1], 0); nir_intrinsic_instr *bary_instr = - nir_instr_as_intrinsic(instr->src[0].ssa->parent_instr); + nir_def_as_intrinsic(instr->src[0].ssa); switch (bary_instr->intrinsic) { case nir_intrinsic_load_barycentric_pixel: diff --git a/src/gallium/drivers/crocus/crocus_program.c b/src/gallium/drivers/crocus/crocus_program.c index 94eb5d61e07..390ee15abea 100644 --- a/src/gallium/drivers/crocus/crocus_program.c +++ b/src/gallium/drivers/crocus/crocus_program.c @@ -694,7 +694,7 @@ crocus_setup_uniforms(ASSERTED const struct intel_device_info *devinfo, */ if (temp_const_ubo_name != NULL) { nir_load_const_instr *const_ubo_index = - nir_instr_as_load_const(temp_const_ubo_name->parent_instr); + nir_def_as_load_const(temp_const_ubo_name); assert(const_ubo_index->def.bit_size == 32); const_ubo_index->value[0].u32 = num_cbufs; } diff --git a/src/gallium/drivers/etnaviv/etnaviv_compiler_nir.c b/src/gallium/drivers/etnaviv/etnaviv_compiler_nir.c index b8720727065..398ca81de6e 100644 --- a/src/gallium/drivers/etnaviv/etnaviv_compiler_nir.c +++ b/src/gallium/drivers/etnaviv/etnaviv_compiler_nir.c @@ -822,7 +822,7 @@ static nir_const_value *get_alu_cv(nir_alu_src *src) if (!cv && (src->src.ssa->parent_instr->type == nir_instr_type_alu)) { - nir_alu_instr *parent = nir_instr_as_alu(src->src.ssa->parent_instr); + nir_alu_instr *parent = nir_def_as_alu(src->src.ssa); if ((parent->op == nir_op_fabs) || (parent->op == nir_op_fneg)) { diff --git a/src/gallium/drivers/etnaviv/etnaviv_nir.c b/src/gallium/drivers/etnaviv/etnaviv_nir.c index 753ea69a096..6581f5b256b 100644 --- a/src/gallium/drivers/etnaviv/etnaviv_nir.c +++ b/src/gallium/drivers/etnaviv/etnaviv_nir.c @@ -66,7 +66,7 @@ etna_lower_io(nir_shader *shader, struct etna_shader_variant *v) nir_def *ssa = nir_ine_imm(&b, &intr->def, 0); if (v->key.front_ccw) - nir_instr_as_alu(ssa->parent_instr)->op = nir_op_ieq; + nir_def_as_alu(ssa)->op = nir_op_ieq; nir_def_rewrite_uses_after(&intr->def, ssa, @@ -91,7 +91,7 @@ etna_lower_io(nir_shader *shader, struct etna_shader_variant *v) b.cursor = nir_before_instr(instr); nir_def *ssa = nir_mov(&b, intr->src[1].ssa); - nir_alu_instr *alu = nir_instr_as_alu(ssa->parent_instr); + nir_alu_instr *alu = nir_def_as_alu(ssa); alu->src[0].swizzle[0] = 2; alu->src[0].swizzle[2] = 0; nir_src_rewrite(&intr->src[1], ssa); diff --git a/src/gallium/drivers/etnaviv/etnaviv_nir_lower_source_mods.c b/src/gallium/drivers/etnaviv/etnaviv_nir_lower_source_mods.c index 533b1c6758f..6a45f3cb797 100644 --- a/src/gallium/drivers/etnaviv/etnaviv_nir_lower_source_mods.c +++ b/src/gallium/drivers/etnaviv/etnaviv_nir_lower_source_mods.c @@ -59,7 +59,7 @@ nir_lower_to_source_mods_instr(nir_builder *b, nir_instr *instr, if (alu->src[i].src.ssa->parent_instr->type != nir_instr_type_alu) continue; - nir_alu_instr *parent = nir_instr_as_alu(alu->src[i].src.ssa->parent_instr); + nir_alu_instr *parent = nir_def_as_alu(alu->src[i].src.ssa); if (nir_alu_type_get_base_type(nir_op_infos[alu->op].input_types[i]) != nir_type_float) continue; diff --git a/src/gallium/drivers/lima/ir/lima_nir_lower_txp.c b/src/gallium/drivers/lima/ir/lima_nir_lower_txp.c index 2e1710f4664..4a77190b130 100644 --- a/src/gallium/drivers/lima/ir/lima_nir_lower_txp.c +++ b/src/gallium/drivers/lima/ir/lima_nir_lower_txp.c @@ -50,7 +50,7 @@ get_proj_index(nir_instr *coord_instr, nir_instr *proj_instr, if (coord_src_ssa->parent_instr->type != nir_instr_type_intrinsic) return NULL; - nir_intrinsic_instr *intrin = nir_instr_as_intrinsic(coord_src_ssa->parent_instr); + nir_intrinsic_instr *intrin = nir_def_as_intrinsic(coord_src_ssa); if (intrin->intrinsic != nir_intrinsic_load_input) return NULL; diff --git a/src/gallium/drivers/lima/ir/lima_nir_split_load_input.c b/src/gallium/drivers/lima/ir/lima_nir_split_load_input.c index 68d3d80334d..c5261ace068 100644 --- a/src/gallium/drivers/lima/ir/lima_nir_split_load_input.c +++ b/src/gallium/drivers/lima/ir/lima_nir_split_load_input.c @@ -42,7 +42,7 @@ lima_nir_split_load_input_instr(nir_builder *b, if (ssa->parent_instr->type != nir_instr_type_intrinsic) return false; - nir_intrinsic_instr *intrin = nir_instr_as_intrinsic(ssa->parent_instr); + nir_intrinsic_instr *intrin = nir_def_as_intrinsic(ssa); if (intrin->intrinsic != nir_intrinsic_load_input) return false; diff --git a/src/gallium/drivers/llvmpipe/lp_state_fs_analysis.c b/src/gallium/drivers/llvmpipe/lp_state_fs_analysis.c index 97b25690cf2..952561131dd 100644 --- a/src/gallium/drivers/llvmpipe/lp_state_fs_analysis.c +++ b/src/gallium/drivers/llvmpipe/lp_state_fs_analysis.c @@ -245,7 +245,7 @@ llvmpipe_nir_fn_is_linear_compat(const struct nir_shader *shader, if (!nir_src_is_const(intrin->src[0])) return false; nir_load_const_instr *load = - nir_instr_as_load_const(intrin->src[0].ssa->parent_instr); + nir_def_as_load_const(intrin->src[0].ssa); if (load->value[0].u32 != 0 || load->def.num_components > 1) return false; } else if (intrin->intrinsic == nir_intrinsic_store_deref) { @@ -333,7 +333,7 @@ llvmpipe_nir_fn_is_linear_compat(const struct nir_shader *shader, */ if (nir_src_is_const(alu->src[s].src)) { nir_load_const_instr *load = - nir_instr_as_load_const(alu->src[s].src.ssa->parent_instr); + nir_def_as_load_const(alu->src[s].src.ssa); if (!check_load_const_in_zero_one(load)) { return false; } diff --git a/src/gallium/drivers/r300/compiler/nir_to_rc.c b/src/gallium/drivers/r300/compiler/nir_to_rc.c index 3765c649b25..b2881955ba4 100644 --- a/src/gallium/drivers/r300/compiler/nir_to_rc.c +++ b/src/gallium/drivers/r300/compiler/nir_to_rc.c @@ -629,7 +629,7 @@ ntr_get_chased_src(struct ntr_compile *c, nir_legacy_src *src) { if (src->is_ssa) { if (src->ssa->parent_instr->type == nir_instr_type_load_const) - return ntr_get_load_const_src(c, nir_instr_as_load_const(src->ssa->parent_instr)); + return ntr_get_load_const_src(c, nir_def_as_load_const(src->ssa)); return c->ssa_temp[src->ssa->index]; } else { @@ -695,7 +695,7 @@ ntr_get_ssa_def_decl(struct ntr_compile *c, nir_def *ssa) uint32_t writemask; /* Fix writemask for nir_intrinsic_load_ubo_vec4 according to uses. */ if (ssa->parent_instr->type == nir_instr_type_intrinsic && - nir_instr_as_intrinsic(ssa->parent_instr)->intrinsic == nir_intrinsic_load_ubo_vec4) + nir_def_as_intrinsic(ssa)->intrinsic == nir_intrinsic_load_ubo_vec4) writemask = nir_def_components_read(ssa); else writemask = BITSET_MASK(ssa->num_components); @@ -1072,7 +1072,7 @@ ntr_emit_load_input(struct ntr_compile *c, nir_intrinsic_instr *instr) case nir_intrinsic_load_interpolated_input: { input = ntr_ureg_src_indirect(c, input, instr->src[1], 0); - nir_intrinsic_instr *bary_instr = nir_instr_as_intrinsic(instr->src[0].ssa->parent_instr); + nir_intrinsic_instr *bary_instr = nir_def_as_intrinsic(instr->src[0].ssa); switch (bary_instr->intrinsic) { case nir_intrinsic_load_barycentric_pixel: diff --git a/src/gallium/drivers/radeonsi/si_nir_lower_color_inputs_to_sysvals.c b/src/gallium/drivers/radeonsi/si_nir_lower_color_inputs_to_sysvals.c index f9d384f351c..f2a21f68f67 100644 --- a/src/gallium/drivers/radeonsi/si_nir_lower_color_inputs_to_sysvals.c +++ b/src/gallium/drivers/radeonsi/si_nir_lower_color_inputs_to_sysvals.c @@ -44,7 +44,7 @@ bool si_nir_lower_color_inputs_to_sysvals(nir_shader *nir) if (intrin->intrinsic == nir_intrinsic_load_interpolated_input) { nir_intrinsic_instr *baryc = - nir_instr_as_intrinsic(intrin->src[0].ssa->parent_instr); + nir_def_as_intrinsic(intrin->src[0].ssa); centroid = baryc->intrinsic == nir_intrinsic_load_barycentric_centroid; diff --git a/src/gallium/drivers/vc4/vc4_program.c b/src/gallium/drivers/vc4/vc4_program.c index f61d3a32c25..d623e64c4bb 100644 --- a/src/gallium/drivers/vc4/vc4_program.c +++ b/src/gallium/drivers/vc4/vc4_program.c @@ -829,9 +829,9 @@ ntq_emit_pack_unorm_4x8(struct vc4_compile *c, nir_alu_instr *instr) * peek back at what generated its sources. */ if (instr->src[0].src.ssa->parent_instr->type == nir_instr_type_alu && - nir_instr_as_alu(instr->src[0].src.ssa->parent_instr)->op == + nir_def_as_alu(instr->src[0].src.ssa)->op == nir_op_vec4) { - vec4 = nir_instr_as_alu(instr->src[0].src.ssa->parent_instr); + vec4 = nir_def_as_alu(instr->src[0].src.ssa); } /* If the pack is replicating the same channel 4 times, use the 8888 @@ -1000,7 +1000,7 @@ static struct qreg ntq_emit_bcsel(struct vc4_compile *c, nir_alu_instr *instr, if (instr->src[0].src.ssa->parent_instr->type != nir_instr_type_alu) goto out; nir_alu_instr *compare = - nir_instr_as_alu(instr->src[0].src.ssa->parent_instr); + nir_def_as_alu(instr->src[0].src.ssa); if (!compare) goto out; diff --git a/src/gallium/drivers/zink/nir_to_spirv/nir_to_spirv.c b/src/gallium/drivers/zink/nir_to_spirv/nir_to_spirv.c index 027fc35d12d..6bec5105d40 100644 --- a/src/gallium/drivers/zink/nir_to_spirv/nir_to_spirv.c +++ b/src/gallium/drivers/zink/nir_to_spirv/nir_to_spirv.c @@ -3795,7 +3795,7 @@ get_tex_srcs(struct ntv_context *ctx, nir_tex_instr *tex, nir_const_value *cv; switch (tex->src[i].src_type) { case nir_tex_src_texture_deref: - var = nir_deref_instr_get_variable(nir_instr_as_deref(tex->src[i].src.ssa->parent_instr)); + var = nir_deref_instr_get_variable(nir_def_as_deref(tex->src[i].src.ssa)); tex_src->src = get_src(ctx, &tex->src[i].src, &atype); break; case nir_tex_src_sampler_deref: diff --git a/src/gallium/drivers/zink/zink_compiler.c b/src/gallium/drivers/zink/zink_compiler.c index d9727749d57..e7594900c01 100644 --- a/src/gallium/drivers/zink/zink_compiler.c +++ b/src/gallium/drivers/zink/zink_compiler.c @@ -2354,7 +2354,8 @@ remove_bo_access_instr(nir_builder *b, nir_instr *instr, void *data) nir_i2iN(b, offset, deref_struct->def.bit_size)); result[i] = nir_load_deref(b, deref_arr); if (intr->intrinsic == nir_intrinsic_load_ssbo) - nir_intrinsic_set_access(nir_instr_as_intrinsic(result[i]->parent_instr), nir_intrinsic_access(intr)); + nir_intrinsic_set_access(nir_def_as_intrinsic(result[i]), + nir_intrinsic_access(intr)); offset = nir_iadd_imm(b, offset, 1); } nir_def *load = nir_vec(b, result, intr->num_components); @@ -3516,7 +3517,7 @@ lower_zs_swizzle_tex_instr(nir_builder *b, nir_instr *instr, void *data) if (handle != -1) /* gtfo bindless depth texture mode */ return false; - var = nir_deref_instr_get_variable(nir_instr_as_deref(tex->src[nir_tex_instr_src_index(tex, nir_tex_src_texture_deref)].src.ssa->parent_instr)); + var = nir_deref_instr_get_variable(nir_def_as_deref(tex->src[nir_tex_instr_src_index(tex, nir_tex_src_texture_deref)].src.ssa)); assert(var); uint32_t sampler_id = var->data.binding - state->base_sampler_id; const struct glsl_type *type = glsl_without_array(var->type); @@ -3802,7 +3803,7 @@ add_derefs_instr(nir_builder *b, nir_intrinsic_instr *intr, void *data) nir_def *load; if (is_interp) { nir_def *interp = intr->src[0].ssa; - nir_intrinsic_instr *interp_intr = nir_instr_as_intrinsic(interp->parent_instr); + nir_intrinsic_instr *interp_intr = nir_def_as_intrinsic(interp); assert(interp_intr); var->data.interpolation = nir_intrinsic_interp_mode(interp_intr); switch (interp_intr->intrinsic) { @@ -4320,7 +4321,7 @@ analyze_io(struct zink_shader *zs, nir_shader *shader) nir_tex_instr *tex = nir_instr_as_tex(instr); int deref_idx = nir_tex_instr_src_index(tex, nir_tex_src_texture_deref); if (deref_idx >= 0) { - nir_variable *img = nir_deref_instr_get_variable(nir_instr_as_deref(tex->src[deref_idx].src.ssa->parent_instr)); + nir_variable *img = nir_deref_instr_get_variable(nir_def_as_deref(tex->src[deref_idx].src.ssa)); unsigned size = glsl_type_is_array(img->type) ? glsl_get_aoa_size(img->type) : 1; BITSET_SET_RANGE(shader->info.textures_used, img->data.driver_location, img->data.driver_location + (size - 1)); } @@ -4778,7 +4779,7 @@ match_tex_dests_instr(nir_builder *b, nir_tex_instr *tex, void *data, return false; var = nir_deref_instr_get_variable(nir_src_as_deref(tex->src[handle].src)); } else { - var = nir_deref_instr_get_variable(nir_instr_as_deref(tex->src[nir_tex_instr_src_index(tex, nir_tex_src_texture_deref)].src.ssa->parent_instr)); + var = nir_deref_instr_get_variable(nir_def_as_deref(tex->src[nir_tex_instr_src_index(tex, nir_tex_src_texture_deref)].src.ssa)); } if (pre) { flag_shadow_tex_instr(b, tex, var, data); @@ -5021,7 +5022,7 @@ type_sampler_vars(nir_shader *nir) if (instr->type != nir_instr_type_tex) continue; nir_tex_instr *tex = nir_instr_as_tex(instr); - nir_variable *var = nir_deref_instr_get_variable(nir_instr_as_deref(tex->src[nir_tex_instr_src_index(tex, nir_tex_src_texture_deref)].src.ssa->parent_instr)); + nir_variable *var = nir_deref_instr_get_variable(nir_def_as_deref(tex->src[nir_tex_instr_src_index(tex, nir_tex_src_texture_deref)].src.ssa)); assert(var); if (glsl_get_sampler_result_type(glsl_without_array(var->type)) != GLSL_TYPE_VOID && nir_tex_instr_is_query(tex)) diff --git a/src/gallium/drivers/zink/zink_lower_cubemap_to_array.c b/src/gallium/drivers/zink/zink_lower_cubemap_to_array.c index a63bb0602ed..029dcb22c80 100644 --- a/src/gallium/drivers/zink/zink_lower_cubemap_to_array.c +++ b/src/gallium/drivers/zink/zink_lower_cubemap_to_array.c @@ -53,7 +53,7 @@ lower_cubemap_to_array_filter(const nir_instr *instr, const void *mask) const uint32_t *nonseamless_cube_mask = mask; if (instr->type == nir_instr_type_tex) { nir_tex_instr *tex = nir_instr_as_tex(instr); - nir_variable *var = nir_deref_instr_get_variable(nir_instr_as_deref(tex->src[nir_tex_instr_src_index(tex, nir_tex_src_texture_deref)].src.ssa->parent_instr)); + nir_variable *var = nir_deref_instr_get_variable(nir_def_as_deref(tex->src[nir_tex_instr_src_index(tex, nir_tex_src_texture_deref)].src.ssa)); if (tex->sampler_dim != GLSL_SAMPLER_DIM_CUBE) return false; @@ -389,7 +389,7 @@ lower_cube_coords(nir_builder *b, nir_def *coord, bool is_array) static void rewrite_cube_var_type(nir_builder *b, nir_tex_instr *tex) { - nir_deref_instr *texture_deref = nir_instr_as_deref(tex->src[nir_tex_instr_src_index(tex, nir_tex_src_texture_deref)].src.ssa->parent_instr); + nir_deref_instr *texture_deref = nir_def_as_deref(tex->src[nir_tex_instr_src_index(tex, nir_tex_src_texture_deref)].src.ssa); nir_variable *sampler = nir_deref_instr_get_variable(texture_deref); assert(sampler); sampler->type = make_2darray_from_cubemap_with_array(sampler->type); diff --git a/src/gallium/frontends/lavapipe/nir/lvp_nir_lower_ray_queries.c b/src/gallium/frontends/lavapipe/nir/lvp_nir_lower_ray_queries.c index e0ecb95df4e..c71d173e8af 100644 --- a/src/gallium/frontends/lavapipe/nir/lvp_nir_lower_ray_queries.c +++ b/src/gallium/frontends/lavapipe/nir/lvp_nir_lower_ray_queries.c @@ -597,12 +597,12 @@ lvp_nir_lower_ray_queries(struct nir_shader *shader) continue; nir_deref_instr *ray_query_deref = - nir_instr_as_deref(intrinsic->src[0].ssa->parent_instr); + nir_def_as_deref(intrinsic->src[0].ssa); nir_def *index = NULL; if (ray_query_deref->deref_type == nir_deref_type_array) { index = ray_query_deref->arr.index.ssa; - ray_query_deref = nir_instr_as_deref(ray_query_deref->parent.ssa->parent_instr); + ray_query_deref = nir_def_as_deref(ray_query_deref->parent.ssa); } assert(ray_query_deref->deref_type == nir_deref_type_var); diff --git a/src/gallium/frontends/rusticl/rusticl_nir.c b/src/gallium/frontends/rusticl/rusticl_nir.c index 86876910701..b517984e119 100644 --- a/src/gallium/frontends/rusticl/rusticl_nir.c +++ b/src/gallium/frontends/rusticl/rusticl_nir.c @@ -39,7 +39,7 @@ rusticl_lower_intrinsics_instr( val = intrins->src[0].ssa; if (val->parent_instr->type == nir_instr_type_deref) { - nir_deref_instr *deref = nir_instr_as_deref(val->parent_instr); + nir_deref_instr *deref = nir_def_as_deref(val); nir_variable *var = nir_deref_instr_get_variable(deref); assert(var); val = nir_imm_intN_t(b, var->data.binding, val->bit_size); @@ -110,7 +110,7 @@ rusticl_lower_input_instr(struct nir_builder *b, nir_instr *instr, void *_) nir_load_ubo(b, intrins->num_components, intrins->def.bit_size, ubo_idx, nir_iadd_imm(b, uniform_offset, nir_intrinsic_base(intrins))); - nir_intrinsic_instr *load = nir_instr_as_intrinsic(load_result->parent_instr); + nir_intrinsic_instr *load = nir_def_as_intrinsic(load_result); nir_intrinsic_set_align_mul(load, nir_intrinsic_align_mul(intrins)); nir_intrinsic_set_align_offset(load, nir_intrinsic_align_offset(intrins)); diff --git a/src/intel/compiler/brw_from_nir.cpp b/src/intel/compiler/brw_from_nir.cpp index 80bceb05b35..a57351c8455 100644 --- a/src/intel/compiler/brw_from_nir.cpp +++ b/src/intel/compiler/brw_from_nir.cpp @@ -487,7 +487,7 @@ optimize_extract_to_float(nir_to_brw_state &ntb, const brw_builder &bld, return false; nir_alu_instr *src0 = - nir_instr_as_alu(instr->src[0].src.ssa->parent_instr); + nir_def_as_alu(instr->src[0].src.ssa); unsigned bytes; bool is_signed; diff --git a/src/intel/compiler/brw_nir.c b/src/intel/compiler/brw_nir.c index 7e4335d8df0..100abc90ed4 100644 --- a/src/intel/compiler/brw_nir.c +++ b/src/intel/compiler/brw_nir.c @@ -369,7 +369,7 @@ lower_per_view_outputs(nir_builder *b, else { nir_def *new_def = nir_load_output(b, intrin->def.num_components, intrin->def.bit_size, new_offset); - new = nir_instr_as_intrinsic(new_def->parent_instr); + new = nir_def_as_intrinsic(new_def); } nir_intrinsic_set_base(new, nir_intrinsic_base(intrin)); @@ -2698,7 +2698,7 @@ brw_nir_move_interpolation_to_top(nir_shader *nir) if (intrin->intrinsic != nir_intrinsic_load_interpolated_input) continue; nir_intrinsic_instr *bary_intrinsic = - nir_instr_as_intrinsic(intrin->src[0].ssa->parent_instr); + nir_def_as_intrinsic(intrin->src[0].ssa); nir_intrinsic_op op = bary_intrinsic->intrinsic; /* Leave interpolateAtSample/Offset() where they are. */ diff --git a/src/intel/compiler/brw_nir.h b/src/intel/compiler/brw_nir.h index 7fd78c69053..11c8ba7c5c3 100644 --- a/src/intel/compiler/brw_nir.h +++ b/src/intel/compiler/brw_nir.h @@ -79,7 +79,7 @@ brw_nir_ubo_surface_index_is_pushable(nir_src src) { nir_intrinsic_instr *intrin = src.ssa->parent_instr->type == nir_instr_type_intrinsic ? - nir_instr_as_intrinsic(src.ssa->parent_instr) : NULL; + nir_def_as_intrinsic(src.ssa) : NULL; if (intrin && intrin->intrinsic == nir_intrinsic_resource_intel) { return (nir_intrinsic_resource_access_intel(intrin) & @@ -100,7 +100,7 @@ brw_nir_ubo_surface_index_get_push_block(nir_src src) assert(src.ssa->parent_instr->type == nir_instr_type_intrinsic); - nir_intrinsic_instr *intrin = nir_instr_as_intrinsic(src.ssa->parent_instr); + nir_intrinsic_instr *intrin = nir_def_as_intrinsic(src.ssa); assert(intrin->intrinsic == nir_intrinsic_resource_intel); return nir_intrinsic_resource_block_intel(intrin); @@ -122,7 +122,7 @@ brw_nir_ubo_surface_index_get_bti(nir_src src) assert(src.ssa->parent_instr->type == nir_instr_type_intrinsic); - nir_intrinsic_instr *intrin = nir_instr_as_intrinsic(src.ssa->parent_instr); + nir_intrinsic_instr *intrin = nir_def_as_intrinsic(src.ssa); if (!intrin || intrin->intrinsic != nir_intrinsic_resource_intel) return UINT32_MAX; diff --git a/src/intel/compiler/brw_nir_lower_immediate_offsets.c b/src/intel/compiler/brw_nir_lower_immediate_offsets.c index 73ca91a2904..c9999acfca7 100644 --- a/src/intel/compiler/brw_nir_lower_immediate_offsets.c +++ b/src/intel/compiler/brw_nir_lower_immediate_offsets.c @@ -30,13 +30,13 @@ lower_immediate_offsets(nir_builder *b, nir_intrinsic_instr *intrin, void *data) nir_src *binding = nir_get_io_index_src(intrin); const bool has_resource = binding->ssa->parent_instr->type == nir_instr_type_intrinsic && - nir_instr_as_intrinsic(binding->ssa->parent_instr)->intrinsic == + nir_def_as_intrinsic(binding->ssa)->intrinsic == nir_intrinsic_resource_intel; bool ss_binding = false; bool bti_is_const; if (has_resource) { nir_intrinsic_instr *resource = - nir_instr_as_intrinsic(binding->ssa->parent_instr); + nir_def_as_intrinsic(binding->ssa); ss_binding = (nir_intrinsic_resource_access_intel(resource) & nir_resource_intel_bindless) != 0; bti_is_const = nir_src_is_const(resource->src[1]); diff --git a/src/intel/compiler/brw_nir_wa_18019110168.c b/src/intel/compiler/brw_nir_wa_18019110168.c index d1b5e03b2f2..b50798de8e1 100644 --- a/src/intel/compiler/brw_nir_wa_18019110168.c +++ b/src/intel/compiler/brw_nir_wa_18019110168.c @@ -73,7 +73,7 @@ rewrite_derefs_to_per_prim_vars(nir_builder *b, return false; nir_deref_instr *old_deref = - nir_instr_as_deref(intrin->src[0].ssa->parent_instr); + nir_def_as_deref(intrin->src[0].ssa); nir_variable *var = nir_deref_instr_get_variable(old_deref); if (var == NULL) return false; diff --git a/src/intel/compiler/elk/elk_fs_nir.cpp b/src/intel/compiler/elk/elk_fs_nir.cpp index e456cd17787..1b9ab2cdc39 100644 --- a/src/intel/compiler/elk/elk_fs_nir.cpp +++ b/src/intel/compiler/elk/elk_fs_nir.cpp @@ -1875,7 +1875,7 @@ static bool is_resource_src(nir_src src) { return src.ssa->parent_instr->type == nir_instr_type_intrinsic && - nir_instr_as_intrinsic(src.ssa->parent_instr)->intrinsic == nir_intrinsic_resource_intel; + nir_def_as_intrinsic(src.ssa)->intrinsic == nir_intrinsic_resource_intel; } static elk_fs_reg @@ -4257,13 +4257,13 @@ try_rebuild_resource(nir_to_elk_state &ntb, const elk::fs_builder &bld, nir_def if (def->parent_instr->type == nir_instr_type_load_const) { nir_load_const_instr *load_const = - nir_instr_as_load_const(def->parent_instr); + nir_def_as_load_const(def); return elk_imm_ud(load_const->value[0].i32); } else { assert(def->parent_instr->type == nir_instr_type_intrinsic && - (nir_instr_as_intrinsic(def->parent_instr)->intrinsic == + (nir_def_as_intrinsic(def)->intrinsic == nir_intrinsic_load_uniform)); - nir_intrinsic_instr *intrin = nir_instr_as_intrinsic(def->parent_instr); + nir_intrinsic_instr *intrin = nir_def_as_intrinsic(def); unsigned base_offset = nir_intrinsic_base(intrin); unsigned load_offset = nir_src_as_uint(intrin->src[0]); elk_fs_reg src(UNIFORM, base_offset / 4, ELK_REGISTER_TYPE_UD); diff --git a/src/intel/compiler/elk/elk_nir.c b/src/intel/compiler/elk/elk_nir.c index d6c64057016..9b13ad40a16 100644 --- a/src/intel/compiler/elk/elk_nir.c +++ b/src/intel/compiler/elk/elk_nir.c @@ -494,7 +494,7 @@ elk_nir_lower_fs_smooth_interp_gfx4_instr(nir_builder *b, nir_intrinsic_instr *i if (intr->intrinsic != nir_intrinsic_load_deref) return false; - nir_deref_instr *deref = nir_instr_as_deref(intr->src[0].ssa->parent_instr); + nir_deref_instr *deref = nir_def_as_deref(intr->src[0].ssa); nir_variable *var = nir_deref_instr_get_variable(deref); if (var->data.interpolation != INTERP_MODE_SMOOTH) diff --git a/src/intel/compiler/elk/elk_nir.h b/src/intel/compiler/elk/elk_nir.h index 934006f02f8..1a131e986dd 100644 --- a/src/intel/compiler/elk/elk_nir.h +++ b/src/intel/compiler/elk/elk_nir.h @@ -116,7 +116,7 @@ elk_nir_ubo_surface_index_is_pushable(nir_src src) { nir_intrinsic_instr *intrin = src.ssa->parent_instr->type == nir_instr_type_intrinsic ? - nir_instr_as_intrinsic(src.ssa->parent_instr) : NULL; + nir_def_as_intrinsic(src.ssa) : NULL; if (intrin && intrin->intrinsic == nir_intrinsic_resource_intel) { return (nir_intrinsic_resource_access_intel(intrin) & @@ -137,7 +137,7 @@ elk_nir_ubo_surface_index_get_push_block(nir_src src) assert(src.ssa->parent_instr->type == nir_instr_type_intrinsic); - nir_intrinsic_instr *intrin = nir_instr_as_intrinsic(src.ssa->parent_instr); + nir_intrinsic_instr *intrin = nir_def_as_intrinsic(src.ssa); assert(intrin->intrinsic == nir_intrinsic_resource_intel); return nir_intrinsic_resource_block_intel(intrin); @@ -159,7 +159,7 @@ elk_nir_ubo_surface_index_get_bti(nir_src src) assert(src.ssa->parent_instr->type == nir_instr_type_intrinsic); - nir_intrinsic_instr *intrin = nir_instr_as_intrinsic(src.ssa->parent_instr); + nir_intrinsic_instr *intrin = nir_def_as_intrinsic(src.ssa); if (!intrin || intrin->intrinsic != nir_intrinsic_resource_intel) return UINT32_MAX; diff --git a/src/intel/compiler/intel_nir_clamp_per_vertex_loads.c b/src/intel/compiler/intel_nir_clamp_per_vertex_loads.c index fe16c83fa2b..46177792d92 100644 --- a/src/intel/compiler/intel_nir_clamp_per_vertex_loads.c +++ b/src/intel/compiler/intel_nir_clamp_per_vertex_loads.c @@ -40,7 +40,7 @@ clamp_per_vertex_loads_instr(nir_builder *b, nir_intrinsic_instr *intrin, if (intrin->intrinsic != nir_intrinsic_load_deref) return false; - nir_deref_instr *deref = nir_instr_as_deref(intrin->src[0].ssa->parent_instr); + nir_deref_instr *deref = nir_def_as_deref(intrin->src[0].ssa); nir_variable *var = nir_deref_instr_get_variable(deref); if (var == NULL || (var->data.mode & nir_var_shader_in) == 0) return false; diff --git a/src/intel/compiler/intel_nir_lower_non_uniform_barycentric_at_sample.c b/src/intel/compiler/intel_nir_lower_non_uniform_barycentric_at_sample.c index 8d42b67ac88..0269aa15836 100644 --- a/src/intel/compiler/intel_nir_lower_non_uniform_barycentric_at_sample.c +++ b/src/intel/compiler/intel_nir_lower_non_uniform_barycentric_at_sample.c @@ -88,7 +88,7 @@ intel_nir_lower_non_uniform_interpolated_input_instr(nir_builder *b, assert(load_ii->src[0].ssa->parent_instr->type == nir_instr_type_intrinsic); nir_intrinsic_instr *bary = - nir_instr_as_intrinsic(load_ii->src[0].ssa->parent_instr); + nir_def_as_intrinsic(load_ii->src[0].ssa); if (bary->intrinsic != nir_intrinsic_load_barycentric_at_sample) return false; diff --git a/src/intel/compiler/intel_nir_lower_sparse.c b/src/intel/compiler/intel_nir_lower_sparse.c index 65dbc6bd4e6..adb505dbf7e 100644 --- a/src/intel/compiler/intel_nir_lower_sparse.c +++ b/src/intel/compiler/intel_nir_lower_sparse.c @@ -87,7 +87,7 @@ lower_sparse_image_load(nir_builder *b, nir_intrinsic_instr *intrin) intrin->src[1].ssa, intrin->src[2].ssa, intrin->src[3].ssa); - new_intrin = nir_instr_as_intrinsic(img_load->parent_instr); + new_intrin = nir_def_as_intrinsic(img_load); nir_intrinsic_set_range_base(new_intrin, nir_intrinsic_range_base(intrin)); } else { img_load = nir_bindless_image_load(b, @@ -97,7 +97,7 @@ lower_sparse_image_load(nir_builder *b, nir_intrinsic_instr *intrin) intrin->src[1].ssa, intrin->src[2].ssa, intrin->src[3].ssa); - new_intrin = nir_instr_as_intrinsic(img_load->parent_instr); + new_intrin = nir_def_as_intrinsic(img_load); } nir_intrinsic_set_image_array(new_intrin, nir_intrinsic_image_array(intrin)); diff --git a/src/intel/compiler/intel_nir_opt_peephole_ffma.c b/src/intel/compiler/intel_nir_opt_peephole_ffma.c index e895b9fc415..588d6a98b45 100644 --- a/src/intel/compiler/intel_nir_opt_peephole_ffma.c +++ b/src/intel/compiler/intel_nir_opt_peephole_ffma.c @@ -143,7 +143,7 @@ any_alu_src_is_a_constant(nir_alu_src srcs[]) for (unsigned i = 0; i < 2; i++) { if (srcs[i].src.ssa->parent_instr->type == nir_instr_type_load_const) { nir_load_const_instr *load_const = - nir_instr_as_load_const (srcs[i].src.ssa->parent_instr); + nir_def_as_load_const(srcs[i].src.ssa); if (list_is_singular(&load_const->def.uses)) return true; diff --git a/src/intel/vulkan/anv_nir_push_descriptor_analysis.c b/src/intel/vulkan/anv_nir_push_descriptor_analysis.c index fd35426d0ea..4e3ff2243c4 100644 --- a/src/intel/vulkan/anv_nir_push_descriptor_analysis.c +++ b/src/intel/vulkan/anv_nir_push_descriptor_analysis.c @@ -197,7 +197,7 @@ anv_nir_push_desc_ubo_fully_promoted(nir_shader *nir, /* Don't check the load_ubo from descriptor buffers */ nir_intrinsic_instr *resource = intrin->src[0].ssa->parent_instr->type == nir_instr_type_intrinsic ? - nir_instr_as_intrinsic(intrin->src[0].ssa->parent_instr) : NULL; + nir_def_as_intrinsic(intrin->src[0].ssa) : NULL; if (resource == NULL || resource->intrinsic != nir_intrinsic_resource_intel) continue; diff --git a/src/mesa/main/ff_fragment_shader.c b/src/mesa/main/ff_fragment_shader.c index 99237053f4d..e1c10b3617b 100644 --- a/src/mesa/main/ff_fragment_shader.c +++ b/src/mesa/main/ff_fragment_shader.c @@ -392,7 +392,7 @@ load_input(struct texenv_fragment_program *p, gl_varying_slot slot) nir_def *baryc = nir_load_barycentric_pixel(p->b, 32); if (slot != VARYING_SLOT_COL0 && slot != VARYING_SLOT_COL1) { - nir_intrinsic_set_interp_mode(nir_instr_as_intrinsic(baryc->parent_instr), + nir_intrinsic_set_interp_mode(nir_def_as_intrinsic(baryc), INTERP_MODE_SMOOTH); } diff --git a/src/mesa/program/prog_to_nir.c b/src/mesa/program/prog_to_nir.c index 5b299757459..450dd635de0 100644 --- a/src/mesa/program/prog_to_nir.c +++ b/src/mesa/program/prog_to_nir.c @@ -102,7 +102,7 @@ ptn_get_src(struct ptn_compile *c, const struct prog_src_register *prog_src) nir_def *baryc = nir_load_barycentric_pixel(b, 32); if (slot != VARYING_SLOT_COL0 && slot != VARYING_SLOT_COL1) { - nir_intrinsic_set_interp_mode(nir_instr_as_intrinsic(baryc->parent_instr), + nir_intrinsic_set_interp_mode(nir_def_as_intrinsic(baryc), INTERP_MODE_SMOOTH); } diff --git a/src/mesa/state_tracker/st_atifs_to_nir.c b/src/mesa/state_tracker/st_atifs_to_nir.c index c8c9f94a059..30ff9545997 100644 --- a/src/mesa/state_tracker/st_atifs_to_nir.c +++ b/src/mesa/state_tracker/st_atifs_to_nir.c @@ -113,7 +113,7 @@ load_input(struct st_translate *t, gl_varying_slot slot) nir_def *baryc = nir_load_barycentric_pixel(t->b, 32); if (slot != VARYING_SLOT_COL0 && slot != VARYING_SLOT_COL1) { - nir_intrinsic_set_interp_mode(nir_instr_as_intrinsic(baryc->parent_instr), + nir_intrinsic_set_interp_mode(nir_def_as_intrinsic(baryc), INTERP_MODE_SMOOTH); } diff --git a/src/mesa/state_tracker/st_nir_unlower_io_to_vars.c b/src/mesa/state_tracker/st_nir_unlower_io_to_vars.c index b49105e8d23..1d548ade787 100644 --- a/src/mesa/state_tracker/st_nir_unlower_io_to_vars.c +++ b/src/mesa/state_tracker/st_nir_unlower_io_to_vars.c @@ -142,7 +142,7 @@ parse_intrinsic(nir_shader *nir, nir_intrinsic_instr *intr, if (intr->intrinsic == nir_intrinsic_load_interpolated_input && intr->src[0].ssa->parent_instr->type == nir_instr_type_intrinsic) - desc->baryc = nir_instr_as_intrinsic(intr->src[0].ssa->parent_instr); + desc->baryc = nir_def_as_intrinsic(intr->src[0].ssa); /* Find the variable if it exists. */ *var = NULL; diff --git a/src/microsoft/clc/clc_compiler.c b/src/microsoft/clc/clc_compiler.c index 62f03237c52..4be9a6178c0 100644 --- a/src/microsoft/clc/clc_compiler.c +++ b/src/microsoft/clc/clc_compiler.c @@ -371,8 +371,7 @@ clc_lower_nonnormalized_samplers(nir_shader *nir, nir_src *sampler_src = &tex->src[sampler_src_idx].src; assert(sampler_src->ssa->parent_instr->type == nir_instr_type_deref); - nir_variable *sampler = nir_deref_instr_get_variable( - nir_instr_as_deref(sampler_src->ssa->parent_instr)); + nir_variable *sampler = nir_deref_instr_get_variable(nir_def_as_deref(sampler_src->ssa)); // If the sampler returns ints, we'll handle this in the int lowering pass if (nir_alu_type_get_base_type(tex->dest_type) != nir_type_float) diff --git a/src/microsoft/compiler/dxil_nir.c b/src/microsoft/compiler/dxil_nir.c index 4b1bd8034d2..f75ba12b471 100644 --- a/src/microsoft/compiler/dxil_nir.c +++ b/src/microsoft/compiler/dxil_nir.c @@ -2681,7 +2681,7 @@ set_deref_variables_coherent(nir_shader *s, nir_deref_instr *deref) /* For derefs with casts, we only support pre-lowered Vulkan accesses */ assert(deref->deref_type == nir_deref_type_cast); - nir_intrinsic_instr *cast_src = nir_instr_as_intrinsic(deref->parent.ssa->parent_instr); + nir_intrinsic_instr *cast_src = nir_def_as_intrinsic(deref->parent.ssa); assert(cast_src->intrinsic == nir_intrinsic_load_vulkan_descriptor); nir_binding binding = nir_chase_binding(cast_src->src[0]); set_binding_variables_coherent(s, binding, nir_var_mem_ssbo); @@ -2772,7 +2772,7 @@ lower_coherent_load_store(nir_builder *b, nir_intrinsic_instr *intr, void *conte return false; } - nir_intrinsic_instr *atomic = nir_instr_as_intrinsic(atomic_def->parent_instr); + nir_intrinsic_instr *atomic = nir_def_as_intrinsic(atomic_def); nir_intrinsic_set_access(atomic, nir_intrinsic_access(intr)); if (nir_intrinsic_has_image_dim(intr)) nir_intrinsic_set_image_dim(atomic, nir_intrinsic_image_dim(intr)); diff --git a/src/microsoft/compiler/dxil_nir_lower_int_cubemaps.c b/src/microsoft/compiler/dxil_nir_lower_int_cubemaps.c index 3809d994a99..1b34fadddb5 100644 --- a/src/microsoft/compiler/dxil_nir_lower_int_cubemaps.c +++ b/src/microsoft/compiler/dxil_nir_lower_int_cubemaps.c @@ -85,7 +85,7 @@ lower_int_cubmap_to_array_filter(const nir_instr *instr, int sampler_deref = nir_tex_instr_src_index(tex, nir_tex_src_sampler_deref); assert(sampler_deref >= 0); - nir_deref_instr *deref = nir_instr_as_deref(tex->src[sampler_deref].src.ssa->parent_instr); + nir_deref_instr *deref = nir_def_as_deref(tex->src[sampler_deref].src.ssa); nir_variable *cube = nir_deref_instr_get_variable(deref); return glsl_base_type_is_integer(glsl_get_sampler_result_type(cube->type)); } diff --git a/src/microsoft/compiler/dxil_nir_lower_int_samplers.c b/src/microsoft/compiler/dxil_nir_lower_int_samplers.c index 9198ce4122e..c31458faadd 100644 --- a/src/microsoft/compiler/dxil_nir_lower_int_samplers.c +++ b/src/microsoft/compiler/dxil_nir_lower_int_samplers.c @@ -139,7 +139,7 @@ wrap_repeat(nir_builder *b, wrap_result_t *wrap_params, nir_def *size) * This instruction must be exact, otherwise certain sizes result in * incorrect sampling */ wrap_params->coords = nir_fmod(b, wrap_params->coords, size); - nir_instr_as_alu(wrap_params->coords->parent_instr)->exact = true; + nir_def_as_alu(wrap_params->coords)->exact = true; } static nir_def * @@ -155,7 +155,7 @@ wrap_mirror_repeat(nir_builder *b, wrap_result_t *wrap_params, nir_def *size) { /* (size − 1) − mirror(mod(coord, 2 * size) − size) */ nir_def *coord_mod2size = nir_fmod(b, wrap_params->coords, nir_fmul_imm(b, size, 2.0f)); - nir_instr_as_alu(coord_mod2size->parent_instr)->exact = true; + nir_def_as_alu(coord_mod2size)->exact = true; nir_def *a = nir_fsub(b, coord_mod2size, size); wrap_params->coords = nir_fsub(b, nir_fadd_imm(b, size, -1.0f), mirror(b, a)); } diff --git a/src/nouveau/compiler/nak_nir_lower_cmat.c b/src/nouveau/compiler/nak_nir_lower_cmat.c index c705a42781e..dd0deb2a945 100644 --- a/src/nouveau/compiler/nak_nir_lower_cmat.c +++ b/src/nouveau/compiler/nak_nir_lower_cmat.c @@ -610,7 +610,7 @@ lower_cmat_instr(nir_builder *b, const enum glsl_matrix_layout layout = nir_intrinsic_matrix_layout(intr); nir_deref_instr *deref = - nir_instr_as_deref(intr->src[1].ssa->parent_instr); + nir_def_as_deref(intr->src[1].ssa); nir_def *stride = intr->src[2].ssa; nir_def *vars[NIR_MAX_VEC_COMPONENTS]; diff --git a/src/nouveau/compiler/nak_nir_lower_kepler_shared_atomics.c b/src/nouveau/compiler/nak_nir_lower_kepler_shared_atomics.c index f00e989571f..9383c695848 100644 --- a/src/nouveau/compiler/nak_nir_lower_kepler_shared_atomics.c +++ b/src/nouveau/compiler/nak_nir_lower_kepler_shared_atomics.c @@ -49,7 +49,7 @@ lower_atomic_in_lock(nir_builder *b, nir_intrinsic_instr *intr, nir_def *loaded) case nir_atomic_op_iadd: { to_store = nir_build_alu2( b, nir_atomic_op_to_alu(nir_intrinsic_atomic_op(intr)), loaded, data); - nir_alu_instr *alu = nir_instr_as_alu(to_store->parent_instr); + nir_alu_instr *alu = nir_def_as_alu(to_store); alu->exact = true; alu->fp_fast_math = 0; break; diff --git a/src/nouveau/compiler/nak_nir_lower_tex.c b/src/nouveau/compiler/nak_nir_lower_tex.c index d7bce06fc74..0600396afad 100644 --- a/src/nouveau/compiler/nak_nir_lower_tex.c +++ b/src/nouveau/compiler/nak_nir_lower_tex.c @@ -27,7 +27,7 @@ tex_handle_as_cbuf(nir_def *tex_h, uint32_t *cbuf_out) if (tex_h->parent_instr->type != nir_instr_type_intrinsic) return false; - nir_intrinsic_instr *intrin = nir_instr_as_intrinsic(tex_h->parent_instr); + nir_intrinsic_instr *intrin = nir_def_as_intrinsic(tex_h); if (intrin->intrinsic != nir_intrinsic_ldc_nv) return false; diff --git a/src/nouveau/compiler/nak_nir_rematerialize_load_const.c b/src/nouveau/compiler/nak_nir_rematerialize_load_const.c index 996ce01a030..8b885c5cd48 100644 --- a/src/nouveau/compiler/nak_nir_rematerialize_load_const.c +++ b/src/nouveau/compiler/nak_nir_rematerialize_load_const.c @@ -28,7 +28,7 @@ rematerialize_load_const(nir_src *src, void *_ctx) } nir_load_const_instr *old_lc = - nir_instr_as_load_const(src->ssa->parent_instr); + nir_def_as_load_const(src->ssa); nir_load_const_instr *new_lc = nir_instr_as_load_const(nir_instr_clone(ctx->b.shader, &old_lc->instr)); diff --git a/src/nouveau/vulkan/nvk_cmd_indirect.c b/src/nouveau/vulkan/nvk_cmd_indirect.c index 6a22b21535b..20e5c93dd96 100644 --- a/src/nouveau/vulkan/nvk_cmd_indirect.c +++ b/src/nouveau/vulkan/nvk_cmd_indirect.c @@ -804,7 +804,7 @@ build_process_shader(struct nvk_device *dev, /* Replace the out stride with the actual size of a command stream */ nir_load_const_instr *out_stride_const = - nir_instr_as_load_const(out_stride->parent_instr); + nir_def_as_load_const(out_stride); out_stride_const->value[0].u32 = push.max_dw_count * 4; /* We also output this stride to go in the layout struct */ diff --git a/src/nouveau/vulkan/nvk_nir_lower_descriptors.c b/src/nouveau/vulkan/nvk_nir_lower_descriptors.c index 1d3a1ea5417..65445c51e70 100644 --- a/src/nouveau/vulkan/nvk_nir_lower_descriptors.c +++ b/src/nouveau/vulkan/nvk_nir_lower_descriptors.c @@ -1193,7 +1193,7 @@ lower_edb_buffer_tex_instr(nir_builder *b, nir_tex_instr *tex, ACCESS_CAN_REORDER, .dest_type = tex->dest_type); if (tex->is_sparse) { - nir_intrinsic_instr *intr = nir_instr_as_intrinsic(res->parent_instr); + nir_intrinsic_instr *intr = nir_def_as_intrinsic(res); intr->intrinsic = nir_intrinsic_bindless_image_sparse_load; } diff --git a/src/panfrost/midgard/midgard_address.c b/src/panfrost/midgard/midgard_address.c index fc36cb7f3c1..5dacb66ecb2 100644 --- a/src/panfrost/midgard/midgard_address.c +++ b/src/panfrost/midgard/midgard_address.c @@ -49,7 +49,7 @@ struct mir_address { static bool mir_args_ssa(nir_scalar s, unsigned count) { - nir_alu_instr *alu = nir_instr_as_alu(s.def->parent_instr); + nir_alu_instr *alu = nir_def_as_alu(s.def); if (count > nir_op_infos[alu->op].num_inputs) return false;