[Mesa-dev] [PATCH v3 104/104] nir: Remove old-school deref chain support
Jason Ekstrand
jason at jlekstrand.net
Tue Apr 3 18:39:48 UTC 2018
---
src/compiler/nir/nir.c | 269 ---------------------------
src/compiler/nir/nir.h | 88 ---------
src/compiler/nir/nir_builder.h | 68 -------
src/compiler/nir/nir_clone.c | 78 --------
src/compiler/nir/nir_deref.c | 276 ----------------------------
src/compiler/nir/nir_instr_set.c | 23 +--
src/compiler/nir/nir_intrinsics.py | 83 +--------
src/compiler/nir/nir_intrinsics_c.py | 1 -
src/compiler/nir/nir_opt_constant_folding.c | 53 ------
src/compiler/nir/nir_opt_copy_propagate.c | 33 ----
src/compiler/nir/nir_print.c | 97 ----------
src/compiler/nir/nir_serialize.c | 97 ----------
src/compiler/nir/nir_validate.c | 107 -----------
13 files changed, 6 insertions(+), 1267 deletions(-)
diff --git a/src/compiler/nir/nir.c b/src/compiler/nir/nir.c
index be4d194..a827fe0 100644
--- a/src/compiler/nir/nir.c
+++ b/src/compiler/nir/nir.c
@@ -536,9 +536,7 @@ nir_tex_instr_create(nir_shader *shader, unsigned num_srcs)
instr->texture_index = 0;
instr->texture_array_size = 0;
- instr->texture = NULL;
instr->sampler_index = 0;
- instr->sampler = NULL;
return instr;
}
@@ -616,218 +614,6 @@ nir_ssa_undef_instr_create(nir_shader *shader,
return instr;
}
-nir_deref_var *
-nir_deref_var_create(void *mem_ctx, nir_variable *var)
-{
- nir_deref_var *deref = ralloc(mem_ctx, nir_deref_var);
- deref->deref.deref_type = nir_deref_type_var;
- deref->deref.child = NULL;
- deref->deref.type = var->type;
- deref->var = var;
- return deref;
-}
-
-nir_deref_array *
-nir_deref_array_create(void *mem_ctx)
-{
- nir_deref_array *deref = ralloc(mem_ctx, nir_deref_array);
- deref->deref.deref_type = nir_deref_type_array;
- deref->deref.child = NULL;
- deref->deref_array_type = nir_deref_array_type_direct;
- src_init(&deref->indirect);
- deref->base_offset = 0;
- return deref;
-}
-
-nir_deref_struct *
-nir_deref_struct_create(void *mem_ctx, unsigned field_index)
-{
- nir_deref_struct *deref = ralloc(mem_ctx, nir_deref_struct);
- deref->deref.deref_type = nir_deref_type_struct;
- deref->deref.child = NULL;
- deref->index = field_index;
- return deref;
-}
-
-nir_deref_var *
-nir_deref_var_clone(const nir_deref_var *deref, void *mem_ctx)
-{
- if (deref == NULL)
- return NULL;
-
- nir_deref_var *ret = nir_deref_var_create(mem_ctx, deref->var);
- ret->deref.type = deref->deref.type;
- if (deref->deref.child)
- ret->deref.child = nir_deref_clone(deref->deref.child, ret);
- return ret;
-}
-
-static nir_deref_array *
-deref_array_clone(const nir_deref_array *deref, void *mem_ctx)
-{
- nir_deref_array *ret = nir_deref_array_create(mem_ctx);
- ret->base_offset = deref->base_offset;
- ret->deref_array_type = deref->deref_array_type;
- if (deref->deref_array_type == nir_deref_array_type_indirect) {
- nir_src_copy(&ret->indirect, &deref->indirect, mem_ctx);
- }
- ret->deref.type = deref->deref.type;
- if (deref->deref.child)
- ret->deref.child = nir_deref_clone(deref->deref.child, ret);
- return ret;
-}
-
-static nir_deref_struct *
-deref_struct_clone(const nir_deref_struct *deref, void *mem_ctx)
-{
- nir_deref_struct *ret = nir_deref_struct_create(mem_ctx, deref->index);
- ret->deref.type = deref->deref.type;
- if (deref->deref.child)
- ret->deref.child = nir_deref_clone(deref->deref.child, ret);
- return ret;
-}
-
-nir_deref *
-nir_deref_clone(const nir_deref *deref, void *mem_ctx)
-{
- if (deref == NULL)
- return NULL;
-
- switch (deref->deref_type) {
- case nir_deref_type_var:
- return &nir_deref_var_clone(nir_deref_as_var(deref), mem_ctx)->deref;
- case nir_deref_type_array:
- return &deref_array_clone(nir_deref_as_array(deref), mem_ctx)->deref;
- case nir_deref_type_struct:
- return &deref_struct_clone(nir_deref_as_struct(deref), mem_ctx)->deref;
- default:
- unreachable("Invalid dereference type");
- }
-
- return NULL;
-}
-
-/* This is the second step in the recursion. We've found the tail and made a
- * copy. Now we need to iterate over all possible leaves and call the
- * callback on each one.
- */
-static bool
-deref_foreach_leaf_build_recur(nir_deref_var *deref, nir_deref *tail,
- nir_deref_foreach_leaf_cb cb, void *state)
-{
- unsigned length;
- union {
- nir_deref_array arr;
- nir_deref_struct str;
- } tmp;
-
- assert(tail->child == NULL);
- switch (glsl_get_base_type(tail->type)) {
- case GLSL_TYPE_UINT:
- case GLSL_TYPE_UINT16:
- case GLSL_TYPE_UINT64:
- case GLSL_TYPE_INT:
- case GLSL_TYPE_INT16:
- case GLSL_TYPE_INT64:
- case GLSL_TYPE_FLOAT:
- case GLSL_TYPE_FLOAT16:
- case GLSL_TYPE_DOUBLE:
- case GLSL_TYPE_BOOL:
- if (glsl_type_is_vector_or_scalar(tail->type))
- return cb(deref, state);
- /* Fall Through */
-
- case GLSL_TYPE_ARRAY:
- tmp.arr.deref.deref_type = nir_deref_type_array;
- tmp.arr.deref.type = glsl_get_array_element(tail->type);
- tmp.arr.deref_array_type = nir_deref_array_type_direct;
- tmp.arr.indirect = NIR_SRC_INIT;
- tail->child = &tmp.arr.deref;
-
- length = glsl_get_length(tail->type);
- for (unsigned i = 0; i < length; i++) {
- tmp.arr.deref.child = NULL;
- tmp.arr.base_offset = i;
- if (!deref_foreach_leaf_build_recur(deref, &tmp.arr.deref, cb, state))
- return false;
- }
- return true;
-
- case GLSL_TYPE_STRUCT:
- tmp.str.deref.deref_type = nir_deref_type_struct;
- tail->child = &tmp.str.deref;
-
- length = glsl_get_length(tail->type);
- for (unsigned i = 0; i < length; i++) {
- tmp.arr.deref.child = NULL;
- tmp.str.deref.type = glsl_get_struct_field(tail->type, i);
- tmp.str.index = i;
- if (!deref_foreach_leaf_build_recur(deref, &tmp.arr.deref, cb, state))
- return false;
- }
- return true;
-
- default:
- unreachable("Invalid type for dereference");
- }
-}
-
-/* This is the first step of the foreach_leaf recursion. In this step we are
- * walking to the end of the deref chain and making a copy in the stack as we
- * go. This is because we don't want to mutate the deref chain that was
- * passed in by the caller. The downside is that this deref chain is on the
- * stack and , if the caller wants to do anything with it, they will have to
- * make their own copy because this one will go away.
- */
-static bool
-deref_foreach_leaf_copy_recur(nir_deref_var *deref, nir_deref *tail,
- nir_deref_foreach_leaf_cb cb, void *state)
-{
- union {
- nir_deref_array arr;
- nir_deref_struct str;
- } c;
-
- if (tail->child) {
- switch (tail->child->deref_type) {
- case nir_deref_type_array:
- c.arr = *nir_deref_as_array(tail->child);
- tail->child = &c.arr.deref;
- return deref_foreach_leaf_copy_recur(deref, &c.arr.deref, cb, state);
-
- case nir_deref_type_struct:
- c.str = *nir_deref_as_struct(tail->child);
- tail->child = &c.str.deref;
- return deref_foreach_leaf_copy_recur(deref, &c.str.deref, cb, state);
-
- case nir_deref_type_var:
- default:
- unreachable("Invalid deref type for a child");
- }
- } else {
- /* We've gotten to the end of the original deref. Time to start
- * building our own derefs.
- */
- return deref_foreach_leaf_build_recur(deref, tail, cb, state);
- }
-}
-
-/**
- * This function iterates over all of the possible derefs that can be created
- * with the given deref as the head. It then calls the provided callback with
- * a full deref for each one.
- *
- * The deref passed to the callback will be allocated on the stack. You will
- * need to make a copy if you want it to hang around.
- */
-bool
-nir_deref_foreach_leaf(nir_deref_var *deref,
- nir_deref_foreach_leaf_cb cb, void *state)
-{
- nir_deref_var copy = *deref;
- return deref_foreach_leaf_copy_recur(©, ©.deref, cb, state);
-}
-
static nir_const_value
const_value_float(double d, unsigned bit_size)
{
@@ -1256,31 +1042,6 @@ visit_src(nir_src *src, nir_foreach_src_cb cb, void *state)
}
static bool
-visit_deref_array_src(nir_deref_array *deref, nir_foreach_src_cb cb,
- void *state)
-{
- if (deref->deref_array_type == nir_deref_array_type_indirect)
- return visit_src(&deref->indirect, cb, state);
- return true;
-}
-
-static bool
-visit_deref_src(nir_deref_var *deref, nir_foreach_src_cb cb, void *state)
-{
- nir_deref *cur = &deref->deref;
- while (cur != NULL) {
- if (cur->deref_type == nir_deref_type_array) {
- if (!visit_deref_array_src(nir_deref_as_array(cur), cb, state))
- return false;
- }
-
- cur = cur->child;
- }
-
- return true;
-}
-
-static bool
visit_alu_src(nir_alu_instr *instr, nir_foreach_src_cb cb, void *state)
{
for (unsigned i = 0; i < nir_op_infos[instr->op].num_inputs; i++)
@@ -1315,16 +1076,6 @@ visit_tex_src(nir_tex_instr *instr, nir_foreach_src_cb cb, void *state)
return false;
}
- if (instr->texture != NULL) {
- if (!visit_deref_src(instr->texture, cb, state))
- return false;
- }
-
- if (instr->sampler != NULL) {
- if (!visit_deref_src(instr->sampler, cb, state))
- return false;
- }
-
return true;
}
@@ -1338,13 +1089,6 @@ visit_intrinsic_src(nir_intrinsic_instr *instr, nir_foreach_src_cb cb,
return false;
}
- unsigned num_vars =
- nir_intrinsic_infos[instr->intrinsic].num_variables;
- for (unsigned i = 0; i < num_vars; i++) {
- if (!visit_deref_src(instr->variables[i], cb, state))
- return false;
- }
-
return true;
}
@@ -1584,19 +1328,6 @@ nir_instr_rewrite_dest(nir_instr *instr, nir_dest *dest, nir_dest new_dest)
src_add_all_uses(dest->reg.indirect, instr, NULL);
}
-void
-nir_instr_rewrite_deref(nir_instr *instr, nir_deref_var **deref,
- nir_deref_var *new_deref)
-{
- if (*deref)
- visit_deref_src(*deref, remove_use_cb, NULL);
-
- *deref = new_deref;
-
- if (*deref)
- visit_deref_src(*deref, add_use_cb, instr);
-}
-
/* note: does *not* take ownership of 'name' */
void
nir_ssa_def_init(nir_instr *instr, nir_ssa_def *def,
diff --git a/src/compiler/nir/nir.h b/src/compiler/nir/nir.h
index 060d673..7cd222d 100644
--- a/src/compiler/nir/nir.h
+++ b/src/compiler/nir/nir.h
@@ -911,62 +911,6 @@ typedef enum {
nir_deref_type_cast,
} nir_deref_type;
-typedef struct nir_deref {
- nir_deref_type deref_type;
- struct nir_deref *child;
- const struct glsl_type *type;
-} nir_deref;
-
-typedef struct {
- nir_deref deref;
-
- nir_variable *var;
-} nir_deref_var;
-
-/* This enum describes how the array is referenced. If the deref is
- * direct then the base_offset is used. If the deref is indirect then
- * offset is given by base_offset + indirect. If the deref is a wildcard
- * then the deref refers to all of the elements of the array at the same
- * time. Wildcard dereferences are only ever allowed in copy_var
- * intrinsics and the source and destination derefs must have matching
- * wildcards.
- */
-typedef enum {
- nir_deref_array_type_direct,
- nir_deref_array_type_indirect,
- nir_deref_array_type_wildcard,
-} nir_deref_array_type;
-
-typedef struct {
- nir_deref deref;
-
- nir_deref_array_type deref_array_type;
- unsigned base_offset;
- nir_src indirect;
-} nir_deref_array;
-
-typedef struct {
- nir_deref deref;
-
- unsigned index;
-} nir_deref_struct;
-
-NIR_DEFINE_CAST(nir_deref_as_var, nir_deref, nir_deref_var, deref,
- deref_type, nir_deref_type_var)
-NIR_DEFINE_CAST(nir_deref_as_array, nir_deref, nir_deref_array, deref,
- deref_type, nir_deref_type_array)
-NIR_DEFINE_CAST(nir_deref_as_struct, nir_deref, nir_deref_struct, deref,
- deref_type, nir_deref_type_struct)
-
-/* Returns the last deref in the chain. */
-static inline nir_deref *
-nir_deref_tail(nir_deref *deref)
-{
- while (deref->child)
- deref = deref->child;
- return deref;
-}
-
typedef struct {
nir_instr instr;
@@ -1037,9 +981,6 @@ nir_deref_instr_get_variable(const nir_deref_instr *instr)
void nir_deref_instr_cleanup(nir_deref_instr *instr);
-nir_deref_var *
-nir_deref_instr_to_deref(nir_deref_instr *instr, void *mem_ctx);
-
typedef struct {
nir_instr instr;
@@ -1098,8 +1039,6 @@ typedef struct {
int const_index[NIR_INTRINSIC_MAX_CONST_INDEX];
- nir_deref_var *variables[2];
-
nir_src src[];
} nir_intrinsic_instr;
@@ -1222,9 +1161,6 @@ typedef struct {
*/
unsigned dest_components;
- /** the number of inputs/outputs that are variables */
- unsigned num_variables;
-
/** the number of constant indices used by the intrinsic */
unsigned num_indices;
@@ -1347,12 +1283,6 @@ typedef struct {
/** The size of the texture array or 0 if it's not an array */
unsigned texture_array_size;
- /** The texture deref
- *
- * If this is null, use texture_index instead.
- */
- nir_deref_var *texture;
-
/** The sampler index
*
* The following operations do not require a sampler and, as such, this
@@ -1369,12 +1299,6 @@ typedef struct {
* then the sampler index is given by sampler_index + sampler_offset.
*/
unsigned sampler_index;
-
- /** The sampler deref
- *
- * If this is null, use sampler_index instead.
- */
- nir_deref_var *sampler;
} nir_tex_instr;
static inline unsigned
@@ -2148,14 +2072,6 @@ nir_ssa_undef_instr *nir_ssa_undef_instr_create(nir_shader *shader,
unsigned num_components,
unsigned bit_size);
-nir_deref_var *nir_deref_var_create(void *mem_ctx, nir_variable *var);
-nir_deref_array *nir_deref_array_create(void *mem_ctx);
-nir_deref_struct *nir_deref_struct_create(void *mem_ctx, unsigned field_index);
-
-typedef bool (*nir_deref_foreach_leaf_cb)(nir_deref_var *deref, void *state);
-bool nir_deref_foreach_leaf(nir_deref_var *deref,
- nir_deref_foreach_leaf_cb cb, void *state);
-
nir_const_value nir_alu_binop_identity(nir_op binop, unsigned bit_size);
/**
@@ -2387,8 +2303,6 @@ void nir_instr_move_src(nir_instr *dest_instr, nir_src *dest, nir_src *src);
void nir_if_rewrite_condition(nir_if *if_stmt, nir_src new_src);
void nir_instr_rewrite_dest(nir_instr *instr, nir_dest *dest,
nir_dest new_dest);
-void nir_instr_rewrite_deref(nir_instr *instr, nir_deref_var **deref,
- nir_deref_var *new_deref);
void nir_ssa_dest_init(nir_instr *instr, nir_dest *dest,
unsigned num_components, unsigned bit_size,
@@ -2483,8 +2397,6 @@ nir_shader *nir_shader_clone(void *mem_ctx, const nir_shader *s);
nir_function_impl *nir_function_impl_clone(const nir_function_impl *fi);
nir_constant *nir_constant_clone(const nir_constant *c, nir_variable *var);
nir_variable *nir_variable_clone(const nir_variable *c, nir_shader *shader);
-nir_deref *nir_deref_clone(const nir_deref *deref, void *mem_ctx);
-nir_deref_var *nir_deref_var_clone(const nir_deref_var *deref, void *mem_ctx);
nir_shader *nir_shader_serialize_deserialize(void *mem_ctx, nir_shader *s);
diff --git a/src/compiler/nir/nir_builder.h b/src/compiler/nir/nir_builder.h
index b3710a2..8eddd8c 100644
--- a/src/compiler/nir/nir_builder.h
+++ b/src/compiler/nir/nir_builder.h
@@ -637,29 +637,6 @@ nir_build_deref_cast(nir_builder *build, nir_ssa_def *parent,
return deref;
}
-static inline nir_deref_instr *
-nir_build_deref_for_chain(nir_builder *b, nir_deref_var *deref_var)
-{
- nir_deref_instr *tail = nir_build_deref_var(b, deref_var->var);
- for (nir_deref *d = deref_var->deref.child; d; d = d->child) {
- if (d->deref_type == nir_deref_type_array) {
- nir_deref_array *a = nir_deref_as_array(d);
- assert(a->deref_array_type != nir_deref_array_type_wildcard);
-
- nir_ssa_def *index = nir_imm_int(b, a->base_offset);
- if (a->deref_array_type == nir_deref_array_type_indirect)
- index = nir_iadd(b, index, nir_ssa_for_src(b, a->indirect, 1));
-
- tail = nir_build_deref_array(b, tail, index);
- } else {
- nir_deref_struct *s = nir_deref_as_struct(d);
- tail = nir_build_deref_struct(b, tail, s->index);
- }
- }
-
- return tail;
-}
-
/** Returns a deref that follows another but starting from the given parent
*
* The new deref will be the same type and take the same array or struct index
@@ -751,22 +728,6 @@ nir_load_var(nir_builder *build, nir_variable *var)
return nir_load_deref(build, nir_build_deref_var(build, var));
}
-static inline nir_ssa_def *
-nir_load_deref_var(nir_builder *build, nir_deref_var *deref)
-{
- const struct glsl_type *type = nir_deref_tail(&deref->deref)->type;
- const unsigned num_components = glsl_get_vector_elements(type);
-
- nir_intrinsic_instr *load =
- nir_intrinsic_instr_create(build->shader, nir_intrinsic_load_var);
- load->num_components = num_components;
- load->variables[0] = nir_deref_var_clone(deref, load);
- nir_ssa_dest_init(&load->instr, &load->dest, num_components,
- glsl_get_bit_size(type), NULL);
- nir_builder_instr_insert(build, &load->instr);
- return &load->dest.ssa;
-}
-
static inline void
nir_store_var(nir_builder *build, nir_variable *var, nir_ssa_def *value,
unsigned writemask)
@@ -775,35 +736,6 @@ nir_store_var(nir_builder *build, nir_variable *var, nir_ssa_def *value,
}
static inline void
-nir_store_deref_var(nir_builder *build, nir_deref_var *deref,
- nir_ssa_def *value, unsigned writemask)
-{
- const unsigned num_components =
- glsl_get_vector_elements(nir_deref_tail(&deref->deref)->type);
-
- nir_intrinsic_instr *store =
- nir_intrinsic_instr_create(build->shader, nir_intrinsic_store_var);
- store->num_components = num_components;
- store->const_index[0] = writemask & ((1 << num_components) - 1);
- store->variables[0] = nir_deref_var_clone(deref, store);
- store->src[0] = nir_src_for_ssa(value);
- nir_builder_instr_insert(build, &store->instr);
-}
-
-static inline void
-nir_copy_deref_var(nir_builder *build, nir_deref_var *dest, nir_deref_var *src)
-{
- assert(nir_deref_tail(&dest->deref)->type ==
- nir_deref_tail(&src->deref)->type);
-
- nir_intrinsic_instr *copy =
- nir_intrinsic_instr_create(build->shader, nir_intrinsic_copy_var);
- copy->variables[0] = nir_deref_var_clone(dest, copy);
- copy->variables[1] = nir_deref_var_clone(src, copy);
- nir_builder_instr_insert(build, ©->instr);
-}
-
-static inline void
nir_copy_var(nir_builder *build, nir_variable *dest, nir_variable *src)
{
nir_copy_deref(build, nir_build_deref_var(build, dest),
diff --git a/src/compiler/nir/nir_clone.c b/src/compiler/nir/nir_clone.c
index 93ce2fd..23bb17e 100644
--- a/src/compiler/nir/nir_clone.c
+++ b/src/compiler/nir/nir_clone.c
@@ -266,73 +266,6 @@ __clone_dst(clone_state *state, nir_instr *ninstr,
}
}
-static nir_deref *clone_deref(clone_state *state, const nir_deref *deref,
- nir_instr *ninstr, nir_deref *parent);
-
-static nir_deref_var *
-clone_deref_var(clone_state *state, const nir_deref_var *dvar,
- nir_instr *ninstr)
-{
- nir_variable *nvar = remap_var(state, dvar->var);
- nir_deref_var *ndvar = nir_deref_var_create(ninstr, nvar);
-
- if (dvar->deref.child)
- ndvar->deref.child = clone_deref(state, dvar->deref.child,
- ninstr, &ndvar->deref);
-
- return ndvar;
-}
-
-static nir_deref_array *
-clone_deref_array(clone_state *state, const nir_deref_array *darr,
- nir_instr *ninstr, nir_deref *parent)
-{
- nir_deref_array *ndarr = nir_deref_array_create(parent);
-
- ndarr->deref.type = darr->deref.type;
- if (darr->deref.child)
- ndarr->deref.child = clone_deref(state, darr->deref.child,
- ninstr, &ndarr->deref);
-
- ndarr->deref_array_type = darr->deref_array_type;
- ndarr->base_offset = darr->base_offset;
- if (ndarr->deref_array_type == nir_deref_array_type_indirect)
- __clone_src(state, ninstr, &ndarr->indirect, &darr->indirect);
-
- return ndarr;
-}
-
-static nir_deref_struct *
-clone_deref_struct(clone_state *state, const nir_deref_struct *dstr,
- nir_instr *ninstr, nir_deref *parent)
-{
- nir_deref_struct *ndstr = nir_deref_struct_create(parent, dstr->index);
-
- ndstr->deref.type = dstr->deref.type;
- if (dstr->deref.child)
- ndstr->deref.child = clone_deref(state, dstr->deref.child,
- ninstr, &ndstr->deref);
-
- return ndstr;
-}
-
-static nir_deref *
-clone_deref(clone_state *state, const nir_deref *dref,
- nir_instr *ninstr, nir_deref *parent)
-{
- switch (dref->deref_type) {
- case nir_deref_type_array:
- return &clone_deref_array(state, nir_deref_as_array(dref),
- ninstr, parent)->deref;
- case nir_deref_type_struct:
- return &clone_deref_struct(state, nir_deref_as_struct(dref),
- ninstr, parent)->deref;
- default:
- unreachable("bad deref type");
- return NULL;
- }
-}
-
static nir_alu_instr *
clone_alu(clone_state *state, const nir_alu_instr *alu)
{
@@ -400,7 +333,6 @@ clone_intrinsic(clone_state *state, const nir_intrinsic_instr *itr)
nir_intrinsic_instr *nitr =
nir_intrinsic_instr_create(state->ns, itr->intrinsic);
- unsigned num_variables = nir_intrinsic_infos[itr->intrinsic].num_variables;
unsigned num_srcs = nir_intrinsic_infos[itr->intrinsic].num_srcs;
if (nir_intrinsic_infos[itr->intrinsic].has_dest)
@@ -409,11 +341,6 @@ clone_intrinsic(clone_state *state, const nir_intrinsic_instr *itr)
nitr->num_components = itr->num_components;
memcpy(nitr->const_index, itr->const_index, sizeof(nitr->const_index));
- for (unsigned i = 0; i < num_variables; i++) {
- nitr->variables[i] = clone_deref_var(state, itr->variables[i],
- &nitr->instr);
- }
-
for (unsigned i = 0; i < num_srcs; i++)
__clone_src(state, &nitr->instr, &nitr->src[i], &itr->src[i]);
@@ -466,13 +393,8 @@ clone_tex(clone_state *state, const nir_tex_instr *tex)
ntex->component = tex->component;
ntex->texture_index = tex->texture_index;
- if (tex->texture)
- ntex->texture = clone_deref_var(state, tex->texture, &ntex->instr);
ntex->texture_array_size = tex->texture_array_size;
-
ntex->sampler_index = tex->sampler_index;
- if (tex->sampler)
- ntex->sampler = clone_deref_var(state, tex->sampler, &ntex->instr);
return ntex;
}
diff --git a/src/compiler/nir/nir_deref.c b/src/compiler/nir/nir_deref.c
index 5add79c..b8fb448 100644
--- a/src/compiler/nir/nir_deref.c
+++ b/src/compiler/nir/nir_deref.c
@@ -86,282 +86,6 @@ nir_deref_instr_cleanup(nir_deref_instr *instr)
}
}
-nir_deref_var *
-nir_deref_instr_to_deref(nir_deref_instr *instr, void *mem_ctx)
-{
- nir_deref *deref = NULL;
-
- while (instr->deref_type != nir_deref_type_var) {
- nir_deref *nderef;
- switch (instr->deref_type) {
- case nir_deref_type_array:
- case nir_deref_type_array_wildcard: {
- nir_deref_array *deref_arr = nir_deref_array_create(mem_ctx);
- if (instr->deref_type == nir_deref_type_array) {
- nir_const_value *const_index =
- nir_src_as_const_value(instr->arr.index);
- if (const_index) {
- deref_arr->deref_array_type = nir_deref_array_type_direct;
- deref_arr->base_offset = const_index->u32[0];
- } else {
- deref_arr->deref_array_type = nir_deref_array_type_indirect;
- deref_arr->base_offset = 0;
- nir_src_copy(&deref_arr->indirect, &instr->arr.index, mem_ctx);
- }
- } else {
- deref_arr->deref_array_type = nir_deref_array_type_wildcard;
- }
- nderef = &deref_arr->deref;
- break;
- }
-
- case nir_deref_type_struct:
- nderef = &nir_deref_struct_create(mem_ctx, instr->strct.index)->deref;
- break;
-
- default:
- unreachable("Invalid deref instruction type");
- }
-
- nderef->child = deref;
- ralloc_steal(nderef, deref);
- nderef->type = instr->type;
-
- deref = nderef;
- assert(instr->parent.is_ssa);
- instr = nir_src_as_deref(instr->parent);
- }
-
- assert(instr->deref_type == nir_deref_type_var);
- nir_deref_var *deref_var = nir_deref_var_create(mem_ctx, instr->var);
- deref_var->deref.child = deref;
- ralloc_steal(deref_var, deref);
-
- return deref_var;
-}
-
-static nir_deref_var *
-nir_deref_src_to_deref(nir_src src, void *mem_ctx)
-{
- return nir_deref_instr_to_deref(nir_src_as_deref(src), mem_ctx);
-}
-
-static bool
-nir_lower_deref_instrs_tex(nir_tex_instr *tex)
-{
- bool progress = false;
-
- /* Remove the instruction before we modify it. This way we won't mess up
- * use-def chains when we move sources around.
- */
- nir_cursor cursor = nir_instr_remove(&tex->instr);
-
- unsigned new_num_srcs = 0;
- for (unsigned i = 0; i < tex->num_srcs; i++) {
- if (tex->src[i].src_type == nir_tex_src_texture_deref) {
- tex->texture = nir_deref_src_to_deref(tex->src[i].src, tex);
- progress = true;
- continue;
- } else if (tex->src[i].src_type == nir_tex_src_sampler_deref) {
- tex->sampler = nir_deref_src_to_deref(tex->src[i].src, tex);
- progress = true;
- continue;
- }
-
- /* Compact the sources down to remove the deref sources */
- assert(new_num_srcs <= i);
- tex->src[new_num_srcs++] = tex->src[i];
- }
- tex->num_srcs = new_num_srcs;
-
- nir_instr_insert(cursor, &tex->instr);
-
- return progress;
-}
-
-static bool
-nir_lower_deref_instrs_intrin(nir_intrinsic_instr *intrin,
- enum nir_lower_deref_flags flags)
-{
- nir_intrinsic_op deref_op = intrin->intrinsic;
- nir_intrinsic_op var_op;
-
- switch (deref_op) {
-#define CASE(a) \
- case nir_intrinsic_##a##_deref: \
- if (!(flags & nir_lower_load_store_derefs)) \
- return false; \
- var_op = nir_intrinsic_##a##_var; \
- break;
- CASE(load)
- CASE(store)
- CASE(copy)
-#undef CASE
-
-#define CASE(a) \
- case nir_intrinsic_interp_deref_##a: \
- if (!(flags & nir_lower_interp_derefs)) \
- return false; \
- var_op = nir_intrinsic_interp_var_##a; \
- break;
- CASE(at_centroid)
- CASE(at_sample)
- CASE(at_offset)
-#undef CASE
-
-#define CASE(a) \
- case nir_intrinsic_atomic_counter_##a##_deref: \
- if (!(flags & nir_lower_atomic_counter_derefs)) \
- return false; \
- var_op = nir_intrinsic_atomic_counter_##a##_var; \
- break;
- CASE(inc)
- CASE(dec)
- CASE(read)
- CASE(add)
- CASE(min)
- CASE(max)
- CASE(and)
- CASE(or)
- CASE(xor)
- CASE(exchange)
- CASE(comp_swap)
-#undef CASE
-
-#define CASE(a) \
- case nir_intrinsic_deref_atomic_##a: \
- if (!(flags & nir_lower_atomic_derefs)) \
- return false; \
- var_op = nir_intrinsic_var_atomic_##a; \
- break;
- CASE(add)
- CASE(imin)
- CASE(umin)
- CASE(imax)
- CASE(umax)
- CASE(and)
- CASE(or)
- CASE(xor)
- CASE(exchange)
- CASE(comp_swap)
-#undef CASE
-
-#define CASE(a) \
- case nir_intrinsic_image_deref_##a: \
- if (!(flags & nir_lower_image_derefs)) \
- return false; \
- var_op = nir_intrinsic_image_var_##a; \
- break;
- CASE(load)
- CASE(store)
- CASE(atomic_add)
- CASE(atomic_min)
- CASE(atomic_max)
- CASE(atomic_and)
- CASE(atomic_or)
- CASE(atomic_xor)
- CASE(atomic_exchange)
- CASE(atomic_comp_swap)
- CASE(size)
- CASE(samples)
-#undef CASE
-
- default:
- return false;
- }
-
- /* Remove the instruction before we modify it. This way we won't mess up
- * use-def chains when we move sources around.
- */
- nir_cursor cursor = nir_instr_remove(&intrin->instr);
-
- unsigned num_derefs = nir_intrinsic_infos[var_op].num_variables;
- assert(nir_intrinsic_infos[var_op].num_srcs + num_derefs ==
- nir_intrinsic_infos[deref_op].num_srcs);
-
- /* Move deref sources to variables */
- for (unsigned i = 0; i < num_derefs; i++)
- intrin->variables[i] = nir_deref_src_to_deref(intrin->src[i], intrin);
-
- /* Shift all the other sources down */
- for (unsigned i = 0; i < nir_intrinsic_infos[var_op].num_srcs; i++)
- nir_src_copy(&intrin->src[i], &intrin->src[i + num_derefs], intrin);
-
- /* Rewrite the extra sources to NIR_SRC_INIT just in case */
- for (unsigned i = 0; i < num_derefs; i++)
- intrin->src[nir_intrinsic_infos[var_op].num_srcs + i] = NIR_SRC_INIT;
-
- /* It's safe to just stomp the intrinsic to var intrinsic since every
- * intrinsic has room for some variables and the number of sources only
- * shrinks.
- */
- intrin->intrinsic = var_op;
-
- nir_instr_insert(cursor, &intrin->instr);
-
- return true;
-}
-
-static bool
-nir_lower_deref_instrs_impl(nir_function_impl *impl,
- enum nir_lower_deref_flags flags)
-{
- bool progress = false;
-
- /* Walk the instructions in reverse order so that we can safely clean up
- * the deref instructions after we clean up their uses.
- */
- nir_foreach_block_reverse(block, impl) {
- nir_foreach_instr_reverse_safe(instr, block) {
- switch (instr->type) {
- case nir_instr_type_deref:
- if (list_empty(&nir_instr_as_deref(instr)->dest.ssa.uses)) {
- nir_instr_remove(instr);
- progress = true;
- }
- break;
-
- case nir_instr_type_tex:
- if (flags & nir_lower_texture_derefs)
- progress |= nir_lower_deref_instrs_tex(nir_instr_as_tex(instr));
- break;
-
- case nir_instr_type_intrinsic:
- progress |=
- nir_lower_deref_instrs_intrin(nir_instr_as_intrinsic(instr),
- flags);
- break;
-
- default:
- break; /* Nothing to do */
- }
- }
- }
-
- if (progress) {
- nir_metadata_preserve(impl, nir_metadata_block_index |
- nir_metadata_dominance);
- }
-
- return progress;
-}
-
-bool
-nir_lower_deref_instrs(nir_shader *shader,
- enum nir_lower_deref_flags flags)
-{
- bool progress = false;
-
- nir_foreach_function(function, shader) {
- if (!function->impl)
- continue;
-
- progress |= nir_lower_deref_instrs_impl(function->impl, flags);
- }
-
- return progress;
-}
-
void
nir_fixup_deref_modes(nir_shader *shader)
{
diff --git a/src/compiler/nir/nir_instr_set.c b/src/compiler/nir/nir_instr_set.c
index 939ddcc..42aa618 100644
--- a/src/compiler/nir/nir_instr_set.c
+++ b/src/compiler/nir/nir_instr_set.c
@@ -165,8 +165,6 @@ hash_intrinsic(uint32_t hash, const nir_intrinsic_instr *instr)
hash = HASH(hash, instr->dest.ssa.bit_size);
}
- assert(info->num_variables == 0);
-
hash = _mesa_fnv32_1a_accumulate_block(hash, instr->const_index,
info->num_indices
* sizeof(instr->const_index[0]));
@@ -195,8 +193,6 @@ hash_tex(uint32_t hash, const nir_tex_instr *instr)
hash = HASH(hash, instr->texture_array_size);
hash = HASH(hash, instr->sampler_index);
- assert(!instr->texture && !instr->sampler);
-
return hash;
}
@@ -391,10 +387,6 @@ nir_instrs_equal(const nir_instr *instr1, const nir_instr *instr2)
return false;
}
- /* Don't support un-lowered sampler derefs currently. */
- assert(!tex1->texture && !tex1->sampler &&
- !tex2->texture && !tex2->sampler);
-
return true;
}
case nir_instr_type_load_const: {
@@ -453,8 +445,6 @@ nir_instrs_equal(const nir_instr *instr1, const nir_instr *instr2)
return false;
}
- assert(info->num_variables == 0);
-
for (unsigned i = 0; i < info->num_indices; i++) {
if (intrinsic1->const_index[i] != intrinsic2->const_index[i])
return false;
@@ -505,24 +495,15 @@ instr_can_rewrite(nir_instr *instr)
switch (instr->type) {
case nir_instr_type_alu:
case nir_instr_type_deref:
+ case nir_instr_type_tex:
case nir_instr_type_load_const:
case nir_instr_type_phi:
return true;
- case nir_instr_type_tex: {
- nir_tex_instr *tex = nir_instr_as_tex(instr);
-
- /* Don't support un-lowered sampler derefs currently. */
- if (tex->texture || tex->sampler)
- return false;
-
- return true;
- }
case nir_instr_type_intrinsic: {
const nir_intrinsic_info *info =
&nir_intrinsic_infos[nir_instr_as_intrinsic(instr)->intrinsic];
return (info->flags & NIR_INTRINSIC_CAN_ELIMINATE) &&
- (info->flags & NIR_INTRINSIC_CAN_REORDER) &&
- info->num_variables == 0; /* not implemented yet */
+ (info->flags & NIR_INTRINSIC_CAN_REORDER);
}
case nir_instr_type_call:
case nir_instr_type_jump:
diff --git a/src/compiler/nir/nir_intrinsics.py b/src/compiler/nir/nir_intrinsics.py
index 2cd7798..e6ec325 100644
--- a/src/compiler/nir/nir_intrinsics.py
+++ b/src/compiler/nir/nir_intrinsics.py
@@ -31,7 +31,7 @@ class Intrinsic(object):
"""Class that represents all the information about an intrinsic opcode.
NOTE: this must be kept in sync with nir_intrinsic_info.
"""
- def __init__(self, name, src_components, dest_components, num_variables,
+ def __init__(self, name, src_components, dest_components,
indices, flags, sysval):
"""Parameters:
@@ -42,7 +42,6 @@ class Intrinsic(object):
- dest_components: number of destination components, -1 means no
dest, 0 means number of components given in num_components field
in nir_intrinsic_instr.
- - num_variables: the number of variables
- indices: list of constant indicies
- flags: list of semantic flags
- sysval: is this a system-value intrinsic
@@ -52,7 +51,6 @@ class Intrinsic(object):
if src_components:
assert isinstance(src_components[0], int)
assert isinstance(dest_components, int)
- assert isinstance(num_variables, int)
assert isinstance(indices, list)
if indices:
assert isinstance(indices[0], str)
@@ -66,7 +64,6 @@ class Intrinsic(object):
self.src_components = src_components
self.has_dest = (dest_components >= 0)
self.dest_components = dest_components
- self.num_variables = num_variables
self.num_indices = len(indices)
self.indices = indices
self.flags = flags
@@ -114,37 +111,20 @@ CAN_REORDER = "NIR_INTRINSIC_CAN_REORDER"
INTR_OPCODES = {}
-def intrinsic(name, src_comp=[], dest_comp=-1, num_vars=0, indices=[],
+def intrinsic(name, src_comp=[], dest_comp=-1, indices=[],
flags=[], sysval=False):
assert name not in INTR_OPCODES
- INTR_OPCODES[name] = Intrinsic(name, src_comp, dest_comp, num_vars,
+ INTR_OPCODES[name] = Intrinsic(name, src_comp, dest_comp,
indices, flags, sysval)
intrinsic("nop", flags=[CAN_ELIMINATE])
intrinsic("load_param", dest_comp=0, indices=[PARAM_IDX], flags=[CAN_ELIMINATE])
-intrinsic("load_var", dest_comp=0, num_vars=1, flags=[CAN_ELIMINATE])
-intrinsic("store_var", src_comp=[0], num_vars=1, indices=[WRMASK])
-intrinsic("copy_var", num_vars=2)
-
intrinsic("load_deref", dest_comp=0, src_comp=[1], flags=[CAN_ELIMINATE])
intrinsic("store_deref", src_comp=[1, 0], indices=[WRMASK])
intrinsic("copy_deref", src_comp=[1, 1])
-# Interpolation of input. The interp_var_at* intrinsics are similar to the
-# load_var intrinsic acting on a shader input except that they interpolate
-# the input differently. The at_sample and at_offset intrinsics take an
-# additional source that is an integer sample id or a vec2 position offset
-# respectively.
-
-intrinsic("interp_var_at_centroid", dest_comp=0, num_vars=1,
- flags=[ CAN_ELIMINATE, CAN_REORDER])
-intrinsic("interp_var_at_sample", src_comp=[1], dest_comp=0, num_vars=1,
- flags=[CAN_ELIMINATE, CAN_REORDER])
-intrinsic("interp_var_at_offset", src_comp=[2], dest_comp=0, num_vars=1,
- flags=[CAN_ELIMINATE, CAN_REORDER])
-
# Interpolation of input. The interp_deref_at* intrinsics are similar to the
# load_var intrinsic acting on a shader input except that they interpolate the
# input differently. The at_sample and at_offset intrinsics take an
@@ -276,17 +256,14 @@ intrinsic("set_vertex_count", src_comp=[1])
# lowered, variants take a constant buffer index and register offset.
def atomic(name, flags=[]):
- intrinsic(name + "_var", dest_comp=1, num_vars=1, flags=flags)
intrinsic(name + "_deref", src_comp=[1], dest_comp=1, flags=flags)
intrinsic(name, src_comp=[1], dest_comp=1, indices=[BASE], flags=flags)
def atomic2(name):
- intrinsic(name + "_var", src_comp=[1], dest_comp=1, num_vars=1)
intrinsic(name + "_deref", src_comp=[1, 1], dest_comp=1)
intrinsic(name, src_comp=[1, 1], dest_comp=1, indices=[BASE])
def atomic3(name):
- intrinsic(name + "_var", src_comp=[1, 1], dest_comp=1, num_vars=1)
intrinsic(name + "_deref", src_comp=[1, 1, 1], dest_comp=1)
intrinsic(name, src_comp=[1, 1, 1], dest_comp=1, indices=[BASE])
@@ -304,33 +281,6 @@ atomic3("atomic_counter_comp_swap")
# Image load, store and atomic intrinsics.
#
-# All image intrinsics take an image target passed as a nir_variable. Image
-# variables contain a number of memory and layout qualifiers that influence
-# the semantics of the intrinsic.
-#
-# All image intrinsics take a four-coordinate vector and a sample index as
-# first two sources, determining the location within the image that will be
-# accessed by the intrinsic. Components not applicable to the image target
-# in use are undefined. Image store takes an additional four-component
-# argument with the value to be written, and image atomic operations take
-# either one or two additional scalar arguments with the same meaning as in
-# the ARB_shader_image_load_store specification.
-intrinsic("image_var_load", src_comp=[4, 1], dest_comp=4, num_vars=1,
- flags=[CAN_ELIMINATE])
-intrinsic("image_var_store", src_comp=[4, 1, 4], num_vars=1)
-intrinsic("image_var_atomic_add", src_comp=[4, 1, 1], dest_comp=1, num_vars=1)
-intrinsic("image_var_atomic_min", src_comp=[4, 1, 1], dest_comp=1, num_vars=1)
-intrinsic("image_var_atomic_max", src_comp=[4, 1, 1], dest_comp=1, num_vars=1)
-intrinsic("image_var_atomic_and", src_comp=[4, 1, 1], dest_comp=1, num_vars=1)
-intrinsic("image_var_atomic_or", src_comp=[4, 1, 1], dest_comp=1, num_vars=1)
-intrinsic("image_var_atomic_xor", src_comp=[4, 1, 1], dest_comp=1, num_vars=1)
-intrinsic("image_var_atomic_exchange", src_comp=[4, 1, 1], dest_comp=1, num_vars=1)
-intrinsic("image_var_atomic_comp_swap", src_comp=[4, 1, 1, 1], dest_comp=1, num_vars=1)
-intrinsic("image_var_size", dest_comp=0, num_vars=1, flags=[CAN_ELIMINATE, CAN_REORDER])
-intrinsic("image_var_samples", dest_comp=1, num_vars=1, flags=[CAN_ELIMINATE, CAN_REORDER])
-
-# Image load, store and atomic intrinsics.
-#
# All image intrinsics take an image target passed as a nir_variable. The
# variable is passed in using a chain of nir_deref_instr with as the first
# source of the image intrinsic. Image variables contain a number of memory
@@ -387,31 +337,6 @@ intrinsic("vulkan_resource_reindex", src_comp=[1, 1], dest_comp=1,
# compute a new value using one of the operations below, write the new value
# to memory, and return the original value read.
#
-# All operations take 1 source except CompSwap that takes 2. These sources
-# represent:
-#
-# 0: The data parameter to the atomic function (i.e. the value to add
-# in shared_atomic_add, etc).
-# 1: For CompSwap only: the second data parameter.
-#
-# All operations take 1 variable deref.
-intrinsic("var_atomic_add", src_comp=[1], dest_comp=1, num_vars=1)
-intrinsic("var_atomic_imin", src_comp=[1], dest_comp=1, num_vars=1)
-intrinsic("var_atomic_umin", src_comp=[1], dest_comp=1, num_vars=1)
-intrinsic("var_atomic_imax", src_comp=[1], dest_comp=1, num_vars=1)
-intrinsic("var_atomic_umax", src_comp=[1], dest_comp=1, num_vars=1)
-intrinsic("var_atomic_and", src_comp=[1], dest_comp=1, num_vars=1)
-intrinsic("var_atomic_or", src_comp=[1], dest_comp=1, num_vars=1)
-intrinsic("var_atomic_xor", src_comp=[1], dest_comp=1, num_vars=1)
-intrinsic("var_atomic_exchange", src_comp=[1], dest_comp=1, num_vars=1)
-intrinsic("var_atomic_comp_swap", src_comp=[1, 1], dest_comp=1, num_vars=1)
-
-# variable atomic intrinsics
-#
-# All of these variable atomic memory operations read a value from memory,
-# compute a new value using one of the operations below, write the new value
-# to memory, and return the original value read.
-#
# All operations take 2 sources except CompSwap that takes 3. These sources
# represent:
#
@@ -482,7 +407,7 @@ intrinsic("shared_atomic_exchange", src_comp=[1, 1], dest_comp=1, indices=[BASE]
intrinsic("shared_atomic_comp_swap", src_comp=[1, 1, 1], dest_comp=1, indices=[BASE])
def system_value(name, dest_comp, indices=[]):
- intrinsic("load_" + name, [], dest_comp, 0, indices,
+ intrinsic("load_" + name, [], dest_comp, indices,
flags=[CAN_ELIMINATE, CAN_REORDER], sysval=True)
system_value("frag_coord", 4)
diff --git a/src/compiler/nir/nir_intrinsics_c.py b/src/compiler/nir/nir_intrinsics_c.py
index 4410bc6..9604fcd 100644
--- a/src/compiler/nir/nir_intrinsics_c.py
+++ b/src/compiler/nir/nir_intrinsics_c.py
@@ -36,7 +36,6 @@ const nir_intrinsic_info nir_intrinsic_infos[nir_num_intrinsics] = {
% endif
.has_dest = ${"true" if opcode.has_dest else "false"},
.dest_components = ${max(opcode.dest_components, 0)},
- .num_variables = ${opcode.num_variables},
.num_indices = ${opcode.num_indices},
% if opcode.indices:
.index_map = {
diff --git a/src/compiler/nir/nir_opt_constant_folding.c b/src/compiler/nir/nir_opt_constant_folding.c
index d6be807..52bda77 100644
--- a/src/compiler/nir/nir_opt_constant_folding.c
+++ b/src/compiler/nir/nir_opt_constant_folding.c
@@ -115,46 +115,10 @@ constant_fold_alu_instr(nir_alu_instr *instr, void *mem_ctx)
}
static bool
-constant_fold_deref(nir_instr *instr, nir_deref_var *deref)
-{
- bool progress = false;
-
- for (nir_deref *tail = deref->deref.child; tail; tail = tail->child) {
- if (tail->deref_type != nir_deref_type_array)
- continue;
-
- nir_deref_array *arr = nir_deref_as_array(tail);
-
- if (arr->deref_array_type == nir_deref_array_type_indirect &&
- arr->indirect.is_ssa &&
- arr->indirect.ssa->parent_instr->type == nir_instr_type_load_const) {
- nir_load_const_instr *indirect =
- nir_instr_as_load_const(arr->indirect.ssa->parent_instr);
-
- arr->base_offset += indirect->value.u32[0];
-
- /* Clear out the source */
- nir_instr_rewrite_src(instr, &arr->indirect, nir_src_for_ssa(NULL));
-
- arr->deref_array_type = nir_deref_array_type_direct;
-
- progress = true;
- }
- }
-
- return progress;
-}
-
-static bool
constant_fold_intrinsic_instr(nir_intrinsic_instr *instr)
{
bool progress = false;
- unsigned num_vars = nir_intrinsic_infos[instr->intrinsic].num_variables;
- for (unsigned i = 0; i < num_vars; i++) {
- progress |= constant_fold_deref(&instr->instr, instr->variables[i]);
- }
-
if (instr->intrinsic == nir_intrinsic_discard_if) {
nir_const_value *src_val = nir_src_as_const_value(instr->src[0]);
if (src_val && src_val->u32[0] == 0) {
@@ -167,20 +131,6 @@ constant_fold_intrinsic_instr(nir_intrinsic_instr *instr)
}
static bool
-constant_fold_tex_instr(nir_tex_instr *instr)
-{
- bool progress = false;
-
- if (instr->texture)
- progress |= constant_fold_deref(&instr->instr, instr->texture);
-
- if (instr->sampler)
- progress |= constant_fold_deref(&instr->instr, instr->sampler);
-
- return progress;
-}
-
-static bool
constant_fold_block(nir_block *block, void *mem_ctx)
{
bool progress = false;
@@ -194,9 +144,6 @@ constant_fold_block(nir_block *block, void *mem_ctx)
progress |=
constant_fold_intrinsic_instr(nir_instr_as_intrinsic(instr));
break;
- case nir_instr_type_tex:
- progress |= constant_fold_tex_instr(nir_instr_as_tex(instr));
- break;
default:
/* Don't know how to constant fold */
break;
diff --git a/src/compiler/nir/nir_opt_copy_propagate.c b/src/compiler/nir/nir_opt_copy_propagate.c
index 594727c..2e58bbf 100644
--- a/src/compiler/nir/nir_opt_copy_propagate.c
+++ b/src/compiler/nir/nir_opt_copy_propagate.c
@@ -219,28 +219,6 @@ copy_prop_dest(nir_dest *dest, nir_instr *instr)
}
static bool
-copy_prop_deref_var(nir_instr *instr, nir_deref_var *deref_var)
-{
- if (!deref_var)
- return false;
-
- bool progress = false;
- for (nir_deref *deref = deref_var->deref.child;
- deref; deref = deref->child) {
- if (deref->deref_type != nir_deref_type_array)
- continue;
-
- nir_deref_array *arr = nir_deref_as_array(deref);
- if (arr->deref_array_type != nir_deref_array_type_indirect)
- continue;
-
- while (copy_prop_src(&arr->indirect, instr, NULL, 1))
- progress = true;
- }
- return progress;
-}
-
-static bool
copy_prop_instr(nir_instr *instr)
{
bool progress = false;
@@ -284,11 +262,6 @@ copy_prop_instr(nir_instr *instr)
progress = true;
}
- if (copy_prop_deref_var(instr, tex->texture))
- progress = true;
- if (copy_prop_deref_var(instr, tex->sampler))
- progress = true;
-
while (copy_prop_dest(&tex->dest, instr))
progress = true;
@@ -308,12 +281,6 @@ copy_prop_instr(nir_instr *instr)
progress = true;
}
- for (unsigned i = 0;
- i < nir_intrinsic_infos[intrin->intrinsic].num_variables; i++) {
- if (copy_prop_deref_var(instr, intrin->variables[i]))
- progress = true;
- }
-
if (nir_intrinsic_infos[intrin->intrinsic].has_dest) {
while (copy_prop_dest(&intrin->dest, instr))
progress = true;
diff --git a/src/compiler/nir/nir_print.c b/src/compiler/nir/nir_print.c
index 10cbedf..6e6fd42 100644
--- a/src/compiler/nir/nir_print.c
+++ b/src/compiler/nir/nir_print.c
@@ -539,81 +539,6 @@ print_deref_instr(nir_deref_instr *instr, print_state *state)
}
static void
-print_var(nir_variable *var, print_state *state)
-{
- FILE *fp = state->fp;
- fprintf(fp, "%s", get_var_name(var, state));
-}
-
-static void
-print_deref_var(nir_deref_var *deref, print_state *state)
-{
- print_var(deref->var, state);
-}
-
-static void
-print_deref_array(nir_deref_array *deref, print_state *state)
-{
- FILE *fp = state->fp;
- fprintf(fp, "[");
- switch (deref->deref_array_type) {
- case nir_deref_array_type_direct:
- fprintf(fp, "%u", deref->base_offset);
- break;
- case nir_deref_array_type_indirect:
- if (deref->base_offset != 0)
- fprintf(fp, "%u + ", deref->base_offset);
- print_src(&deref->indirect, state);
- break;
- case nir_deref_array_type_wildcard:
- fprintf(fp, "*");
- break;
- }
- fprintf(fp, "]");
-}
-
-static void
-print_deref_struct(nir_deref_struct *deref, const struct glsl_type *parent_type,
- print_state *state)
-{
- FILE *fp = state->fp;
- fprintf(fp, ".%s", glsl_get_struct_elem_name(parent_type, deref->index));
-}
-
-static void
-print_deref(nir_deref_var *deref, print_state *state)
-{
- nir_deref *tail = &deref->deref;
- nir_deref *pretail = NULL;
- while (tail != NULL) {
- switch (tail->deref_type) {
- case nir_deref_type_var:
- assert(pretail == NULL);
- assert(tail == &deref->deref);
- print_deref_var(deref, state);
- break;
-
- case nir_deref_type_array:
- assert(pretail != NULL);
- print_deref_array(nir_deref_as_array(tail), state);
- break;
-
- case nir_deref_type_struct:
- assert(pretail != NULL);
- print_deref_struct(nir_deref_as_struct(tail),
- pretail->type, state);
- break;
-
- default:
- unreachable("Invalid deref type");
- }
-
- pretail = tail;
- tail = pretail->child;
- }
-}
-
-static void
print_intrinsic_instr(nir_intrinsic_instr *instr, print_state *state)
{
const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
@@ -636,15 +561,6 @@ print_intrinsic_instr(nir_intrinsic_instr *instr, print_state *state)
fprintf(fp, ") (");
- for (unsigned i = 0; i < info->num_variables; i++) {
- if (i != 0)
- fprintf(fp, ", ");
-
- print_deref(instr->variables[i], state);
- }
-
- fprintf(fp, ") (");
-
for (unsigned i = 0; i < info->num_indices; i++) {
if (i != 0)
fprintf(fp, ", ");
@@ -840,19 +756,6 @@ print_tex_instr(nir_tex_instr *instr, print_state *state)
if (instr->op == nir_texop_tg4) {
fprintf(fp, "%u (gather_component), ", instr->component);
}
-
- if (instr->texture) {
- print_deref(instr->texture, state);
- fprintf(fp, " (texture)");
- if (instr->sampler) {
- print_deref(instr->sampler, state);
- fprintf(fp, " (sampler)");
- }
- } else {
- assert(instr->sampler == NULL);
- fprintf(fp, "%u (texture) %u (sampler)",
- instr->texture_index, instr->sampler_index);
- }
}
static void
diff --git a/src/compiler/nir/nir_serialize.c b/src/compiler/nir/nir_serialize.c
index 6b57f21..cc4bf23 100644
--- a/src/compiler/nir/nir_serialize.c
+++ b/src/compiler/nir/nir_serialize.c
@@ -370,81 +370,6 @@ read_dest(read_ctx *ctx, nir_dest *dst, nir_instr *instr)
}
static void
-write_deref_chain(write_ctx *ctx, const nir_deref_var *deref_var)
-{
- write_object(ctx, deref_var->var);
-
- uint32_t len = 0;
- for (const nir_deref *d = deref_var->deref.child; d; d = d->child)
- len++;
- blob_write_uint32(ctx->blob, len);
-
- for (const nir_deref *d = deref_var->deref.child; d; d = d->child) {
- blob_write_uint32(ctx->blob, d->deref_type);
- switch (d->deref_type) {
- case nir_deref_type_array: {
- const nir_deref_array *deref_array = nir_deref_as_array(d);
- blob_write_uint32(ctx->blob, deref_array->deref_array_type);
- blob_write_uint32(ctx->blob, deref_array->base_offset);
- if (deref_array->deref_array_type == nir_deref_array_type_indirect)
- write_src(ctx, &deref_array->indirect);
- break;
- }
- case nir_deref_type_struct: {
- const nir_deref_struct *deref_struct = nir_deref_as_struct(d);
- blob_write_uint32(ctx->blob, deref_struct->index);
- break;
- }
- case nir_deref_type_var:
- unreachable("Invalid deref type");
- }
-
- encode_type_to_blob(ctx->blob, d->type);
- }
-}
-
-static nir_deref_var *
-read_deref_chain(read_ctx *ctx, void *mem_ctx)
-{
- nir_variable *var = read_object(ctx);
- nir_deref_var *deref_var = nir_deref_var_create(mem_ctx, var);
-
- uint32_t len = blob_read_uint32(ctx->blob);
-
- nir_deref *tail = &deref_var->deref;
- for (uint32_t i = 0; i < len; i++) {
- nir_deref_type deref_type = blob_read_uint32(ctx->blob);
- nir_deref *deref = NULL;
- switch (deref_type) {
- case nir_deref_type_array: {
- nir_deref_array *deref_array = nir_deref_array_create(tail);
- deref_array->deref_array_type = blob_read_uint32(ctx->blob);
- deref_array->base_offset = blob_read_uint32(ctx->blob);
- if (deref_array->deref_array_type == nir_deref_array_type_indirect)
- read_src(ctx, &deref_array->indirect, mem_ctx);
- deref = &deref_array->deref;
- break;
- }
- case nir_deref_type_struct: {
- uint32_t index = blob_read_uint32(ctx->blob);
- nir_deref_struct *deref_struct = nir_deref_struct_create(tail, index);
- deref = &deref_struct->deref;
- break;
- }
- case nir_deref_type_var:
- unreachable("Invalid deref type");
- }
-
- deref->type = decode_type_from_blob(ctx->blob);
-
- tail->child = deref;
- tail = deref;
- }
-
- return deref_var;
-}
-
-static void
write_alu(write_ctx *ctx, const nir_alu_instr *alu)
{
blob_write_uint32(ctx->blob, alu->op);
@@ -570,7 +495,6 @@ write_intrinsic(write_ctx *ctx, const nir_intrinsic_instr *intrin)
{
blob_write_uint32(ctx->blob, intrin->intrinsic);
- unsigned num_variables = nir_intrinsic_infos[intrin->intrinsic].num_variables;
unsigned num_srcs = nir_intrinsic_infos[intrin->intrinsic].num_srcs;
unsigned num_indices = nir_intrinsic_infos[intrin->intrinsic].num_indices;
@@ -579,9 +503,6 @@ write_intrinsic(write_ctx *ctx, const nir_intrinsic_instr *intrin)
if (nir_intrinsic_infos[intrin->intrinsic].has_dest)
write_dest(ctx, &intrin->dest);
- for (unsigned i = 0; i < num_variables; i++)
- write_deref_chain(ctx, intrin->variables[i]);
-
for (unsigned i = 0; i < num_srcs; i++)
write_src(ctx, &intrin->src[i]);
@@ -596,7 +517,6 @@ read_intrinsic(read_ctx *ctx)
nir_intrinsic_instr *intrin = nir_intrinsic_instr_create(ctx->nir, op);
- unsigned num_variables = nir_intrinsic_infos[op].num_variables;
unsigned num_srcs = nir_intrinsic_infos[op].num_srcs;
unsigned num_indices = nir_intrinsic_infos[op].num_indices;
@@ -605,9 +525,6 @@ read_intrinsic(read_ctx *ctx)
if (nir_intrinsic_infos[op].has_dest)
read_dest(ctx, &intrin->dest, &intrin->instr);
- for (unsigned i = 0; i < num_variables; i++)
- intrin->variables[i] = read_deref_chain(ctx, &intrin->instr);
-
for (unsigned i = 0; i < num_srcs; i++)
read_src(ctx, &intrin->src[i], &intrin->instr);
@@ -671,8 +588,6 @@ union packed_tex_data {
unsigned is_shadow:1;
unsigned is_new_style_shadow:1;
unsigned component:2;
- unsigned has_texture_deref:1;
- unsigned has_sampler_deref:1;
unsigned unused:10; /* Mark unused for valgrind. */
} u;
};
@@ -695,8 +610,6 @@ write_tex(write_ctx *ctx, const nir_tex_instr *tex)
.u.is_shadow = tex->is_shadow,
.u.is_new_style_shadow = tex->is_new_style_shadow,
.u.component = tex->component,
- .u.has_texture_deref = tex->texture != NULL,
- .u.has_sampler_deref = tex->sampler != NULL,
};
blob_write_uint32(ctx->blob, packed.u32);
@@ -705,11 +618,6 @@ write_tex(write_ctx *ctx, const nir_tex_instr *tex)
blob_write_uint32(ctx->blob, tex->src[i].src_type);
write_src(ctx, &tex->src[i].src);
}
-
- if (tex->texture)
- write_deref_chain(ctx, tex->texture);
- if (tex->sampler)
- write_deref_chain(ctx, tex->sampler);
}
static nir_tex_instr *
@@ -739,11 +647,6 @@ read_tex(read_ctx *ctx)
read_src(ctx, &tex->src[i].src, &tex->instr);
}
- tex->texture = packed.u.has_texture_deref ?
- read_deref_chain(ctx, &tex->instr) : NULL;
- tex->sampler = packed.u.has_sampler_deref ?
- read_deref_chain(ctx, &tex->instr) : NULL;
-
return tex;
}
diff --git a/src/compiler/nir/nir_validate.c b/src/compiler/nir/nir_validate.c
index e8c0a2a..6820f4e 100644
--- a/src/compiler/nir/nir_validate.c
+++ b/src/compiler/nir/nir_validate.c
@@ -401,55 +401,6 @@ validate_alu_instr(nir_alu_instr *instr, validate_state *state)
}
static void
-validate_deref_chain(nir_deref *deref, nir_variable_mode mode,
- validate_state *state)
-{
- validate_assert(state, deref->child == NULL || ralloc_parent(deref->child) == deref);
-
- nir_deref *parent = NULL;
- while (deref != NULL) {
- switch (deref->deref_type) {
- case nir_deref_type_array:
- if (mode == nir_var_shared) {
- /* Shared variables have a bit more relaxed rules because we need
- * to be able to handle array derefs on vectors. Fortunately,
- * nir_lower_io handles these just fine.
- */
- validate_assert(state, glsl_type_is_array(parent->type) ||
- glsl_type_is_matrix(parent->type) ||
- glsl_type_is_vector(parent->type));
- } else {
- /* Most of NIR cannot handle array derefs on vectors */
- validate_assert(state, glsl_type_is_array(parent->type) ||
- glsl_type_is_matrix(parent->type));
- }
- validate_assert(state, deref->type == glsl_get_array_element(parent->type));
- if (nir_deref_as_array(deref)->deref_array_type ==
- nir_deref_array_type_indirect)
- validate_src(&nir_deref_as_array(deref)->indirect, state, 32, 1);
- break;
-
- case nir_deref_type_struct:
- assume(parent); /* cannot happen: deref change starts w/ nir_deref_var */
- validate_assert(state, deref->type ==
- glsl_get_struct_field(parent->type,
- nir_deref_as_struct(deref)->index));
- break;
-
- case nir_deref_type_var:
- break;
-
- default:
- validate_assert(state, !"Invalid deref type");
- break;
- }
-
- parent = deref;
- deref = deref->child;
- }
-}
-
-static void
validate_var_use(nir_variable *var, validate_state *state)
{
struct hash_entry *entry = _mesa_hash_table_search(state->var_defs, var);
@@ -459,18 +410,6 @@ validate_var_use(nir_variable *var, validate_state *state)
}
static void
-validate_deref_var(void *parent_mem_ctx, nir_deref_var *deref, validate_state *state)
-{
- validate_assert(state, deref != NULL);
- validate_assert(state, ralloc_parent(deref) == parent_mem_ctx);
- validate_assert(state, deref->deref.type == deref->var->type);
-
- validate_var_use(deref->var, state);
-
- validate_deref_chain(&deref->deref, deref->var->data.mode, state);
-}
-
-static void
validate_deref_instr(nir_deref_instr *instr, validate_state *state)
{
if (instr->deref_type == nir_deref_type_var) {
@@ -598,41 +537,6 @@ validate_intrinsic_instr(nir_intrinsic_instr *instr, validate_state *state)
break;
}
- case nir_intrinsic_load_var: {
- const struct glsl_type *type =
- nir_deref_tail(&instr->variables[0]->deref)->type;
- validate_assert(state, glsl_type_is_vector_or_scalar(type) ||
- (instr->variables[0]->var->data.mode == nir_var_uniform &&
- glsl_get_base_type(type) == GLSL_TYPE_SUBROUTINE));
- validate_assert(state, instr->num_components ==
- glsl_get_vector_elements(type));
- dest_bit_size = glsl_get_bit_size(type);
- break;
- }
-
- case nir_intrinsic_store_var: {
- const struct glsl_type *type =
- nir_deref_tail(&instr->variables[0]->deref)->type;
- validate_assert(state, glsl_type_is_vector_or_scalar(type) ||
- (instr->variables[0]->var->data.mode == nir_var_uniform &&
- glsl_get_base_type(type) == GLSL_TYPE_SUBROUTINE));
- validate_assert(state, instr->num_components == glsl_get_vector_elements(type));
- src_bit_sizes[0] = glsl_get_bit_size(type);
- validate_assert(state, instr->variables[0]->var->data.mode != nir_var_shader_in &&
- instr->variables[0]->var->data.mode != nir_var_uniform &&
- instr->variables[0]->var->data.mode != nir_var_shader_storage);
- validate_assert(state, (nir_intrinsic_write_mask(instr) & ~((1 << instr->num_components) - 1)) == 0);
- break;
- }
-
- case nir_intrinsic_copy_var:
- validate_assert(state, nir_deref_tail(&instr->variables[0]->deref)->type ==
- nir_deref_tail(&instr->variables[1]->deref)->type);
- validate_assert(state, instr->variables[0]->var->data.mode != nir_var_shader_in &&
- instr->variables[0]->var->data.mode != nir_var_uniform &&
- instr->variables[0]->var->data.mode != nir_var_shader_storage);
- break;
-
default:
break;
}
@@ -649,11 +553,6 @@ validate_intrinsic_instr(nir_intrinsic_instr *instr, validate_state *state)
validate_src(&instr->src[i], state, src_bit_sizes[i], components_read);
}
- unsigned num_vars = nir_intrinsic_infos[instr->intrinsic].num_variables;
- for (unsigned i = 0; i < num_vars; i++) {
- validate_deref_var(instr, instr->variables[i], state);
- }
-
if (nir_intrinsic_infos[instr->intrinsic].has_dest) {
unsigned components_written =
nir_intrinsic_infos[instr->intrinsic].dest_components;
@@ -680,12 +579,6 @@ validate_tex_instr(nir_tex_instr *instr, validate_state *state)
0, nir_tex_instr_src_size(instr, i));
}
- if (instr->texture != NULL)
- validate_deref_var(instr, instr->texture, state);
-
- if (instr->sampler != NULL)
- validate_deref_var(instr, instr->sampler, state);
-
validate_dest(&instr->dest, state, 0, nir_tex_instr_dest_size(instr));
}
--
2.5.0.400.gff86faf
More information about the mesa-dev
mailing list