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

nir: Delete most of the constant_initializer support

Browse Source 
Constant initializers have been a constant (ha!) pain for quite some time.
While they're useful from a language perspective, people writing passes or
backends really don't want deal with them most of the time.  This commit
removes most of the constant initializer support from NIR.  It is expected
that you call nir_lower_constant_initializers VERY EARLY to ensure that
they're gone before you do anything interesting.

Reviewed-by: Iago Toral Quiroga <itoral@igalia.com>
This commit is contained in:
Jason Ekstrand
2016-07-15 17:17:40 -07:00
parent 2f19c19b5d
commit 50e0b0bee3
5 changed files with 12 additions and 146 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/compiler/nir/nir_inline_functions.c
+2 -40
View File
@@ -25,20 +25,6 @@
#include "nir_builder.h"
#include "nir_control_flow.h"
static bool
deref_apply_constant_initializer(nir_deref_var *deref, void *state)
{
struct nir_builder *b = state;
nir_load_const_instr *initializer =
nir_deref_get_const_initializer_load(b->shader, deref);
nir_builder_instr_insert(b, &initializer->instr);
nir_store_deref_var(b, deref, &initializer->def, 0xf);
return true;
}
static bool inline_function_impl(nir_function_impl *impl, struct set *inlined);
static void
@@ -188,35 +174,11 @@ inline_functions_block(nir_block *block, nir_builder *b,
/* Add copies of all in parameters */
assert(call->num_params == callee_copy->num_params);
b->cursor = nir_before_instr(&call->instr);
/* Before we insert the copy of the function, we need to lower away
* constant initializers on local variables. This is because constant
* initializers happen (effectively) at the top of the function and,
* since these are about to become locals of the calling function,
* initialization will happen at the top of the caller rather than at
* the top of the callee. This isn't usually a problem, but if we are
* being inlined inside of a loop, it can result in the variable not
* getting re-initialized properly for all loop iterations.
*/
nir_foreach_variable(local, &callee_copy->locals) {
if (!local->constant_initializer)
continue;
nir_deref_var deref;
deref.deref.deref_type = nir_deref_type_var,
deref.deref.child = NULL;
deref.deref.type = local->type,
deref.var = local;
nir_deref_foreach_leaf(&deref, deref_apply_constant_initializer, b);
local->constant_initializer = NULL;
}
exec_list_append(&b->impl->locals, &callee_copy->locals);
exec_list_append(&b->impl->registers, &callee_copy->registers);
b->cursor = nir_before_instr(&call->instr);
/* We now need to tie the two functions together using the
* parameters. There are two ways we do this: One is to turn the
* parameter into a local variable and do a shadow-copy. The other