#include <assert.h>
nir_shader *
-nir_shader_create(void *mem_ctx)
+nir_shader_create(void *mem_ctx, const nir_shader_compiler_options *options)
{
nir_shader *shader = ralloc(mem_ctx, nir_shader);
- shader->uniforms = _mesa_hash_table_create(shader, _mesa_key_hash_string,
- _mesa_key_string_equal);
- shader->inputs = _mesa_hash_table_create(shader, _mesa_key_hash_string,
- _mesa_key_string_equal);
- shader->outputs = _mesa_hash_table_create(shader, _mesa_key_hash_string,
- _mesa_key_string_equal);
+ exec_list_make_empty(&shader->uniforms);
+ exec_list_make_empty(&shader->inputs);
+ exec_list_make_empty(&shader->outputs);
- shader->num_user_structures = 0;
- shader->user_structures = NULL;
+ shader->options = options;
exec_list_make_empty(&shader->functions);
exec_list_make_empty(&shader->registers);
{
nir_register *reg = ralloc(mem_ctx, nir_register);
- reg->uses = _mesa_set_create(mem_ctx, _mesa_key_pointer_equal);
- reg->defs = _mesa_set_create(mem_ctx, _mesa_key_pointer_equal);
- reg->if_uses = _mesa_set_create(mem_ctx, _mesa_key_pointer_equal);
+ list_inithead(®->uses);
+ list_inithead(®->defs);
+ list_inithead(®->if_uses);
reg->num_components = 0;
reg->num_array_elems = 0;
exec_list_push_tail(&shader->functions, &func->node);
exec_list_make_empty(&func->overload_list);
- func->name = name;
+ func->name = ralloc_strdup(func, name);
+ func->shader = shader;
return func;
}
return overload;
}
-nir_src nir_src_copy(nir_src src, void *mem_ctx)
+void nir_src_copy(nir_src *dest, const nir_src *src, void *mem_ctx)
{
- nir_src ret;
- ret.is_ssa = src.is_ssa;
- if (ret.is_ssa) {
- ret.ssa = src.ssa;
+ dest->is_ssa = src->is_ssa;
+ if (src->is_ssa) {
+ dest->ssa = src->ssa;
} else {
- ret.reg.base_offset = src.reg.base_offset;
- ret.reg.reg = src.reg.reg;
- if (src.reg.indirect) {
- ret.reg.indirect = ralloc(mem_ctx, nir_src);
- *ret.reg.indirect = *src.reg.indirect;
+ dest->reg.base_offset = src->reg.base_offset;
+ dest->reg.reg = src->reg.reg;
+ if (src->reg.indirect) {
+ dest->reg.indirect = ralloc(mem_ctx, nir_src);
+ nir_src_copy(dest->reg.indirect, src->reg.indirect, mem_ctx);
} else {
- ret.reg.indirect = NULL;
+ dest->reg.indirect = NULL;
}
}
-
- return ret;
}
-nir_dest nir_dest_copy(nir_dest dest, void *mem_ctx)
+void nir_dest_copy(nir_dest *dest, const nir_dest *src, void *mem_ctx)
{
- nir_dest ret;
- ret.is_ssa = dest.is_ssa;
- if (ret.is_ssa) {
- ret.ssa = dest.ssa;
+ /* Copying an SSA definition makes no sense whatsoever. */
+ assert(!src->is_ssa);
+
+ dest->is_ssa = false;
+
+ dest->reg.base_offset = src->reg.base_offset;
+ dest->reg.reg = src->reg.reg;
+ if (src->reg.indirect) {
+ dest->reg.indirect = ralloc(mem_ctx, nir_src);
+ nir_src_copy(dest->reg.indirect, src->reg.indirect, mem_ctx);
} else {
- ret.reg.base_offset = dest.reg.base_offset;
- ret.reg.reg = dest.reg.reg;
- if (dest.reg.indirect) {
- ret.reg.indirect = ralloc(mem_ctx, nir_src);
- *ret.reg.indirect = *dest.reg.indirect;
- } else {
- ret.reg.indirect = NULL;
- }
+ dest->reg.indirect = NULL;
}
+}
- return ret;
+void
+nir_alu_src_copy(nir_alu_src *dest, const nir_alu_src *src, void *mem_ctx)
+{
+ nir_src_copy(&dest->src, &src->src, mem_ctx);
+ dest->abs = src->abs;
+ dest->negate = src->negate;
+ for (unsigned i = 0; i < 4; i++)
+ dest->swizzle[i] = src->swizzle[i];
+}
+
+void
+nir_alu_dest_copy(nir_alu_dest *dest, const nir_alu_dest *src, void *mem_ctx)
+{
+ nir_dest_copy(&dest->dest, &src->dest, mem_ctx);
+ dest->write_mask = src->write_mask;
+ dest->saturate = src->saturate;
}
static inline void
block_add_pred(nir_block *block, nir_block *pred)
{
- _mesa_set_add(block->predecessors, _mesa_hash_pointer(pred), pred);
+ _mesa_set_add(block->predecessors, pred);
}
static void
pred->successors[1] = NULL;
}
- struct set_entry *entry = _mesa_set_search(succ->predecessors,
- _mesa_hash_pointer(pred), pred);
+ struct set_entry *entry = _mesa_set_search(succ->predecessors, pred);
assert(entry);
impl->return_var = NULL;
impl->reg_alloc = 0;
impl->ssa_alloc = 0;
- impl->block_index_dirty = true;
+ impl->valid_metadata = nir_metadata_none;
/* create start & end blocks */
nir_block *start_block = nir_block_create(mem_ctx);
cf_init(&block->cf_node, nir_cf_node_block);
block->successors[0] = block->successors[1] = NULL;
- block->predecessors = _mesa_set_create(mem_ctx, _mesa_key_pointer_equal);
+ block->predecessors = _mesa_set_create(block, _mesa_hash_pointer,
+ _mesa_key_pointer_equal);
+ block->imm_dom = NULL;
+ block->dom_frontier = _mesa_set_create(block, _mesa_hash_pointer,
+ _mesa_key_pointer_equal);
exec_list_make_empty(&block->instr_list);
}
nir_alu_instr *
-nir_alu_instr_create(void *mem_ctx, nir_op op)
+nir_alu_instr_create(nir_shader *shader, nir_op op)
{
unsigned num_srcs = nir_op_infos[op].num_inputs;
nir_alu_instr *instr =
- ralloc_size(mem_ctx,
+ ralloc_size(shader,
sizeof(nir_alu_instr) + num_srcs * sizeof(nir_alu_src));
instr_init(&instr->instr, nir_instr_type_alu);
for (unsigned i = 0; i < num_srcs; i++)
alu_src_init(&instr->src[i]);
- instr->has_predicate = false;
- src_init(&instr->predicate);
-
return instr;
}
nir_jump_instr *
-nir_jump_instr_create(void *mem_ctx, nir_jump_type type)
+nir_jump_instr_create(nir_shader *shader, nir_jump_type type)
{
- nir_jump_instr *instr = ralloc(mem_ctx, nir_jump_instr);
+ nir_jump_instr *instr = ralloc(shader, nir_jump_instr);
instr_init(&instr->instr, nir_instr_type_jump);
instr->type = type;
return instr;
}
nir_load_const_instr *
-nir_load_const_instr_create(void *mem_ctx)
+nir_load_const_instr_create(nir_shader *shader, unsigned num_components)
{
- nir_load_const_instr *instr = ralloc(mem_ctx, nir_load_const_instr);
+ nir_load_const_instr *instr = ralloc(shader, nir_load_const_instr);
instr_init(&instr->instr, nir_instr_type_load_const);
- dest_init(&instr->dest);
- instr->num_components = 0;
- instr->array_elems = 0;
-
- instr->has_predicate = false;
- src_init(&instr->predicate);
+ nir_ssa_def_init(&instr->instr, &instr->def, num_components, NULL);
return instr;
}
nir_intrinsic_instr *
-nir_intrinsic_instr_create(void *mem_ctx, nir_intrinsic_op op)
+nir_intrinsic_instr_create(nir_shader *shader, nir_intrinsic_op op)
{
unsigned num_srcs = nir_intrinsic_infos[op].num_srcs;
nir_intrinsic_instr *instr =
- ralloc_size(mem_ctx,
+ ralloc_size(shader,
sizeof(nir_intrinsic_instr) + num_srcs * sizeof(nir_src));
instr_init(&instr->instr, nir_instr_type_intrinsic);
for (unsigned i = 0; i < num_srcs; i++)
src_init(&instr->src[i]);
- instr->has_predicate = false;
- src_init(&instr->predicate);
-
return instr;
}
nir_call_instr *
-nir_call_instr_create(void *mem_ctx, nir_function_overload *callee)
+nir_call_instr_create(nir_shader *shader, nir_function_overload *callee)
{
- nir_call_instr *instr = ralloc(mem_ctx, nir_call_instr);
+ nir_call_instr *instr = ralloc(shader, nir_call_instr);
instr_init(&instr->instr, nir_instr_type_call);
instr->callee = callee;
instr->num_params = callee->num_params;
- instr->params = ralloc_array(mem_ctx, nir_deref_var *, instr->num_params);
+ instr->params = ralloc_array(instr, nir_deref_var *, instr->num_params);
instr->return_deref = NULL;
- instr->has_predicate = false;
- src_init(&instr->predicate);
-
return instr;
}
nir_tex_instr *
-nir_tex_instr_create(void *mem_ctx, unsigned num_srcs)
+nir_tex_instr_create(nir_shader *shader, unsigned num_srcs)
{
- nir_tex_instr *instr = ralloc(mem_ctx, nir_tex_instr);
- instr_init(&instr->instr, nir_instr_type_texture);
+ nir_tex_instr *instr = ralloc(shader, nir_tex_instr);
+ instr_init(&instr->instr, nir_instr_type_tex);
dest_init(&instr->dest);
instr->num_srcs = num_srcs;
+ instr->src = ralloc_array(instr, nir_tex_src, num_srcs);
for (unsigned i = 0; i < num_srcs; i++)
- src_init(&instr->src[i]);
+ src_init(&instr->src[i].src);
- instr->has_predicate = false;
- src_init(&instr->predicate);
+ instr->sampler_index = 0;
+ instr->sampler_array_size = 0;
+ instr->sampler = NULL;
return instr;
}
nir_phi_instr *
-nir_phi_instr_create(void *mem_ctx)
+nir_phi_instr_create(nir_shader *shader)
{
- nir_phi_instr *instr = ralloc(mem_ctx, nir_phi_instr);
+ nir_phi_instr *instr = ralloc(shader, nir_phi_instr);
instr_init(&instr->instr, nir_instr_type_phi);
dest_init(&instr->dest);
return instr;
}
+nir_parallel_copy_instr *
+nir_parallel_copy_instr_create(nir_shader *shader)
+{
+ nir_parallel_copy_instr *instr = ralloc(shader, nir_parallel_copy_instr);
+ instr_init(&instr->instr, nir_instr_type_parallel_copy);
+
+ exec_list_make_empty(&instr->entries);
+
+ return instr;
+}
+
nir_ssa_undef_instr *
-nir_ssa_undef_instr_create(void *mem_ctx)
+nir_ssa_undef_instr_create(nir_shader *shader, unsigned num_components)
{
- nir_ssa_undef_instr *instr = ralloc(mem_ctx, nir_ssa_undef_instr);
+ nir_ssa_undef_instr *instr = ralloc(shader, nir_ssa_undef_instr);
instr_init(&instr->instr, nir_instr_type_ssa_undef);
- instr->def.name = NULL;
- instr->def.parent_instr = &instr->instr;
+ nir_ssa_def_init(&instr->instr, &instr->def, num_components, NULL);
return instr;
}
nir_deref_array *deref = ralloc(mem_ctx, nir_deref_array);
deref->deref.deref_type = nir_deref_type_array;
deref->deref.child = NULL;
- deref->has_indirect = false;
+ 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, const char *field)
+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->elem = ralloc_strdup(deref, field);
+ deref->index = field_index;
return deref;
}
copy_deref_var(void *mem_ctx, nir_deref_var *deref)
{
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_copy_deref(mem_ctx, deref->deref.child);
+ ret->deref.child = nir_copy_deref(ret, deref->deref.child);
return ret;
}
{
nir_deref_array *ret = nir_deref_array_create(mem_ctx);
ret->base_offset = deref->base_offset;
- if (deref->has_indirect)
- ret->indirect = deref->indirect;
+ 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_copy_deref(mem_ctx, deref->deref.child);
+ ret->deref.child = nir_copy_deref(ret, deref->deref.child);
return ret;
}
static nir_deref_struct *
copy_deref_struct(void *mem_ctx, nir_deref_struct *deref)
{
- nir_deref_struct *ret = nir_deref_struct_create(mem_ctx, deref->elem);
+ 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_copy_deref(mem_ctx, deref->deref.child);
+ ret->deref.child = nir_copy_deref(ret, deref->deref.child);
return ret;
}
return NULL;
}
+/* Returns a load_const instruction that represents the constant
+ * initializer for the given deref chain. The caller is responsible for
+ * ensuring that there actually is a constant initializer.
+ */
+nir_load_const_instr *
+nir_deref_get_const_initializer_load(nir_shader *shader, nir_deref_var *deref)
+{
+ nir_constant *constant = deref->var->constant_initializer;
+ assert(constant);
+
+ const nir_deref *tail = &deref->deref;
+ unsigned matrix_offset = 0;
+ while (tail->child) {
+ switch (tail->child->deref_type) {
+ case nir_deref_type_array: {
+ nir_deref_array *arr = nir_deref_as_array(tail->child);
+ assert(arr->deref_array_type == nir_deref_array_type_direct);
+ if (glsl_type_is_matrix(tail->type)) {
+ assert(arr->deref.child == NULL);
+ matrix_offset = arr->base_offset;
+ } else {
+ constant = constant->elements[arr->base_offset];
+ }
+ break;
+ }
+
+ case nir_deref_type_struct: {
+ constant = constant->elements[nir_deref_as_struct(tail->child)->index];
+ break;
+ }
+
+ default:
+ unreachable("Invalid deref child type");
+ }
+
+ tail = tail->child;
+ }
+
+ nir_load_const_instr *load =
+ nir_load_const_instr_create(shader, glsl_get_vector_elements(tail->type));
+
+ matrix_offset *= load->def.num_components;
+ for (unsigned i = 0; i < load->def.num_components; i++) {
+ switch (glsl_get_base_type(tail->type)) {
+ case GLSL_TYPE_FLOAT:
+ case GLSL_TYPE_INT:
+ case GLSL_TYPE_UINT:
+ load->value.u[i] = constant->value.u[matrix_offset + i];
+ break;
+ case GLSL_TYPE_BOOL:
+ load->value.u[i] = constant->value.b[matrix_offset + i] ?
+ NIR_TRUE : NIR_FALSE;
+ break;
+ default:
+ unreachable("Invalid immediate type");
+ }
+ }
+
+ return load;
+}
/**
* \name Control flow modification
return new_block;
}
+static void
+rewrite_phi_preds(nir_block *block, nir_block *old_pred, nir_block *new_pred)
+{
+ nir_foreach_instr_safe(block, instr) {
+ if (instr->type != nir_instr_type_phi)
+ break;
+
+ nir_phi_instr *phi = nir_instr_as_phi(instr);
+ nir_foreach_phi_src(phi, src) {
+ if (src->pred == old_pred) {
+ src->pred = new_pred;
+ break;
+ }
+ }
+ }
+}
+
/**
* Moves the successors of source to the successors of dest, leaving both
* successors of source NULL.
move_successors(nir_block *source, nir_block *dest)
{
nir_block *succ1 = source->successors[0];
- if (succ1)
+ nir_block *succ2 = source->successors[1];
+
+ if (succ1) {
unlink_blocks(source, succ1);
+ rewrite_phi_preds(succ1, source, dest);
+ }
- nir_block *succ2 = source->successors[1];
- if (succ2)
+ if (succ2) {
unlink_blocks(source, succ2);
+ rewrite_phi_preds(succ2, source, dest);
+ }
unlink_block_successors(dest);
link_blocks(dest, succ1, succ2);
unlink_block_successors(block);
+ nir_function_impl *impl = nir_cf_node_get_function(&block->cf_node);
+ nir_metadata_preserve(impl, nir_metadata_none);
+
if (jump_instr->type == nir_jump_break ||
jump_instr->type == nir_jump_continue) {
nir_loop *loop = nearest_loop(&block->cf_node);
}
} else {
assert(jump_instr->type == nir_jump_return);
- nir_function_impl *impl = nir_cf_node_get_function(&block->cf_node);
link_blocks(block, impl->end_block, NULL);
}
}
block_add_pred(next_block, last_block);
}
}
+
+ nir_function_impl *impl = nir_cf_node_get_function(&block->cf_node);
+ nir_metadata_preserve(impl, nir_metadata_none);
}
/**
return;
nir_if *if_stmt = nir_cf_node_as_if(node);
- if (if_stmt->condition.is_ssa)
- return;
-
- nir_register *reg = if_stmt->condition.reg.reg;
- assert(reg != NULL);
- _mesa_set_add(reg->if_uses, _mesa_hash_pointer(if_stmt), if_stmt);
+ if_stmt->condition.parent_if = if_stmt;
+ if (if_stmt->condition.is_ssa) {
+ list_addtail(&if_stmt->condition.use_link,
+ &if_stmt->condition.ssa->if_uses);
+ } else {
+ list_addtail(&if_stmt->condition.use_link,
+ &if_stmt->condition.reg.reg->if_uses);
+ }
}
void
}
nir_function_impl *impl = nir_cf_node_get_function(node);
- impl->block_index_dirty = true;
+ nir_metadata_preserve(impl, nir_metadata_none);
}
void
}
nir_function_impl *impl = nir_cf_node_get_function(node);
- impl->block_index_dirty = true;
+ nir_metadata_preserve(impl, nir_metadata_none);
}
void
exec_node_remove(&after->cf_node.node);
}
+static void
+remove_defs_uses(nir_instr *instr);
+
+static void
+cleanup_cf_node(nir_cf_node *node)
+{
+ switch (node->type) {
+ case nir_cf_node_block: {
+ nir_block *block = nir_cf_node_as_block(node);
+ /* We need to walk the instructions and clean up defs/uses */
+ nir_foreach_instr(block, instr)
+ remove_defs_uses(instr);
+ break;
+ }
+
+ case nir_cf_node_if: {
+ nir_if *if_stmt = nir_cf_node_as_if(node);
+ foreach_list_typed(nir_cf_node, child, node, &if_stmt->then_list)
+ cleanup_cf_node(child);
+ foreach_list_typed(nir_cf_node, child, node, &if_stmt->else_list)
+ cleanup_cf_node(child);
+
+ list_del(&if_stmt->condition.use_link);
+ break;
+ }
+
+ case nir_cf_node_loop: {
+ nir_loop *loop = nir_cf_node_as_loop(node);
+ foreach_list_typed(nir_cf_node, child, node, &loop->body)
+ cleanup_cf_node(child);
+ break;
+ }
+ case nir_cf_node_function: {
+ nir_function_impl *impl = nir_cf_node_as_function(node);
+ foreach_list_typed(nir_cf_node, child, node, &impl->body)
+ cleanup_cf_node(child);
+ break;
+ }
+ default:
+ unreachable("Invalid CF node type");
+ }
+}
+
void
nir_cf_node_remove(nir_cf_node *node)
{
nir_function_impl *impl = nir_cf_node_get_function(node);
- impl->block_index_dirty = true;
+ nir_metadata_preserve(impl, nir_metadata_none);
if (node->type == nir_cf_node_block) {
/*
exec_node_remove(&node->node);
stitch_blocks(before_block, after_block);
}
+
+ cleanup_cf_node(node);
}
static bool
add_use_cb(nir_src *src, void *state)
{
- nir_instr *instr = (nir_instr *) state;
-
- if (src->is_ssa)
- return true;
+ nir_instr *instr = state;
- nir_register *reg = src->reg.reg;
-
- _mesa_set_add(reg->uses, _mesa_hash_pointer(instr), instr);
+ src->parent_instr = instr;
+ list_addtail(&src->use_link,
+ src->is_ssa ? &src->ssa->uses : &src->reg.reg->uses);
return true;
}
static bool
-add_def_cb(nir_dest *dest, void *state)
+add_ssa_def_cb(nir_ssa_def *def, void *state)
{
- nir_instr *instr = (nir_instr *) state;
+ nir_instr *instr = state;
- if (dest->is_ssa)
- return true;
+ if (instr->block && def->index == UINT_MAX) {
+ nir_function_impl *impl =
+ nir_cf_node_get_function(&instr->block->cf_node);
+
+ def->index = impl->ssa_alloc++;
+ }
+
+ return true;
+}
- nir_register *reg = dest->reg.reg;
+static bool
+add_reg_def_cb(nir_dest *dest, void *state)
+{
+ nir_instr *instr = state;
- _mesa_set_add(reg->defs, _mesa_hash_pointer(instr), instr);
+ if (!dest->is_ssa) {
+ dest->reg.parent_instr = instr;
+ list_addtail(&dest->reg.def_link, &dest->reg.reg->defs);
+ }
return true;
}
add_defs_uses(nir_instr *instr)
{
nir_foreach_src(instr, add_use_cb, instr);
- nir_foreach_dest(instr, add_def_cb, instr);
+ nir_foreach_dest(instr, add_reg_def_cb, instr);
+ nir_foreach_ssa_def(instr, add_ssa_def_cb, instr);
}
void
void
nir_instr_insert_after_cf(nir_cf_node *node, nir_instr *after)
{
- if (node->type == nir_cf_node_block) {
+ if (node->type == nir_cf_node_block) {
nir_instr_insert_after_block(nir_cf_node_as_block(node), after);
} else {
nir_cf_node *next = nir_cf_node_next(node);
static bool
remove_use_cb(nir_src *src, void *state)
{
- nir_instr *instr = (nir_instr *) state;
-
- if (src->is_ssa)
- return true;
-
- nir_register *reg = src->reg.reg;
-
- struct set_entry *entry = _mesa_set_search(reg->uses,
- _mesa_hash_pointer(instr),
- instr);
- if (entry)
- _mesa_set_remove(reg->uses, entry);
+ list_del(&src->use_link);
return true;
}
static bool
remove_def_cb(nir_dest *dest, void *state)
{
- nir_instr *instr = (nir_instr *) state;
-
- if (dest->is_ssa)
- return true;
-
- nir_register *reg = dest->reg.reg;
-
- struct set_entry *entry = _mesa_set_search(reg->defs,
- _mesa_hash_pointer(instr),
- instr);
- if (entry)
- _mesa_set_remove(reg->defs, entry);
+ if (!dest->is_ssa)
+ list_del(&dest->reg.def_link);
return true;
}
foreach_list_typed(nir_register, reg, node, &impl->registers) {
reg->index = index++;
}
+ impl->reg_alloc = index;
}
void
foreach_list_typed(nir_register, reg, node, &shader->registers) {
reg->index = index++;
}
+ shader->reg_alloc = index;
}
static bool
}
static bool
-visit_load_const_dest(nir_load_const_instr *instr, nir_foreach_dest_cb cb,
- void *state)
+visit_phi_dest(nir_phi_instr *instr, nir_foreach_dest_cb cb, void *state)
{
return cb(&instr->dest, state);
}
static bool
-visit_phi_dest(nir_phi_instr *instr, nir_foreach_dest_cb cb, void *state)
+visit_parallel_copy_dest(nir_parallel_copy_instr *instr,
+ nir_foreach_dest_cb cb, void *state)
{
- return cb(&instr->dest, state);
+ nir_foreach_parallel_copy_entry(instr, entry) {
+ if (!cb(&entry->dest, state))
+ return false;
+ }
+
+ return true;
}
bool
return visit_alu_dest(nir_instr_as_alu(instr), cb, state);
case nir_instr_type_intrinsic:
return visit_intrinsic_dest(nir_instr_as_intrinsic(instr), cb, state);
- case nir_instr_type_texture:
- return visit_texture_dest(nir_instr_as_texture(instr), cb, state);
- case nir_instr_type_load_const:
- return visit_load_const_dest(nir_instr_as_load_const(instr), cb, state);
+ case nir_instr_type_tex:
+ return visit_texture_dest(nir_instr_as_tex(instr), cb, state);
case nir_instr_type_phi:
return visit_phi_dest(nir_instr_as_phi(instr), cb, state);
- break;
+ case nir_instr_type_parallel_copy:
+ return visit_parallel_copy_dest(nir_instr_as_parallel_copy(instr),
+ cb, state);
+ case nir_instr_type_load_const:
case nir_instr_type_ssa_undef:
case nir_instr_type_call:
case nir_instr_type_jump:
return true;
}
+struct foreach_ssa_def_state {
+ nir_foreach_ssa_def_cb cb;
+ void *client_state;
+};
+
+static inline bool
+nir_ssa_def_visitor(nir_dest *dest, void *void_state)
+{
+ struct foreach_ssa_def_state *state = void_state;
+
+ if (dest->is_ssa)
+ return state->cb(&dest->ssa, state->client_state);
+ else
+ return true;
+}
+
+bool
+nir_foreach_ssa_def(nir_instr *instr, nir_foreach_ssa_def_cb cb, void *state)
+{
+ switch (instr->type) {
+ case nir_instr_type_alu:
+ case nir_instr_type_tex:
+ case nir_instr_type_intrinsic:
+ case nir_instr_type_phi:
+ case nir_instr_type_parallel_copy: {
+ struct foreach_ssa_def_state foreach_state = {cb, state};
+ return nir_foreach_dest(instr, nir_ssa_def_visitor, &foreach_state);
+ }
+
+ case nir_instr_type_load_const:
+ return cb(&nir_instr_as_load_const(instr)->def, state);
+ case nir_instr_type_ssa_undef:
+ return cb(&nir_instr_as_ssa_undef(instr)->def, state);
+ case nir_instr_type_call:
+ case nir_instr_type_jump:
+ return true;
+ default:
+ unreachable("Invalid instruction type");
+ }
+}
+
static bool
visit_src(nir_src *src, nir_foreach_src_cb cb, void *state)
{
visit_deref_array_src(nir_deref_array *deref, nir_foreach_src_cb cb,
void *state)
{
- if (deref->has_indirect)
+ if (deref->deref_array_type == nir_deref_array_type_indirect)
return visit_src(&deref->indirect, cb, state);
return true;
}
if (!visit_src(&instr->src[i].src, cb, state))
return false;
- if (instr->has_predicate)
- if (!visit_src(&instr->predicate, cb, state))
- return false;
-
return true;
}
visit_tex_src(nir_tex_instr *instr, nir_foreach_src_cb cb, void *state)
{
for (unsigned i = 0; i < instr->num_srcs; i++)
- if (!visit_src(&instr->src[i], cb, state))
- return false;
-
- if (instr->has_predicate)
- if (!visit_src(&instr->predicate, cb, state))
+ if (!visit_src(&instr->src[i].src, cb, state))
return false;
if (instr->sampler != NULL)
if (!visit_deref_src(instr->variables[i], cb, state))
return false;
- if (instr->has_predicate)
- if (!visit_src(&instr->predicate, cb, state))
- return false;
-
return true;
}
static bool
visit_call_src(nir_call_instr *instr, nir_foreach_src_cb cb, void *state)
{
- if (instr->has_predicate)
- if (!visit_src(&instr->predicate, cb, state))
- return false;
-
return true;
}
visit_load_const_src(nir_load_const_instr *instr, nir_foreach_src_cb cb,
void *state)
{
- if (instr->has_predicate)
- if (!visit_src(&instr->predicate, cb, state))
- return false;
-
return true;
}
static bool
visit_phi_src(nir_phi_instr *instr, nir_foreach_src_cb cb, void *state)
{
- foreach_list_typed(nir_phi_src, src, node, &instr->srcs) {
+ nir_foreach_phi_src(instr, src) {
if (!visit_src(&src->src, cb, state))
return false;
}
return true;
}
+static bool
+visit_parallel_copy_src(nir_parallel_copy_instr *instr,
+ nir_foreach_src_cb cb, void *state)
+{
+ nir_foreach_parallel_copy_entry(instr, entry) {
+ if (!visit_src(&entry->src, cb, state))
+ return false;
+ }
+
+ return true;
+}
+
typedef struct {
void *state;
nir_foreach_src_cb cb;
if (!visit_intrinsic_src(nir_instr_as_intrinsic(instr), cb, state))
return false;
break;
- case nir_instr_type_texture:
- if (!visit_tex_src(nir_instr_as_texture(instr), cb, state))
+ case nir_instr_type_tex:
+ if (!visit_tex_src(nir_instr_as_tex(instr), cb, state))
return false;
break;
case nir_instr_type_call:
if (!visit_phi_src(nir_instr_as_phi(instr), cb, state))
return false;
break;
+ case nir_instr_type_parallel_copy:
+ if (!visit_parallel_copy_src(nir_instr_as_parallel_copy(instr),
+ cb, state))
+ return false;
+ break;
case nir_instr_type_jump:
case nir_instr_type_ssa_undef:
return true;
return nir_foreach_dest(instr, visit_dest_indirect, &dest_state);
}
+nir_const_value *
+nir_src_as_const_value(nir_src src)
+{
+ if (!src.is_ssa)
+ return NULL;
-static bool foreach_cf_node(nir_cf_node *node, nir_foreach_block_cb cb,
- void *state);
+ if (src.ssa->parent_instr->type != nir_instr_type_load_const)
+ return NULL;
-static bool
-foreach_block(nir_block *block, nir_foreach_block_cb cb, void *state)
+ nir_load_const_instr *load = nir_instr_as_load_const(src.ssa->parent_instr);
+
+ return &load->value;
+}
+
+bool
+nir_srcs_equal(nir_src src1, nir_src src2)
{
- return cb(block, state);
+ if (src1.is_ssa) {
+ if (src2.is_ssa) {
+ return src1.ssa == src2.ssa;
+ } else {
+ return false;
+ }
+ } else {
+ if (src2.is_ssa) {
+ return false;
+ } else {
+ if ((src1.reg.indirect == NULL) != (src2.reg.indirect == NULL))
+ return false;
+
+ if (src1.reg.indirect) {
+ if (!nir_srcs_equal(*src1.reg.indirect, *src2.reg.indirect))
+ return false;
+ }
+
+ return src1.reg.reg == src2.reg.reg &&
+ src1.reg.base_offset == src2.reg.base_offset;
+ }
+ }
}
static bool
-foreach_if(nir_if *if_stmt, nir_foreach_block_cb cb, void *state)
+src_is_valid(const nir_src *src)
{
- foreach_list_typed(nir_cf_node, node, node, &if_stmt->then_list) {
- if (!foreach_cf_node(node, cb, state))
- return false;
+ return src->is_ssa ? (src->ssa != NULL) : (src->reg.reg != NULL);
+}
+
+static void
+src_remove_all_uses(nir_src *src)
+{
+ for (; src; src = src->is_ssa ? NULL : src->reg.indirect) {
+ if (!src_is_valid(src))
+ continue;
+
+ list_del(&src->use_link);
}
+}
- foreach_list_typed(nir_cf_node, node, node, &if_stmt->else_list) {
- if (!foreach_cf_node(node, cb, state))
- return false;
+static void
+src_add_all_uses(nir_src *src, nir_instr *parent_instr, nir_if *parent_if)
+{
+ for (; src; src = src->is_ssa ? NULL : src->reg.indirect) {
+ if (!src_is_valid(src))
+ continue;
+
+ if (parent_instr) {
+ src->parent_instr = parent_instr;
+ if (src->is_ssa)
+ list_addtail(&src->use_link, &src->ssa->uses);
+ else
+ list_addtail(&src->use_link, &src->reg.reg->uses);
+ } else {
+ assert(parent_if);
+ src->parent_if = parent_if;
+ if (src->is_ssa)
+ list_addtail(&src->use_link, &src->ssa->if_uses);
+ else
+ list_addtail(&src->use_link, &src->reg.reg->if_uses);
+ }
+ }
+}
+
+void
+nir_instr_rewrite_src(nir_instr *instr, nir_src *src, nir_src new_src)
+{
+ assert(!src_is_valid(src) || src->parent_instr == instr);
+
+ src_remove_all_uses(src);
+ *src = new_src;
+ src_add_all_uses(src, instr, NULL);
+}
+
+void
+nir_instr_move_src(nir_instr *dest_instr, nir_src *dest, nir_src *src)
+{
+ assert(!src_is_valid(dest) || dest->parent_instr == dest_instr);
+
+ src_remove_all_uses(dest);
+ src_remove_all_uses(src);
+ *dest = *src;
+ *src = NIR_SRC_INIT;
+ src_add_all_uses(dest, dest_instr, NULL);
+}
+
+void
+nir_if_rewrite_condition(nir_if *if_stmt, nir_src new_src)
+{
+ nir_src *src = &if_stmt->condition;
+ assert(!src_is_valid(src) || src->parent_if == if_stmt);
+
+ src_remove_all_uses(src);
+ *src = new_src;
+ src_add_all_uses(src, NULL, if_stmt);
+}
+
+void
+nir_ssa_def_init(nir_instr *instr, nir_ssa_def *def,
+ unsigned num_components, const char *name)
+{
+ def->name = name;
+ def->parent_instr = instr;
+ list_inithead(&def->uses);
+ list_inithead(&def->if_uses);
+ def->num_components = num_components;
+
+ if (instr->block) {
+ nir_function_impl *impl =
+ nir_cf_node_get_function(&instr->block->cf_node);
+
+ def->index = impl->ssa_alloc++;
+ } else {
+ def->index = UINT_MAX;
+ }
+}
+
+void
+nir_ssa_dest_init(nir_instr *instr, nir_dest *dest,
+ unsigned num_components, const char *name)
+{
+ dest->is_ssa = true;
+ nir_ssa_def_init(instr, &dest->ssa, num_components, name);
+}
+
+void
+nir_ssa_def_rewrite_uses(nir_ssa_def *def, nir_src new_src, void *mem_ctx)
+{
+ assert(!new_src.is_ssa || def != new_src.ssa);
+
+ nir_foreach_use_safe(def, use_src) {
+ nir_instr *src_parent_instr = use_src->parent_instr;
+ list_del(&use_src->use_link);
+ nir_src_copy(use_src, &new_src, mem_ctx);
+ src_add_all_uses(use_src, src_parent_instr, NULL);
+ }
+
+ nir_foreach_if_use_safe(def, use_src) {
+ nir_if *src_parent_if = use_src->parent_if;
+ list_del(&use_src->use_link);
+ nir_src_copy(use_src, &new_src, mem_ctx);
+ src_add_all_uses(use_src, NULL, src_parent_if);
+ }
+}
+
+
+static bool foreach_cf_node(nir_cf_node *node, nir_foreach_block_cb cb,
+ bool reverse, void *state);
+
+static inline bool
+foreach_if(nir_if *if_stmt, nir_foreach_block_cb cb, bool reverse, void *state)
+{
+ if (reverse) {
+ foreach_list_typed_safe_reverse(nir_cf_node, node, node,
+ &if_stmt->else_list) {
+ if (!foreach_cf_node(node, cb, reverse, state))
+ return false;
+ }
+
+ foreach_list_typed_safe_reverse(nir_cf_node, node, node,
+ &if_stmt->then_list) {
+ if (!foreach_cf_node(node, cb, reverse, state))
+ return false;
+ }
+ } else {
+ foreach_list_typed_safe(nir_cf_node, node, node, &if_stmt->then_list) {
+ if (!foreach_cf_node(node, cb, reverse, state))
+ return false;
+ }
+
+ foreach_list_typed_safe(nir_cf_node, node, node, &if_stmt->else_list) {
+ if (!foreach_cf_node(node, cb, reverse, state))
+ return false;
+ }
}
return true;
}
-static bool
-foreach_loop(nir_loop *loop, nir_foreach_block_cb cb, void *state)
+static inline bool
+foreach_loop(nir_loop *loop, nir_foreach_block_cb cb, bool reverse, void *state)
{
- foreach_list_typed(nir_cf_node, node, node, &loop->body) {
- if (!foreach_cf_node(node, cb, state))
- return false;
+ if (reverse) {
+ foreach_list_typed_safe_reverse(nir_cf_node, node, node, &loop->body) {
+ if (!foreach_cf_node(node, cb, reverse, state))
+ return false;
+ }
+ } else {
+ foreach_list_typed_safe(nir_cf_node, node, node, &loop->body) {
+ if (!foreach_cf_node(node, cb, reverse, state))
+ return false;
+ }
}
return true;
}
static bool
-foreach_cf_node(nir_cf_node *node, nir_foreach_block_cb cb, void *state)
+foreach_cf_node(nir_cf_node *node, nir_foreach_block_cb cb,
+ bool reverse, void *state)
{
switch (node->type) {
case nir_cf_node_block:
- return foreach_block(nir_cf_node_as_block(node), cb, state);
+ return cb(nir_cf_node_as_block(node), state);
case nir_cf_node_if:
- return foreach_if(nir_cf_node_as_if(node), cb, state);
+ return foreach_if(nir_cf_node_as_if(node), cb, reverse, state);
case nir_cf_node_loop:
- return foreach_loop(nir_cf_node_as_loop(node), cb, state);
+ return foreach_loop(nir_cf_node_as_loop(node), cb, reverse, state);
break;
default:
bool
nir_foreach_block(nir_function_impl *impl, nir_foreach_block_cb cb, void *state)
{
- foreach_list_typed(nir_cf_node, node, node, &impl->body) {
- if (!foreach_cf_node(node, cb, state))
+ foreach_list_typed_safe(nir_cf_node, node, node, &impl->body) {
+ if (!foreach_cf_node(node, cb, false, state))
return false;
}
- cb(impl->end_block, state);
+ return cb(impl->end_block, state);
+}
+
+bool
+nir_foreach_block_reverse(nir_function_impl *impl, nir_foreach_block_cb cb,
+ void *state)
+{
+ if (!cb(impl->end_block, state))
+ return false;
+
+ foreach_list_typed_safe_reverse(nir_cf_node, node, node, &impl->body) {
+ if (!foreach_cf_node(node, cb, true, state))
+ return false;
+ }
return true;
}
+nir_if *
+nir_block_get_following_if(nir_block *block)
+{
+ if (exec_node_is_tail_sentinel(&block->cf_node.node))
+ return NULL;
+
+ if (nir_cf_node_is_last(&block->cf_node))
+ return NULL;
+
+ nir_cf_node *next_node = nir_cf_node_next(&block->cf_node);
+
+ if (next_node->type != nir_cf_node_if)
+ return NULL;
+
+ return nir_cf_node_as_if(next_node);
+}
+
static bool
index_block(nir_block *block, void *state)
{
- unsigned *index = (unsigned *) state;
+ unsigned *index = state;
block->index = (*index)++;
return true;
}
{
unsigned index = 0;
- if (!impl->block_index_dirty)
+ if (impl->valid_metadata & nir_metadata_block_index)
return;
nir_foreach_block(impl, index_block, &index);
impl->num_blocks = index;
- impl->block_index_dirty = false;
-}
-
-static void
-index_ssa_def(nir_ssa_def *def, unsigned *index)
-{
- def->index = (*index)++;
}
static bool
-index_ssa_def_cb(nir_dest *dest, void *state)
+index_ssa_def_cb(nir_ssa_def *def, void *state)
{
unsigned *index = (unsigned *) state;
- if (dest->is_ssa)
- index_ssa_def(&dest->ssa, index);
- return true;
-}
+ def->index = (*index)++;
-static void
-index_ssa_undef(nir_ssa_undef_instr *instr, unsigned *index)
-{
- index_ssa_def(&instr->def, index);
+ return true;
}
static bool
index_ssa_block(nir_block *block, void *state)
{
- unsigned *index = (unsigned *) state;
-
- nir_foreach_instr(block, instr) {
- if (instr->type == nir_instr_type_ssa_undef)
- index_ssa_undef(nir_instr_as_ssa_undef(instr), index);
- else
- nir_foreach_dest(instr, index_ssa_def_cb, state);
- }
+ nir_foreach_instr(block, instr)
+ nir_foreach_ssa_def(instr, index_ssa_def_cb, state);
return true;
}
{
unsigned index = 0;
nir_foreach_block(impl, index_ssa_block, &index);
+ impl->ssa_alloc = index;
}
projects / mesa.git / blobdiff