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

treewide: sed out more is_ssa

Browse Source 
Signed-off-by: Alyssa Rosenzweig <alyssa@rosenzweig.io>
Reviewed-by: Faith Ekstrand <faith.ekstrand@collabora.com>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/24432>
This commit is contained in:
Alyssa Rosenzweig
2023-08-01 12:07:25 -04:00
committed by Marge Bot
parent a8013644a1
commit 95e3df39c0
48 changed files with 7 additions and 98 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/compiler/nir/nir.c
+1 -9
View File
@@ -1759,7 +1759,7 @@ get_store_value(nir_intrinsic_instr *intrin)
nir_component_mask_t
nir_src_components_read(const nir_src *src)
{
assert(src->is_ssa && src->parent_instr);
assert(src->parent_instr);
if (src->parent_instr->type == nir_instr_type_alu) {
nir_alu_instr *alu = nir_instr_as_alu(src->parent_instr);
@@ -2168,13 +2168,6 @@ cursor_next_instr(nir_cursor cursor)
unreachable("Inavlid cursor option");
}
ASSERTED static bool
dest_is_ssa(nir_dest *dest, void *_state)
{
(void) _state;
return dest->is_ssa;
}
bool
nir_function_impl_lower_instructions(nir_function_impl *impl,
nir_instr_filter_cb filter,
@@ -2195,7 +2188,6 @@ nir_function_impl_lower_instructions(nir_function_impl *impl,
continue;
}
assert(nir_foreach_dest(instr, dest_is_ssa, NULL));
nir_ssa_def *old_def = nir_instr_ssa_def(instr);
struct list_head old_uses;
if (old_def != NULL) {
src/compiler/nir/nir_clone.c
-2
View File
@@ -199,7 +199,6 @@ static void
__clone_src(clone_state *state, void *ninstr_or_if,
nir_src *nsrc, const nir_src *src)
{
assert(src->is_ssa);
nsrc->is_ssa = true;
nsrc->ssa = remap_local(state, src->ssa);
}
@@ -208,7 +207,6 @@ static void
__clone_dst(clone_state *state, nir_instr *ninstr,
nir_dest *ndst, const nir_dest *dst)
{
assert(dst->is_ssa);
ndst->is_ssa = true;
nir_ssa_dest_init(ninstr, ndst, dst->ssa.num_components,
dst->ssa.bit_size);
src/compiler/nir/nir_from_ssa.c
-1
View File
@@ -664,7 +664,6 @@ rewrite_src(nir_src *src, void *void_state)
{
struct from_ssa_state *state = void_state;
assert(src->is_ssa);
nir_ssa_def *reg = reg_for_ssa_def(src->ssa, state);
if (reg == NULL)
return true;
src/compiler/nir/nir_gather_info.c
-2
View File
@@ -30,7 +30,6 @@
static bool
src_is_invocation_id(const nir_src *src)
{
assert(src->is_ssa);
nir_ssa_scalar s = nir_ssa_scalar_resolved(src->ssa, 0);
return s.def->parent_instr->type == nir_instr_type_intrinsic &&
nir_instr_as_intrinsic(s.def->parent_instr)->intrinsic ==
@@ -40,7 +39,6 @@ src_is_invocation_id(const nir_src *src)
static bool
src_is_local_invocation_index(const nir_src *src)
{
assert(src->is_ssa);
nir_ssa_scalar s = nir_ssa_scalar_resolved(src->ssa, 0);
return s.def->parent_instr->type == nir_instr_type_intrinsic &&
nir_instr_as_intrinsic(s.def->parent_instr)->intrinsic ==
src/compiler/nir/nir_instr_set.c
-4
View File
@@ -58,9 +58,6 @@ instr_each_src_and_dest_is_ssa(const nir_instr *instr)
static bool
instr_can_rewrite(const nir_instr *instr)
{
/* We only handle SSA. */
assert(instr_each_src_and_dest_is_ssa(instr));
switch (instr->type) {
case nir_instr_type_alu:
case nir_instr_type_deref:
@@ -88,7 +85,6 @@ instr_can_rewrite(const nir_instr *instr)
static uint32_t
hash_src(uint32_t hash, const nir_src *src)
{
assert(src->is_ssa);
hash = HASH(hash, src->ssa);
return hash;
}
src/compiler/nir/nir_legacy.c
-7
View File
@@ -42,7 +42,6 @@ nir_legacy_float_mod_folds(nir_alu_instr *mod)
static nir_legacy_alu_src
chase_alu_src_helper(const nir_src *src)
{
assert(src->is_ssa && "registers lowered to intrinsics");
nir_intrinsic_instr *load = nir_load_reg_for_def(src->ssa);
if (load) {
@@ -92,7 +91,6 @@ chase_source_mod(nir_ssa_def **ssa, nir_op op, uint8_t *swizzle)
for (unsigned i = 0; i < NIR_MAX_VEC_COMPONENTS; ++i)
swizzle[i] = alu->src[0].swizzle[swizzle[i]];
assert(alu->src[0].src.is_ssa && "registers lowered to intrinsics");
*ssa = alu->src[0].src.ssa;
return true;
}
@@ -100,8 +98,6 @@ chase_source_mod(nir_ssa_def **ssa, nir_op op, uint8_t *swizzle)
nir_legacy_alu_src
nir_legacy_chase_alu_src(const nir_alu_src *src, bool fuse_fabs)
{
assert(src->src.is_ssa && "registers lowered to intrinsics");
if (src->src.ssa->parent_instr->type == nir_instr_type_alu) {
nir_legacy_alu_src out = {
.src.is_ssa = true,
@@ -129,7 +125,6 @@ nir_legacy_chase_alu_src(const nir_alu_src *src, bool fuse_fabs)
static nir_legacy_alu_dest
chase_alu_dest_helper(nir_dest *dest)
{
assert(dest->is_ssa && "registers lowered to intrinsics");
nir_intrinsic_instr *store = nir_store_reg_for_def(&dest->ssa);
if (store) {
@@ -227,7 +222,6 @@ chase_fsat(nir_ssa_def **def)
nir_legacy_alu_dest
nir_legacy_chase_alu_dest(nir_dest *dest)
{
assert(dest->is_ssa && "registers lowered to intrinsics");
nir_ssa_def *def = &dest->ssa;
/* Try SSA fsat. No users support 64-bit modifiers. */
@@ -320,7 +314,6 @@ fuse_mods_with_registers(nir_builder *b, nir_instr *instr, void *fuse_fabs_)
nir_legacy_alu_dest dest = nir_legacy_chase_alu_dest(&alu->dest.dest);
if (dest.fsat) {
assert(dest.dest.is_ssa && "not fully chased");
nir_intrinsic_instr *store = nir_store_reg_for_def(dest.dest.ssa);
if (store) {
src/compiler/nir/nir_lower_amul.c
-2
View File
@@ -75,8 +75,6 @@ lower_large_src(nir_src *src, void *s)
{
lower_state *state = s;
assert(src->is_ssa);
nir_instr *parent = src->ssa->parent_instr;
/* No need to visit instructions we've already visited.. this also
src/compiler/nir/nir_lower_blend.c
-1
View File
@@ -633,7 +633,6 @@ consume_dual_stores(nir_builder *b, nir_instr *instr, void *data)
int rt = color_index_for_location(sem.location);
assert(rt >= 0 && rt < 8 && "bounds for dual-source blending");
assert(store->src[0].is_ssa && "must be SSA");
outputs[rt] = store->src[0].ssa;
nir_instr_remove(instr);
src/compiler/nir/nir_lower_const_arrays_to_uniforms.c
-1
View File
@@ -79,7 +79,6 @@ set_const_initialiser(nir_deref_instr **p, nir_constant *top_level_init,
/* Now that we have selected the corrent nir_constant we copy the constant
* values to it.
*/
assert(const_src->is_ssa);
nir_instr *src_instr = const_src->ssa->parent_instr;
assert(src_instr->type == nir_instr_type_load_const);
nir_load_const_instr* load = nir_instr_as_load_const(src_instr);
src/compiler/nir/nir_lower_int64.c
+2 -2
View File
@@ -1144,7 +1144,7 @@ split_64bit_subgroup_op(nir_builder *b, const nir_intrinsic_instr *intrin)
/* This works on subgroup ops with a single 64-bit source which can be
* trivially lowered by doing the exact same op on both halves.
*/
assert(intrin->src[0].is_ssa && intrin->src[0].ssa->bit_size == 64);
assert(nir_src_bit_size(intrin->src[0]) == 64);
nir_ssa_def *split_src0[2] = {
nir_unpack_64_2x32_split_x(b, intrin->src[0].ssa),
nir_unpack_64_2x32_split_y(b, intrin->src[0].ssa),
@@ -1161,7 +1161,7 @@ split_64bit_subgroup_op(nir_builder *b, const nir_intrinsic_instr *intrin)
/* Other sources must be less than 64 bits and get copied directly */
for (unsigned j = 1; j < info->num_srcs; j++) {
assert(intrin->src[j].is_ssa && intrin->src[j].ssa->bit_size < 64);
assert(nir_src_bit_size(intrin->src[j]) < 64);
split->src[j] = nir_src_for_ssa(intrin->src[j].ssa);
}
src/compiler/nir/nir_lower_io.c
+1 -1
View File
@@ -533,7 +533,7 @@ lower_interpolate_at(nir_intrinsic_instr *intrin, struct lower_io_state *state,
}
/* None of the supported APIs allow interpolation on 64-bit things */
assert(intrin->dest.is_ssa && intrin->dest.ssa.bit_size <= 32);
assert(nir_dest_bit_size(intrin->dest) <= 32);
nir_intrinsic_op bary_op;
switch (intrin->intrinsic) {
src/compiler/nir/nir_lower_mem_access_bit_sizes.c
-2
View File
@@ -81,7 +81,6 @@ lower_mem_load(nir_builder *b, nir_intrinsic_instr *intrin,
const uint32_t whole_align = nir_intrinsic_align(intrin);
nir_src *offset_src = nir_get_io_offset_src(intrin);
const bool offset_is_const = nir_src_is_const(*offset_src);
assert(offset_src->is_ssa);
nir_ssa_def *offset = offset_src->ssa;
nir_mem_access_size_align requested =
@@ -241,7 +240,6 @@ lower_mem_store(nir_builder *b, nir_intrinsic_instr *intrin,
const uint32_t whole_align = nir_intrinsic_align(intrin);
nir_src *offset_src = nir_get_io_offset_src(intrin);
const bool offset_is_const = nir_src_is_const(*offset_src);
assert(offset_src->is_ssa);
nir_ssa_def *offset = offset_src->ssa;
nir_component_mask_t writemask = nir_intrinsic_write_mask(intrin);
src/compiler/nir/nir_lower_non_uniform_access.c
-1
View File
@@ -56,7 +56,6 @@ nu_handle_init(struct nu_handle *h, nir_src *src)
if (nir_src_is_const(*src))
return false;
assert(src->is_ssa);
h->handle = src->ssa;
h->parent_deref = NULL;
src/compiler/nir/nir_lower_shader_calls.c
-3
View File
@@ -101,7 +101,6 @@ static bool
src_is_in_bitset(nir_src *src, void *_set)
{
struct sized_bitset *set = _set;
assert(src->is_ssa);
/* Any SSA values which were added after we generated liveness information
* are things generated by this pass and, while most of it is arithmetic
@@ -371,7 +370,6 @@ static nir_ssa_def *
get_phi_builder_def_for_src(nir_src *src, struct pbv_array *pbv_arr,
nir_block *block)
{
assert(src->is_ssa);
struct nir_phi_builder_value *pbv =
get_phi_builder_value_for_def(src->ssa, pbv_arr);
@@ -423,7 +421,6 @@ add_src_to_call_live_bitset(nir_src *src, void *state)
{
BITSET_WORD *call_live = state;
assert(src->is_ssa);
BITSET_SET(call_live, src->ssa->index);
return true;
}
src/compiler/nir/nir_move_vec_src_uses_to_dest.c
-1
View File
@@ -124,7 +124,6 @@ move_vec_src_uses_to_dest_block(nir_block *block)
if (use->parent_instr->type != nir_instr_type_alu)
continue;
assert(use->is_ssa);
nir_alu_instr *use_alu = nir_instr_as_alu(use->parent_instr);
src/compiler/nir/nir_opt_copy_prop_vars.c
-1
View File
@@ -717,7 +717,6 @@ load_from_ssa_entry_value(struct copy_prop_var_state *state,
}
*value = entry->src;
assert(value->is_ssa);
const struct glsl_type *type = entry->dst.instr->type;
unsigned num_components = glsl_get_vector_elements(type);
src/compiler/nir/nir_opt_gcm.c
-2
View File
@@ -165,7 +165,6 @@ gcm_build_block_info(struct exec_list *cf_list, struct gcm_state *state,
static bool
is_src_scalarizable(nir_src *src)
{
assert(src->is_ssa);
nir_instr *src_instr = src->ssa->parent_instr;
switch (src_instr->type) {
@@ -428,7 +427,6 @@ gcm_schedule_early_src(nir_src *src, void *void_state)
struct gcm_state *state = void_state;
nir_instr *instr = state->instr;
assert(src->is_ssa);
gcm_schedule_early_instr(src->ssa->parent_instr, void_state);
src/compiler/nir/nir_opt_preamble.c
-1
View File
@@ -98,7 +98,6 @@ can_move_src(nir_src *src, void *state)
{
opt_preamble_ctx *ctx = state;
assert(src->is_ssa);
return ctx->states[src->ssa->index].can_move;
}
src/compiler/nir/nir_opt_vectorize.c
-3
View File
@@ -42,7 +42,6 @@
static uint32_t
hash_src(uint32_t hash, const nir_src *src)
{
assert(src->is_ssa);
void *hash_data = nir_src_is_const(*src) ? NULL : src->ssa;
return HASH(hash, hash_data);
@@ -84,8 +83,6 @@ hash_instr(const void *data)
static bool
srcs_equal(const nir_src *src1, const nir_src *src2)
{
assert(src1->is_ssa);
assert(src2->is_ssa);
return src1->ssa == src2->ssa ||
(nir_src_is_const(*src1) && nir_src_is_const(*src2));
src/compiler/nir/nir_print.c
-2
View File
@@ -384,14 +384,12 @@ static void print_src(const nir_src *src, print_state *state, nir_alu_type src_t
static void
print_src(const nir_src *src, print_state *state, nir_alu_type src_type)
{
assert(src->is_ssa);
print_ssa_use(src->ssa, state, src_type);
}
static void
print_dest(nir_dest *dest, print_state *state)
{
assert(dest->is_ssa);
print_ssa_def(&dest->ssa, state);
}
src/compiler/nir/nir_serialize.c
-3
View File
@@ -470,7 +470,6 @@ union packed_src {
static void
write_src_full(write_ctx *ctx, const nir_src *src, union packed_src header)
{
assert(src->is_ssa);
header.any.object_idx = write_lookup_object(ctx, src->ssa);
blob_write_uint32(ctx->blob, header.u32);
}
@@ -616,7 +615,6 @@ write_dest(write_ctx *ctx, const nir_dest *dst, union packed_instr header,
union packed_dest dest;
dest.u8 = 0;
assert(dst->is_ssa);
dest.num_components =
encode_num_components_in_3bits(dst->ssa.num_components);
dest.bit_size = encode_bit_size_3bits(dst->ssa.bit_size);
@@ -665,7 +663,6 @@ write_dest(write_ctx *ctx, const nir_dest *dst, union packed_instr header,
if (dest.num_components == NUM_COMPONENTS_IS_SEPARATE_7)
blob_write_uint32(ctx->blob, dst->ssa.num_components);
assert(dst->is_ssa);
write_add_object(ctx, &dst->ssa);
}
src/compiler/nir/nir_to_lcssa.c
-1
View File
@@ -123,7 +123,6 @@ def_is_invariant(nir_ssa_def *def, nir_loop *loop)
static bool
src_is_invariant(nir_src *src, void *state)
{
assert(src->is_ssa);
return def_is_invariant(src->ssa, (nir_loop *)state);
}
src/compiler/nir/nir_trivialize_registers.c
-1
View File
@@ -116,7 +116,6 @@ trivialize_src(nir_src *src, void *state_)
{
struct trivialize_src_state *state = state_;
assert(src->is_ssa && "register intrinsics only");
nir_instr *parent = src->ssa->parent_instr;
if (parent->type != nir_instr_type_intrinsic)
return true;
src/compiler/nir/nir_validate.c
-3
View File
@@ -161,7 +161,6 @@ validate_src(nir_src *src, validate_state *state,
else
validate_assert(state, src->parent_if == state->if_stmt);
validate_assert(state, src->is_ssa);
validate_ssa_src(src, state, bit_sizes, num_components);
}
@@ -193,7 +192,6 @@ validate_ssa_def(nir_ssa_def *def, validate_state *state)
list_validate(&def->uses);
nir_foreach_use_including_if(src, def) {
validate_assert(state, src->is_ssa);
validate_assert(state, src->ssa == def);
bool already_seen = false;
@@ -207,7 +205,6 @@ static void
validate_dest(nir_dest *dest, validate_state *state,
unsigned bit_sizes, unsigned num_components)
{
validate_assert(state, dest->is_ssa);
if (bit_sizes)
validate_assert(state, dest->ssa.bit_size & bit_sizes);
if (num_components)