#ifndef NDEBUG
/* Just in case someone uses short_path by accident */
for (unsigned i = 0; i < ARRAY_SIZE(path->_short_path); i++)
- path->_short_path[i] = (void *)0xdeadbeef;
+ path->_short_path[i] = (void *)(uintptr_t)0xdeadbeef;
#endif
path->path = ralloc_array(mem_ctx, nir_deref_instr *, count + 1);
for (nir_deref_instr *d = instr; d; d = nir_deref_instr_parent(d)) {
/* If anyone is using this deref, leave it alone */
assert(d->dest.is_ssa);
- if (!list_empty(&d->dest.ssa.uses))
+ if (!list_is_empty(&d->dest.ssa.uses))
break;
nir_instr_remove(&d->instr);
return false;
}
+bool
+nir_deref_instr_is_known_out_of_bounds(nir_deref_instr *instr)
+{
+ for (; instr; instr = nir_deref_instr_parent(instr)) {
+ if (instr->deref_type == nir_deref_type_array &&
+ nir_src_is_const(instr->arr.index) &&
+ nir_src_as_uint(instr->arr.index) >=
+ glsl_get_length(nir_deref_instr_parent(instr)->type))
+ return true;
+ }
+
+ return false;
+}
+
+bool
+nir_deref_instr_has_complex_use(nir_deref_instr *deref)
+{
+ nir_foreach_use(use_src, &deref->dest.ssa) {
+ nir_instr *use_instr = use_src->parent_instr;
+
+ switch (use_instr->type) {
+ case nir_instr_type_deref: {
+ nir_deref_instr *use_deref = nir_instr_as_deref(use_instr);
+
+ /* A var deref has no sources */
+ assert(use_deref->deref_type != nir_deref_type_var);
+
+ /* If a deref shows up in an array index or something like that, it's
+ * a complex use.
+ */
+ if (use_src != &use_deref->parent)
+ return true;
+
+ /* Anything that isn't a basic struct or array deref is considered to
+ * be a "complex" use. In particular, we don't allow ptr_as_array
+ * because we assume that opt_deref will turn any non-complex
+ * ptr_as_array derefs into regular array derefs eventually so passes
+ * which only want to handle simple derefs will pick them up in a
+ * later pass.
+ */
+ if (use_deref->deref_type != nir_deref_type_struct &&
+ use_deref->deref_type != nir_deref_type_array_wildcard &&
+ use_deref->deref_type != nir_deref_type_array)
+ return true;
+
+ if (nir_deref_instr_has_complex_use(use_deref))
+ return true;
+
+ continue;
+ }
+
+ case nir_instr_type_intrinsic: {
+ nir_intrinsic_instr *use_intrin = nir_instr_as_intrinsic(use_instr);
+ switch (use_intrin->intrinsic) {
+ case nir_intrinsic_load_deref:
+ assert(use_src == &use_intrin->src[0]);
+ continue;
+
+ case nir_intrinsic_copy_deref:
+ assert(use_src == &use_intrin->src[0] ||
+ use_src == &use_intrin->src[1]);
+ continue;
+
+ case nir_intrinsic_store_deref:
+ /* A use in src[1] of a store means we're taking that pointer and
+ * writing it to a variable. Because we have no idea who will
+ * read that variable and what they will do with the pointer, it's
+ * considered a "complex" use. A use in src[0], on the other
+ * hand, is a simple use because we're just going to dereference
+ * it and write a value there.
+ */
+ if (use_src == &use_intrin->src[0])
+ continue;
+ return true;
+
+ default:
+ return true;
+ }
+ unreachable("Switch default failed");
+ }
+
+ default:
+ return true;
+ }
+ }
+
+ nir_foreach_if_use(use, &deref->dest.ssa)
+ return true;
+
+ return false;
+}
+
unsigned
nir_deref_instr_ptr_as_array_stride(nir_deref_instr *deref)
{
- assert(deref->deref_type == nir_deref_type_ptr_as_array);
- nir_deref_instr *parent = nir_deref_instr_parent(deref);
- switch (parent->deref_type) {
+ switch (deref->deref_type) {
case nir_deref_type_array:
- return glsl_get_explicit_stride(nir_deref_instr_parent(parent)->type);
+ return glsl_get_explicit_stride(nir_deref_instr_parent(deref)->type);
case nir_deref_type_ptr_as_array:
- return nir_deref_instr_ptr_as_array_stride(parent);
+ return nir_deref_instr_ptr_as_array_stride(nir_deref_instr_parent(deref));
case nir_deref_type_cast:
- return parent->cast.ptr_stride;
+ return deref->cast.ptr_stride;
default:
- unreachable("Invalid parent for ptr_as_array deref");
+ return 0;
}
}
for (nir_deref_instr **p = &path.path[1]; *p; p++) {
if ((*p)->deref_type == nir_deref_type_array) {
nir_ssa_def *index = nir_ssa_for_src(b, (*p)->arr.index, 1);
- nir_ssa_def *stride =
- nir_imm_int(b, type_get_array_stride((*p)->type, size_align));
- offset = nir_iadd(b, offset, nir_imul(b, index, stride));
+ int stride = type_get_array_stride((*p)->type, size_align);
+ offset = nir_iadd(b, offset, nir_amul_imm(b, index, stride));
} else if ((*p)->deref_type == nir_deref_type_struct) {
/* p starts at path[1], so this is safe */
nir_deref_instr *parent = *(p - 1);
unsigned field_offset =
struct_type_get_field_offset(parent->type, size_align,
(*p)->strct.index);
- nir_iadd(b, offset, nir_imm_int(b, field_offset));
+ offset = nir_iadd_imm(b, offset, field_offset);
} else {
unreachable("Unsupported deref type");
}
{
assert(path->path[0]->deref_type == nir_deref_type_var);
- if (path->path[0]->var->data.image.access & ACCESS_COHERENT)
+ if (path->path[0]->var->data.access & ACCESS_COHERENT)
return true;
for (nir_deref_instr **p = &path->path[1]; *p; p++) {
* used. After this pass has been run, every use of a deref will be of a
* deref in the same block as the use. Also, all unused derefs will be
* deleted as a side-effect.
+ *
+ * Derefs used as sources of phi instructions are not rematerialized.
*/
bool
nir_rematerialize_derefs_in_use_blocks_impl(nir_function_impl *impl)
nir_deref_instr_remove_if_unused(nir_instr_as_deref(instr)))
continue;
+ /* If a deref is used in a phi, we can't rematerialize it, as the new
+ * derefs would appear before the phi, which is not valid.
+ */
+ if (instr->type == nir_instr_type_phi)
+ continue;
+
state.builder.cursor = nir_before_instr(instr);
nir_foreach_src(instr, rematerialize_deref_src, &state);
}
nir_instr_as_deref(instr)->deref_type == nir_deref_type_ptr_as_array;
}
+/**
+ * Remove casts that just wrap other casts.
+ */
static bool
-opt_deref_cast(nir_deref_instr *cast)
+opt_remove_cast_cast(nir_deref_instr *cast)
{
- if (!is_trivial_deref_cast(cast))
+ nir_deref_instr *first_cast = cast;
+
+ while (true) {
+ nir_deref_instr *parent = nir_deref_instr_parent(first_cast);
+ if (parent == NULL || parent->deref_type != nir_deref_type_cast)
+ break;
+ first_cast = parent;
+ }
+ if (cast == first_cast)
return false;
+ nir_instr_rewrite_src(&cast->instr, &cast->parent,
+ nir_src_for_ssa(first_cast->parent.ssa));
+ return true;
+}
+
+/**
+ * Is this casting a struct to a contained struct.
+ * struct a { struct b field0 };
+ * ssa_5 is structa;
+ * deref_cast (structb *)ssa_5 (function_temp structb);
+ * converts to
+ * deref_struct &ssa_5->field0 (function_temp structb);
+ * This allows subsequent copy propagation to work.
+ */
+static bool
+opt_replace_struct_wrapper_cast(nir_builder *b, nir_deref_instr *cast)
+{
+ nir_deref_instr *parent = nir_src_as_deref(cast->parent);
+ if (!parent)
+ return false;
+
+ if (!glsl_type_is_struct(parent->type))
+ return false;
+
+ if (glsl_get_struct_field_offset(parent->type, 0) != 0)
+ return false;
+
+ if (cast->type != glsl_get_struct_field(parent->type, 0))
+ return false;
+
+ nir_deref_instr *replace = nir_build_deref_struct(b, parent, 0);
+ nir_ssa_def_rewrite_uses(&cast->dest.ssa, nir_src_for_ssa(&replace->dest.ssa));
+ nir_deref_instr_remove_if_unused(cast);
+ return true;
+}
+
+static bool
+opt_deref_cast(nir_builder *b, nir_deref_instr *cast)
+{
+ bool progress;
+
+ if (opt_replace_struct_wrapper_cast(b, cast))
+ return true;
+
+ progress = opt_remove_cast_cast(cast);
+ if (!is_trivial_deref_cast(cast))
+ return progress;
+
bool trivial_array_cast = is_trivial_array_deref_cast(cast);
assert(cast->dest.is_ssa);
assert(cast->parent.is_ssa);
- bool progress = false;
nir_foreach_use_safe(use_src, &cast->dest.ssa) {
/* If this isn't a trivial array cast, we can't propagate into
* ptr_as_array derefs.
}
/* If uses would be a bit crazy */
- assert(list_empty(&cast->dest.ssa.if_uses));
+ assert(list_is_empty(&cast->dest.ssa.if_uses));
nir_deref_instr_remove_if_unused(cast);
return progress;
break;
case nir_deref_type_cast:
- if (opt_deref_cast(deref))
+ if (opt_deref_cast(&b, deref))
progress = true;
break;