{
nir_instr *instr = state;
- if (!dest->is_ssa) {
- dest->reg.parent_instr = instr;
- list_addtail(&dest->reg.def_link, &dest->reg.reg->defs);
- }
-
return true;
}
{
(void) state;
- if (!dest->is_ssa)
- list_del(&dest->reg.def_link);
-
return true;
}
bool
nir_src_is_always_uniform(nir_src src)
{
- if (!src.is_ssa)
- return false;
-
/* Constants are trivially uniform */
if (src.ssa->parent_instr->type == nir_instr_type_load_const)
return true;
static bool
dest_replace_ssa_with_reg(nir_dest *dest, nir_function_impl *impl)
{
- if (!dest->is_ssa)
- return false;
-
nir_builder b = nir_builder_create(impl);
nir_ssa_def *reg = decl_reg_for_ssa_def(&b, &dest->ssa);
uint32_t *uni_offsets, uint8_t *num_offsets,
unsigned max_num_bo, unsigned max_offset)
{
- if (!src->is_ssa)
- return false;
-
assert(max_num_bo > 0 && max_num_bo <= MAX_NUM_BO);
assert(component < src->ssa->num_components);
uint32_t *uni_offsets, uint8_t *num_offsets,
unsigned max_num_bo, unsigned max_offset)
{
- if (!src->is_ssa)
- return false;
-
assert(component < src->ssa->num_components);
/* Return true for induction variable (ie. i in for loop) */
{
BITSET_WORD *live = void_live;
- if (!src->is_ssa)
- return true;
-
if (nir_src_is_undef(*src))
return true; /* undefined variables are never live */
static bool
is_only_uniform_src(nir_src *src)
{
- if (!src->is_ssa)
- return false;
-
nir_instr *instr = src->ssa->parent_instr;
switch (instr->type) {
{
nir_const_value src[NIR_MAX_VEC_COMPONENTS][NIR_MAX_VEC_COMPONENTS];
- if (!alu->dest.dest.is_ssa)
- return false;
-
/* In the case that any outputs/inputs have unsized types, then we need to
* guess the bit-size. In this case, the validator ensures that all
* bit-sizes match so we can just take the bit-size from first
bit_size = alu->dest.dest.ssa.bit_size;
for (unsigned i = 0; i < nir_op_infos[alu->op].num_inputs; i++) {
- if (!alu->src[i].src.is_ssa)
- return false;
-
if (bit_size == 0 &&
!nir_alu_type_get_type_size(nir_op_infos[alu->op].input_types[i]))
bit_size = alu->src[i].src.ssa->bit_size;
is_phi_src_scalarizable(nir_phi_src *src,
struct lower_phis_to_scalar_state *state)
{
- /* Don't know what to do with non-ssa sources */
- if (!src->src.is_ssa)
- return false;
nir_instr *src_instr = src->src.ssa->parent_instr;
switch (src_instr->type) {
continue; /* The loop */
}
- /* Can't handle non-SSA vec operations */
- if (!vec->dest.dest.is_ssa)
- continue;
-
/* First, mark all of the sources we are going to consider for rewriting
* to the destination
*/
int srcs_remaining = 0;
for (unsigned i = 0; i < nir_op_infos[vec->op].num_inputs; i++) {
- /* We can't rewrite a source if it's not in SSA form */
- if (!vec->src[i].src.is_ssa)
- continue;
srcs_remaining |= 1 << i;
}
{
nir_const_value src[NIR_MAX_VEC_COMPONENTS][NIR_MAX_VEC_COMPONENTS];
- if (!alu->dest.dest.is_ssa)
- return false;
-
/* In the case that any outputs/inputs have unsized types, then we need to
* guess the bit-size. In this case, the validator ensures that all
* bit-sizes match so we can just take the bit-size from first
bit_size = alu->dest.dest.ssa.bit_size;
for (unsigned i = 0; i < nir_op_infos[alu->op].num_inputs; i++) {
- if (!alu->src[i].src.is_ssa)
- return false;
-
if (bit_size == 0 &&
!nir_alu_type_get_type_size(nir_op_infos[alu->op].input_types[i]))
bit_size = alu->src[i].src.ssa->bit_size;
value_set_ssa_components(struct value *value, nir_ssa_def *def,
unsigned num_components)
{
- if (!value->is_ssa)
- memset(&value->ssa, 0, sizeof(value->ssa));
value->is_ssa = true;
for (unsigned i = 0; i < num_components; i++) {
value->ssa.def[i] = def;
bool *entry_removed)
{
util_dynarray_foreach_reverse(copies_array, struct copy_entry, iter) {
- if (!iter->src.is_ssa) {
- /* If this write aliases the source of some entry, get rid of it */
- nir_deref_compare_result result =
- nir_compare_derefs_and_paths(state->mem_ctx, &iter->src.deref, deref);
- if (result & nir_derefs_may_alias_bit) {
- copy_entry_remove(copies_array, iter, entry);
- continue;
- }
- }
-
nir_deref_compare_result comp =
nir_compare_derefs_and_paths(state->mem_ctx, &iter->dst, deref);
if (from->is_ssa) {
/* Clear value if it was being used as non-SSA. */
- if (!value->is_ssa)
- memset(&value->ssa, 0, sizeof(value->ssa));
value->is_ssa = true;
/* Only overwrite the written components */
for (unsigned i = 0; i < NIR_MAX_VEC_COMPONENTS; i++) {
static void
print_value(struct value *value, unsigned num_components)
{
- if (!value->is_ssa) {
- printf(" %s ", glsl_get_type_name(value->deref.instr->type));
- nir_print_deref(value->deref.instr, stdout);
- return;
- }
-
bool same_ssa = true;
for (unsigned i = 0; i < num_components; i++) {
if (value->ssa.component[i] != i ||
return false;
nir_if *nif = nir_cf_node_as_if(if_node);
- if (!nif->condition.is_ssa)
- return false;
nir_ssa_def *cond = nif->condition.ssa;
if (cond->parent_instr->type != nir_instr_type_phi)
static bool
can_move_src(nir_src *src, void *worklist)
{
- if (!src->is_ssa)
- return false;
-
nir_instr *instr = src->ssa->parent_instr;
if (instr->pass_flags)
return true;
break;
}
- /* It must be SSA */
- if (!mov->dest.dest.is_ssa)
- return false;
-
if (alu_ok) {
/* If the ALU operation is an fsat or a move-like operation, do
* not count it. The expectation is that it will eventually be
all_srcs_are_ssa(const nir_alu_instr *instr)
{
for (unsigned i = 0; i < nir_op_infos[instr->op].num_inputs; i++) {
- if (!instr->src[i].src.is_ssa)
- return false;
}
return true;
static bool
all_uses_are_bcsel(const nir_alu_instr *instr)
{
- if (!instr->dest.dest.is_ssa)
- return false;
-
nir_foreach_use(use, &instr->dest.dest.ssa) {
if (use->parent_instr->type != nir_instr_type_alu)
return false;
return false;
for (int i = 1; i <= 2; i++) {
- if (!instr->src[i].src.is_ssa)
- continue;
-
nir_instr *parent = instr->src[i].src.ssa->parent_instr;
if (parent->type != nir_instr_type_ssa_undef)
continue;
return false;
}
- if (!intrin->src[arg_index].is_ssa)
- return false;
-
nir_ssa_def *def = intrin->src[arg_index].ssa;
unsigned write_mask = nir_intrinsic_write_mask(intrin);
unsigned src = q.src;
nir_alu_type use_type = q.use_type;
- if (!instr->src[src].src.is_ssa) {
- *result = pack_data((struct ssa_result_range){unknown, false, false, false});
- return;
- }
-
if (nir_src_is_const(instr->src[src].src)) {
*result = pack_data(analyze_constant(instr, src, use_type));
return;
{
assert(type != nir_type_invalid);
- if (!src.is_ssa)
- return false;
-
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_type output_type = nir_op_infos[src_alu->op].output_type;
return false;
nir_alu_instr *alu = nir_instr_as_alu(instr);
- if (!alu->dest.dest.is_ssa)
- return false;
unsigned bit_size = alu->dest.dest.ssa.bit_size;
const unsigned execution_mode =
validate_src_dominance(nir_src *src, void *_state)
{
validate_state *state = _state;
- if (!src->is_ssa)
- return true;
if (src->ssa->parent_instr->block == src->parent_instr->block) {
validate_assert(state, src->ssa->index < state->impl->ssa_alloc);
static inline nir_intrinsic_instr *
ir3_bindless_resource(nir_src src)
{
- if (!src.is_ssa)
- return NULL;
-
if (src.ssa->parent_instr->type != nir_instr_type_intrinsic)
return NULL;
if (alu->op != nir_op_vec2)
return -1;
- if (!alu->src[0].src.is_ssa)
- return -1;
-
int base_src_offset = coord_offset(alu->src[0].src.ssa);
if (base_src_offset < 0)
return -1;
/* NOTE it might be possible to support more than 2D? */
for (int i = 1; i < 2; i++) {
- if (!alu->src[i].src.is_ssa)
- return -1;
-
int nth_src_offset = coord_offset(alu->src[i].src.ssa);
if (nth_src_offset < 0)
return -1;
if (input->intrinsic != nir_intrinsic_load_interpolated_input)
return -1;
- /* limit to load_barycentric_pixel, other interpolation modes don't seem
- * to be supported:
- */
- if (!input->src[0].is_ssa)
- return -1;
-
nir_intrinsic_instr *interp =
nir_instr_as_intrinsic(input->src[0].ssa->parent_instr);
static const uint32_t
ntt_extract_const_src_offset(nir_src *src)
{
- if (!src->is_ssa)
- return 0;
-
nir_ssa_scalar s = nir_get_ssa_scalar(src->ssa, 0);
while (nir_ssa_scalar_is_alu(s)) {
nir_alu_instr *alu = nir_instr_as_alu(s.def->parent_instr);
- for (int i = 0; i < nir_op_infos[alu->op].num_inputs; i++) {
- if (!alu->src[i].src.is_ssa)
- return 0;
- }
-
if (alu->op == nir_op_iadd) {
for (int i = 0; i < 2; i++) {
nir_const_value *v = nir_src_as_const_value(alu->src[i].src);
static hw_src
get_src(struct etna_compile *c, nir_src *src)
{
- if (!src->is_ssa)
- return ra_src(c, src);
-
nir_instr *instr = src->ssa->parent_instr;
if (instr->pass_flags & BYPASS_SRC) {
unsigned dst_swiz;
hw_dst dst = ra_dest(c, &alu->dest.dest, &dst_swiz);
- /* compose alu write_mask with RA write mask */
- if (!alu->dest.dest.is_ssa)
- dst.write_mask = inst_write_mask_compose(alu->dest.write_mask, dst.write_mask);
-
switch (alu->op) {
case nir_op_fdot2:
case nir_op_fdot3:
nir_alu_instr *alu = nir_instr_as_alu(instr);
for (unsigned i = 0; i < nir_op_infos[alu->op].num_inputs; i++) {
- if (!alu->src[i].src.is_ssa)
- continue;
-
if (alu->src[i].src.ssa->parent_instr->type != nir_instr_type_alu)
continue;
if (itr->instr.pass_flags)
continue;
- if (!itr->dest.is_ssa)
- continue;
-
lima_nir_duplicate_intrinsic(&builder, itr, op);
}
}
if (alu->op != nir_op_mov)
return false;
- if (!alu->dest.dest.is_ssa)
- return false;
-
- if (!alu->src[0].src.is_ssa)
- return false;
-
nir_ssa_def *ssa = alu->src[0].src.ssa;
if (ssa->parent_instr->type != nir_instr_type_intrinsic)
return false;
static bool
replace_intrinsic(nir_builder *b, nir_intrinsic_instr *intrin)
{
- if (!intrin->dest.is_ssa)
- return false;
-
if (intrin->intrinsic != nir_intrinsic_load_input &&
intrin->intrinsic != nir_intrinsic_load_uniform)
return false;
- if (!intrin->src[0].is_ssa)
- return false;
-
if (intrin->src[0].ssa->parent_instr->type == nir_instr_type_load_const)
return false;
static bool
is_fs_input(const nir_src *src)
{
- if (!src->is_ssa) {
- return false;
- }
-
const nir_instr *parent = src->ssa[0].parent_instr;
if (!parent) {
return false;
unsigned *input_index,
int *input_component)
{
- if (!src->src.is_ssa) {
- return false;
- }
-
// The parent instr should be a nir_intrinsic_load_deref.
const nir_instr *parent = src->src.ssa[0].parent_instr;
if (!parent || parent->type != nir_instr_type_intrinsic) {
if (!offset)
return true;
- if (!offset->is_ssa)
- return false;
-
auto literal = nir_src_as_const_value(*offset);
if (!literal)
return false;
static bool
add_src_instr_to_worklist(nir_src *src, void *wl)
{
- if (!src->is_ssa)
- return false;
-
nir_instr_worklist_push_tail(wl, src->ssa->parent_instr);
return true;
}
static bool
add_src_instr(nir_src *src, void *state)
{
- if (!src->is_ssa)
- return true;
-
struct util_dynarray *inst_array = state;
util_dynarray_foreach(inst_array, nir_instr *, instr_ptr) {
if (*instr_ptr == src->ssa->parent_instr)
b->cursor = nir_before_instr(&intrin->instr);
- if (!intrin->src[source].is_ssa)
- return false;
-
util_dynarray_clear(inst_array);
nir_intrinsic_instr *old_resource_intel =
tex->src[s].src_type != nir_tex_src_sampler_handle)
continue;
- if (!tex->src[s].src.is_ssa)
- continue;
-
util_dynarray_clear(inst_array);
nir_intrinsic_instr *old_resource_intel =