[Mesa-dev] [PATCH 01/12] nir: Get rid of function overloads
Rob Clark
robdclark at gmail.com
Mon Dec 28 07:02:13 PST 2015
On Sat, Dec 26, 2015 at 2:09 PM, Jason Ekstrand <jason at jlekstrand.net> wrote:
> When Connor originally drafted NIR, he copied the same function+overload
> system that GLSL IR had with a few names changed. However, this
> double-indirection is not really needed and has only served to confuse
> people. Instead, let's just have functions which may not have unique names
> and may or may not have an implementation. If someone wants to do overload
> resolving, they can hav a hash table based function+overload system in the
> overload resolving pass. There's no good reason to keep it in core NIR.
I always kinda wondered what was the point of the double indirection..
the freedreno/ir3 parts are r-b.. I'll look more closely at the rest
if you want, but it sounds like a fairly mechanical conversion
BR,
-R
> ---
> src/gallium/auxiliary/nir/tgsi_to_nir.c | 3 +-
> .../drivers/freedreno/ir3/ir3_compiler_nir.c | 8 ++--
> .../drivers/freedreno/ir3/ir3_nir_lower_if_else.c | 6 +--
> src/gallium/drivers/vc4/vc4_nir_lower_blend.c | 8 ++--
> src/gallium/drivers/vc4/vc4_nir_lower_io.c | 6 +--
> src/gallium/drivers/vc4/vc4_nir_lower_txf_ms.c | 6 +--
> src/gallium/drivers/vc4/vc4_program.c | 14 +++---
> src/glsl/nir/glsl_to_nir.cpp | 51 +++++++++-------------
> src/glsl/nir/nir.c | 38 +++++-----------
> src/glsl/nir/nir.h | 46 +++++++------------
> src/glsl/nir/nir_algebraic.py | 6 +--
> src/glsl/nir/nir_builder.h | 2 +-
> src/glsl/nir/nir_clone.c | 50 ++++++++-------------
> src/glsl/nir/nir_dominance.c | 28 ++++++------
> src/glsl/nir/nir_from_ssa.c | 6 +--
> src/glsl/nir/nir_gs_count_vertices.c | 6 +--
> src/glsl/nir/nir_lower_alu_to_scalar.c | 6 +--
> src/glsl/nir/nir_lower_atomics.c | 8 ++--
> src/glsl/nir/nir_lower_clip.c | 18 ++++----
> src/glsl/nir/nir_lower_global_vars_to_local.c | 8 ++--
> src/glsl/nir/nir_lower_gs_intrinsics.c | 12 ++---
> src/glsl/nir/nir_lower_idiv.c | 6 +--
> src/glsl/nir/nir_lower_io.c | 6 +--
> src/glsl/nir/nir_lower_load_const_to_scalar.c | 6 +--
> src/glsl/nir/nir_lower_locals_to_regs.c | 8 ++--
> src/glsl/nir/nir_lower_outputs_to_temporaries.c | 12 ++---
> src/glsl/nir/nir_lower_phis_to_scalar.c | 6 +--
> src/glsl/nir/nir_lower_samplers.c | 6 +--
> src/glsl/nir/nir_lower_system_values.c | 6 +--
> src/glsl/nir/nir_lower_tex.c | 6 +--
> src/glsl/nir/nir_lower_to_source_mods.c | 6 +--
> src/glsl/nir/nir_lower_two_sided_color.c | 6 +--
> src/glsl/nir/nir_lower_var_copies.c | 6 +--
> src/glsl/nir/nir_lower_vars_to_ssa.c | 8 ++--
> src/glsl/nir/nir_lower_vec_to_movs.c | 8 ++--
> src/glsl/nir/nir_metadata.c | 12 ++---
> src/glsl/nir/nir_move_vec_src_uses_to_dest.c | 6 +--
> src/glsl/nir/nir_normalize_cubemap_coords.c | 6 +--
> src/glsl/nir/nir_opt_constant_folding.c | 6 +--
> src/glsl/nir/nir_opt_copy_propagate.c | 4 +-
> src/glsl/nir/nir_opt_cse.c | 6 +--
> src/glsl/nir/nir_opt_dce.c | 4 +-
> src/glsl/nir/nir_opt_dead_cf.c | 6 +--
> src/glsl/nir/nir_opt_gcm.c | 6 +--
> src/glsl/nir/nir_opt_peephole_select.c | 6 +--
> src/glsl/nir/nir_opt_remove_phis.c | 6 +--
> src/glsl/nir/nir_opt_undef.c | 8 ++--
> src/glsl/nir/nir_print.c | 33 +++++---------
> src/glsl/nir/nir_remove_dead_variables.c | 14 +++---
> src/glsl/nir/nir_split_var_copies.c | 6 +--
> src/glsl/nir/nir_sweep.c | 9 ++--
> src/glsl/nir/nir_to_ssa.c | 6 +--
> src/glsl/nir/nir_validate.c | 25 ++++-------
> src/mesa/drivers/dri/i965/brw_fs_nir.cpp | 16 +++----
> src/mesa/drivers/dri/i965/brw_nir.c | 50 ++++++++++-----------
> .../dri/i965/brw_nir_analyze_boolean_resolves.c | 7 +--
> .../drivers/dri/i965/brw_nir_opt_peephole_ffma.c | 6 +--
> src/mesa/drivers/dri/i965/brw_vec4_nir.cpp | 16 +++----
> src/mesa/program/prog_to_nir.c | 3 +-
> 59 files changed, 313 insertions(+), 386 deletions(-)
>
> diff --git a/src/gallium/auxiliary/nir/tgsi_to_nir.c b/src/gallium/auxiliary/nir/tgsi_to_nir.c
> index 2cb723c..01426e8 100644
> --- a/src/gallium/auxiliary/nir/tgsi_to_nir.c
> +++ b/src/gallium/auxiliary/nir/tgsi_to_nir.c
> @@ -1972,8 +1972,7 @@ tgsi_to_nir(const void *tgsi_tokens,
> options);
>
> nir_function *func = nir_function_create(s, "main");
> - nir_function_overload *overload = nir_function_overload_create(func);
> - nir_function_impl *impl = nir_function_impl_create(overload);
> + nir_function_impl *impl = nir_function_impl_create(func);
>
> nir_builder_init(&c->build, impl);
> c->build.cursor = nir_after_cf_list(&impl->body);
> diff --git a/src/gallium/drivers/freedreno/ir3/ir3_compiler_nir.c b/src/gallium/drivers/freedreno/ir3/ir3_compiler_nir.c
> index 44c74b8..224f780 100644
> --- a/src/gallium/drivers/freedreno/ir3/ir3_compiler_nir.c
> +++ b/src/gallium/drivers/freedreno/ir3/ir3_compiler_nir.c
> @@ -2351,10 +2351,10 @@ emit_instructions(struct ir3_compile *ctx)
> nir_function_impl *fxn = NULL;
>
> /* Find the main function: */
> - nir_foreach_overload(ctx->s, overload) {
> - compile_assert(ctx, strcmp(overload->function->name, "main") == 0);
> - compile_assert(ctx, overload->impl);
> - fxn = overload->impl;
> + nir_foreach_function(ctx->s, function) {
> + compile_assert(ctx, strcmp(function->name, "main") == 0);
> + compile_assert(ctx, function->impl);
> + fxn = function->impl;
> break;
> }
>
> diff --git a/src/gallium/drivers/freedreno/ir3/ir3_nir_lower_if_else.c b/src/gallium/drivers/freedreno/ir3/ir3_nir_lower_if_else.c
> index 4ec0e2b..6eee2eb 100644
> --- a/src/gallium/drivers/freedreno/ir3/ir3_nir_lower_if_else.c
> +++ b/src/gallium/drivers/freedreno/ir3/ir3_nir_lower_if_else.c
> @@ -328,9 +328,9 @@ ir3_nir_lower_if_else(nir_shader *shader)
> {
> bool progress = false;
>
> - nir_foreach_overload(shader, overload) {
> - if (overload->impl)
> - progress |= lower_if_else_impl(overload->impl);
> + nir_foreach_function(shader, function) {
> + if (function->impl)
> + progress |= lower_if_else_impl(function->impl);
> }
>
> return progress;
> diff --git a/src/gallium/drivers/vc4/vc4_nir_lower_blend.c b/src/gallium/drivers/vc4/vc4_nir_lower_blend.c
> index a1ec4c7..6d9a624 100644
> --- a/src/gallium/drivers/vc4/vc4_nir_lower_blend.c
> +++ b/src/gallium/drivers/vc4/vc4_nir_lower_blend.c
> @@ -712,12 +712,12 @@ vc4_nir_lower_blend_block(nir_block *block, void *state)
> void
> vc4_nir_lower_blend(struct vc4_compile *c)
> {
> - nir_foreach_overload(c->s, overload) {
> - if (overload->impl) {
> - nir_foreach_block(overload->impl,
> + nir_foreach_function(c->s, function) {
> + if (function->impl) {
> + nir_foreach_block(function->impl,
> vc4_nir_lower_blend_block, c);
>
> - nir_metadata_preserve(overload->impl,
> + nir_metadata_preserve(function->impl,
> nir_metadata_block_index |
> nir_metadata_dominance);
> }
> diff --git a/src/gallium/drivers/vc4/vc4_nir_lower_io.c b/src/gallium/drivers/vc4/vc4_nir_lower_io.c
> index 465b288..bf6631e 100644
> --- a/src/gallium/drivers/vc4/vc4_nir_lower_io.c
> +++ b/src/gallium/drivers/vc4/vc4_nir_lower_io.c
> @@ -467,8 +467,8 @@ vc4_nir_lower_io_impl(struct vc4_compile *c, nir_function_impl *impl)
> void
> vc4_nir_lower_io(struct vc4_compile *c)
> {
> - nir_foreach_overload(c->s, overload) {
> - if (overload->impl)
> - vc4_nir_lower_io_impl(c, overload->impl);
> + nir_foreach_function(c->s, function) {
> + if (function->impl)
> + vc4_nir_lower_io_impl(c, function->impl);
> }
> }
> diff --git a/src/gallium/drivers/vc4/vc4_nir_lower_txf_ms.c b/src/gallium/drivers/vc4/vc4_nir_lower_txf_ms.c
> index 54873e6..2490819 100644
> --- a/src/gallium/drivers/vc4/vc4_nir_lower_txf_ms.c
> +++ b/src/gallium/drivers/vc4/vc4_nir_lower_txf_ms.c
> @@ -165,8 +165,8 @@ vc4_nir_lower_txf_ms_impl(struct vc4_compile *c, nir_function_impl *impl)
> void
> vc4_nir_lower_txf_ms(struct vc4_compile *c)
> {
> - nir_foreach_overload(c->s, overload) {
> - if (overload->impl)
> - vc4_nir_lower_txf_ms_impl(c, overload->impl);
> + nir_foreach_function(c->s, function) {
> + if (function->impl)
> + vc4_nir_lower_txf_ms_impl(c, function->impl);
> }
> }
> diff --git a/src/gallium/drivers/vc4/vc4_program.c b/src/gallium/drivers/vc4/vc4_program.c
> index d11c4e3..da0d211 100644
> --- a/src/gallium/drivers/vc4/vc4_program.c
> +++ b/src/gallium/drivers/vc4/vc4_program.c
> @@ -1705,10 +1705,10 @@ nir_to_qir(struct vc4_compile *c)
> ntq_setup_registers(c, &c->s->registers);
>
> /* Find the main function and emit the body. */
> - nir_foreach_overload(c->s, overload) {
> - assert(strcmp(overload->function->name, "main") == 0);
> - assert(overload->impl);
> - ntq_emit_impl(c, overload->impl);
> + nir_foreach_function(c->s, function) {
> + assert(strcmp(function->name, "main") == 0);
> + assert(function->impl);
> + ntq_emit_impl(c, function->impl);
> }
> }
>
> @@ -1735,10 +1735,10 @@ static int
> count_nir_instrs(nir_shader *nir)
> {
> int count = 0;
> - nir_foreach_overload(nir, overload) {
> - if (!overload->impl)
> + nir_foreach_function(nir, function) {
> + if (!function->impl)
> continue;
> - nir_foreach_block(overload->impl, count_nir_instrs_in_block, &count);
> + nir_foreach_block(function->impl, count_nir_instrs_in_block, &count);
> }
> return count;
> }
> diff --git a/src/glsl/nir/glsl_to_nir.cpp b/src/glsl/nir/glsl_to_nir.cpp
> index 0f0f4a1..0d1d0f4 100644
> --- a/src/glsl/nir/glsl_to_nir.cpp
> +++ b/src/glsl/nir/glsl_to_nir.cpp
> @@ -70,10 +70,9 @@ public:
> virtual void visit(ir_dereference_array *);
> virtual void visit(ir_barrier *);
>
> - void create_function(ir_function *ir);
> + void create_function(ir_function_signature *ir);
>
> private:
> - void create_overload(ir_function_signature *ir, nir_function *function);
> void add_instr(nir_instr *instr, unsigned num_components);
> nir_ssa_def *evaluate_rvalue(ir_rvalue *ir);
>
> @@ -430,60 +429,50 @@ nir_visitor::visit(ir_variable *ir)
> ir_visitor_status
> nir_function_visitor::visit_enter(ir_function *ir)
> {
> - visitor->create_function(ir);
> - return visit_continue_with_parent;
> -}
> -
> -
> -void
> -nir_visitor::create_function(ir_function *ir)
> -{
> - nir_function *func = nir_function_create(this->shader, ir->name);
> foreach_in_list(ir_function_signature, sig, &ir->signatures) {
> - create_overload(sig, func);
> + visitor->create_function(sig);
> }
> + return visit_continue_with_parent;
> }
>
> -
> -
> void
> -nir_visitor::create_overload(ir_function_signature *ir, nir_function *function)
> +nir_visitor::create_function(ir_function_signature *ir)
> {
> if (ir->is_intrinsic)
> return;
>
> - nir_function_overload *overload = nir_function_overload_create(function);
> + nir_function *func = nir_function_create(shader, ir->function_name());
>
> unsigned num_params = ir->parameters.length();
> - overload->num_params = num_params;
> - overload->params = ralloc_array(shader, nir_parameter, num_params);
> + func->num_params = num_params;
> + func->params = ralloc_array(shader, nir_parameter, num_params);
>
> unsigned i = 0;
> foreach_in_list(ir_variable, param, &ir->parameters) {
> switch (param->data.mode) {
> case ir_var_function_in:
> - overload->params[i].param_type = nir_parameter_in;
> + func->params[i].param_type = nir_parameter_in;
> break;
>
> case ir_var_function_out:
> - overload->params[i].param_type = nir_parameter_out;
> + func->params[i].param_type = nir_parameter_out;
> break;
>
> case ir_var_function_inout:
> - overload->params[i].param_type = nir_parameter_inout;
> + func->params[i].param_type = nir_parameter_inout;
> break;
>
> default:
> unreachable("not reached");
> }
>
> - overload->params[i].type = param->type;
> + func->params[i].type = param->type;
> i++;
> }
>
> - overload->return_type = ir->return_type;
> + func->return_type = ir->return_type;
>
> - _mesa_hash_table_insert(this->overload_table, ir, overload);
> + _mesa_hash_table_insert(this->overload_table, ir, func);
> }
>
> void
> @@ -503,13 +492,13 @@ nir_visitor::visit(ir_function_signature *ir)
> _mesa_hash_table_search(this->overload_table, ir);
>
> assert(entry);
> - nir_function_overload *overload = (nir_function_overload *) entry->data;
> + nir_function *func = (nir_function *) entry->data;
>
> if (ir->is_defined) {
> - nir_function_impl *impl = nir_function_impl_create(overload);
> + nir_function_impl *impl = nir_function_impl_create(func);
> this->impl = impl;
>
> - unsigned num_params = overload->num_params;
> + unsigned num_params = func->num_params;
> impl->num_params = num_params;
> impl->params = ralloc_array(this->shader, nir_variable *, num_params);
> unsigned i = 0;
> @@ -519,13 +508,13 @@ nir_visitor::visit(ir_function_signature *ir)
> i++;
> }
>
> - if (overload->return_type == glsl_type::void_type) {
> + if (func->return_type == glsl_type::void_type) {
> impl->return_var = NULL;
> } else {
> impl->return_var = ralloc(this->shader, nir_variable);
> impl->return_var->name = ralloc_strdup(impl->return_var,
> "return_var");
> - impl->return_var->type = overload->return_type;
> + impl->return_var->type = func->return_type;
> }
>
> this->is_global = false;
> @@ -536,7 +525,7 @@ nir_visitor::visit(ir_function_signature *ir)
>
> this->is_global = true;
> } else {
> - overload->impl = NULL;
> + func->impl = NULL;
> }
> }
>
> @@ -1082,7 +1071,7 @@ nir_visitor::visit(ir_call *ir)
> struct hash_entry *entry =
> _mesa_hash_table_search(this->overload_table, ir->callee);
> assert(entry);
> - nir_function_overload *callee = (nir_function_overload *) entry->data;
> + nir_function *callee = (nir_function *) entry->data;
>
> nir_call_instr *instr = nir_call_instr_create(this->shader, callee);
>
> diff --git a/src/glsl/nir/nir.c b/src/glsl/nir/nir.c
> index 35fc1de..60395ae 100644
> --- a/src/glsl/nir/nir.c
> +++ b/src/glsl/nir/nir.c
> @@ -163,7 +163,7 @@ nir_variable *
> nir_local_variable_create(nir_function_impl *impl,
> const struct glsl_type *type, const char *name)
> {
> - nir_variable *var = rzalloc(impl->overload->function->shader, nir_variable);
> + nir_variable *var = rzalloc(impl->function->shader, nir_variable);
> var->name = ralloc_strdup(var, name);
> var->type = type;
> var->data.mode = nir_var_local;
> @@ -179,31 +179,17 @@ nir_function_create(nir_shader *shader, const char *name)
> nir_function *func = ralloc(shader, nir_function);
>
> exec_list_push_tail(&shader->functions, &func->node);
> - exec_list_make_empty(&func->overload_list);
> +
> func->name = ralloc_strdup(func, name);
> func->shader = shader;
> + func->num_params = 0;
> + func->params = NULL;
> + func->return_type = glsl_void_type();
> + func->impl = NULL;
>
> return func;
> }
>
> -nir_function_overload *
> -nir_function_overload_create(nir_function *func)
> -{
> - void *mem_ctx = ralloc_parent(func);
> -
> - nir_function_overload *overload = ralloc(mem_ctx, nir_function_overload);
> -
> - overload->num_params = 0;
> - overload->params = NULL;
> - overload->return_type = glsl_void_type();
> - overload->impl = NULL;
> -
> - exec_list_push_tail(&func->overload_list, &overload->node);
> - overload->function = func;
> -
> - return overload;
> -}
> -
> void nir_src_copy(nir_src *dest, const nir_src *src, void *mem_ctx)
> {
> dest->is_ssa = src->is_ssa;
> @@ -268,16 +254,16 @@ cf_init(nir_cf_node *node, nir_cf_node_type type)
> }
>
> nir_function_impl *
> -nir_function_impl_create(nir_function_overload *overload)
> +nir_function_impl_create(nir_function *function)
> {
> - assert(overload->impl == NULL);
> + assert(function->impl == NULL);
>
> - void *mem_ctx = ralloc_parent(overload);
> + void *mem_ctx = ralloc_parent(function);
>
> nir_function_impl *impl = ralloc(mem_ctx, nir_function_impl);
>
> - overload->impl = impl;
> - impl->overload = overload;
> + function->impl = impl;
> + impl->function = function;
>
> cf_init(&impl->cf_node, nir_cf_node_function);
>
> @@ -474,7 +460,7 @@ nir_intrinsic_instr_create(nir_shader *shader, nir_intrinsic_op op)
> }
>
> nir_call_instr *
> -nir_call_instr_create(nir_shader *shader, nir_function_overload *callee)
> +nir_call_instr_create(nir_shader *shader, nir_function *callee)
> {
> nir_call_instr *instr = ralloc(shader, nir_call_instr);
> instr_init(&instr->instr, nir_instr_type_call);
> diff --git a/src/glsl/nir/nir.h b/src/glsl/nir/nir.h
> index 9dbda44..562c5c5 100644
> --- a/src/glsl/nir/nir.h
> +++ b/src/glsl/nir/nir.h
> @@ -65,7 +65,6 @@ name(const in_type *parent) \
> return exec_node_data(out_type, parent, field); \
> }
>
> -struct nir_function_overload;
> struct nir_function;
> struct nir_shader;
> struct nir_instr;
> @@ -785,7 +784,7 @@ typedef struct {
> nir_deref_var **params;
> nir_deref_var *return_deref;
>
> - struct nir_function_overload *callee;
> + struct nir_function *callee;
> } nir_call_instr;
>
> #define INTRINSIC(name, num_srcs, src_components, has_dest, dest_components, \
> @@ -1339,8 +1338,8 @@ typedef enum {
> typedef struct {
> nir_cf_node cf_node;
>
> - /** pointer to the overload of which this is an implementation */
> - struct nir_function_overload *overload;
> + /** pointer to the function of which this is an implementation */
> + struct nir_function *function;
>
> struct exec_list body; /** < list of nir_cf_node */
>
> @@ -1425,31 +1424,23 @@ typedef struct {
> const struct glsl_type *type;
> } nir_parameter;
>
> -typedef struct nir_function_overload {
> +typedef struct nir_function {
> struct exec_node node;
>
> + const char *name;
> + struct nir_shader *shader;
> +
> unsigned num_params;
> nir_parameter *params;
> const struct glsl_type *return_type;
>
> - nir_function_impl *impl; /** < NULL if the overload is only declared yet */
> -
> - /** pointer to the function of which this is an overload */
> - struct nir_function *function;
> -} nir_function_overload;
> -
> -typedef struct nir_function {
> - struct exec_node node;
> -
> - struct exec_list overload_list; /** < list of nir_function_overload */
> - const char *name;
> - struct nir_shader *shader;
> + /** The implementation of this function.
> + *
> + * If the function is only declared and not implemented, this is NULL.
> + */
> + nir_function_impl *impl;
> } nir_function;
>
> -#define nir_function_first_overload(func) \
> - exec_node_data(nir_function_overload, \
> - exec_list_get_head(&(func)->overload_list), node)
> -
> typedef struct nir_shader_compiler_options {
> bool lower_ffma;
> bool lower_flrp;
> @@ -1610,10 +1601,8 @@ typedef struct nir_shader {
> gl_shader_stage stage;
> } nir_shader;
>
> -#define nir_foreach_overload(shader, overload) \
> - foreach_list_typed(nir_function, func, node, &(shader)->functions) \
> - foreach_list_typed(nir_function_overload, overload, node, \
> - &(func)->overload_list)
> +#define nir_foreach_function(shader, func) \
> + foreach_list_typed(nir_function, func, node, &(shader)->functions)
>
> nir_shader *nir_shader_create(void *mem_ctx,
> gl_shader_stage stage,
> @@ -1649,10 +1638,7 @@ nir_variable *nir_local_variable_create(nir_function_impl *impl,
> /** creates a function and adds it to the shader's list of functions */
> nir_function *nir_function_create(nir_shader *shader, const char *name);
>
> -/** creates a null function returning null */
> -nir_function_overload *nir_function_overload_create(nir_function *func);
> -
> -nir_function_impl *nir_function_impl_create(nir_function_overload *func);
> +nir_function_impl *nir_function_impl_create(nir_function *func);
>
> nir_block *nir_block_create(nir_shader *shader);
> nir_if *nir_if_create(nir_shader *shader);
> @@ -1677,7 +1663,7 @@ nir_intrinsic_instr *nir_intrinsic_instr_create(nir_shader *shader,
> nir_intrinsic_op op);
>
> nir_call_instr *nir_call_instr_create(nir_shader *shader,
> - nir_function_overload *callee);
> + nir_function *callee);
>
> nir_tex_instr *nir_tex_instr_create(nir_shader *shader, unsigned num_srcs);
>
> diff --git a/src/glsl/nir/nir_algebraic.py b/src/glsl/nir/nir_algebraic.py
> index bbf4f08..a30652f 100644
> --- a/src/glsl/nir/nir_algebraic.py
> +++ b/src/glsl/nir/nir_algebraic.py
> @@ -276,9 +276,9 @@ ${pass_name}(nir_shader *shader)
> condition_flags[${index}] = ${condition};
> % endfor
>
> - nir_foreach_overload(shader, overload) {
> - if (overload->impl)
> - progress |= ${pass_name}_impl(overload->impl, condition_flags);
> + nir_foreach_function(shader, function) {
> + if (function->impl)
> + progress |= ${pass_name}_impl(function->impl, condition_flags);
> }
>
> return progress;
> diff --git a/src/glsl/nir/nir_builder.h b/src/glsl/nir/nir_builder.h
> index 5883d86..ee6131a 100644
> --- a/src/glsl/nir/nir_builder.h
> +++ b/src/glsl/nir/nir_builder.h
> @@ -40,7 +40,7 @@ nir_builder_init(nir_builder *build, nir_function_impl *impl)
> {
> memset(build, 0, sizeof(*build));
> build->impl = impl;
> - build->shader = impl->overload->function->shader;
> + build->shader = impl->function->shader;
> }
>
> static inline void
> diff --git a/src/glsl/nir/nir_clone.c b/src/glsl/nir/nir_clone.c
> index 33ff526..5eff743 100644
> --- a/src/glsl/nir/nir_clone.c
> +++ b/src/glsl/nir/nir_clone.c
> @@ -420,7 +420,7 @@ clone_jump(clone_state *state, const nir_jump_instr *jmp)
> static nir_call_instr *
> clone_call(clone_state *state, const nir_call_instr *call)
> {
> - nir_function_overload *ncallee = lookup_ptr(state, call->callee);
> + nir_function *ncallee = lookup_ptr(state, call->callee);
> nir_call_instr *ncall = nir_call_instr_create(state->ns, ncallee);
>
> for (unsigned i = 0; i < ncall->num_params; i++)
> @@ -547,9 +547,9 @@ clone_cf_list(clone_state *state, struct exec_list *dst,
>
> static nir_function_impl *
> clone_function_impl(clone_state *state, const nir_function_impl *fi,
> - nir_function_overload *nfo)
> + nir_function *nfxn)
> {
> - nir_function_impl *nfi = nir_function_impl_create(nfo);
> + nir_function_impl *nfi = nir_function_impl_create(nfxn);
>
> clone_var_list(state, &nfi->locals, &fi->locals);
> clone_reg_list(state, &nfi->registers, &fi->registers);
> @@ -588,39 +588,27 @@ clone_function_impl(clone_state *state, const nir_function_impl *fi,
> return nfi;
> }
>
> -static nir_function_overload *
> -clone_function_overload(clone_state *state, const nir_function_overload *fo,
> - nir_function *nfxn)
> +static nir_function *
> +clone_function(clone_state *state, const nir_function *fxn, nir_shader *ns)
> {
> - nir_function_overload *nfo = nir_function_overload_create(nfxn);
> + assert(ns == state->ns);
> + nir_function *nfxn = nir_function_create(ns, fxn->name);
>
> /* Needed for call instructions */
> - store_ptr(state, nfo, fo);
> + store_ptr(state, nfxn, fxn);
>
> - nfo->num_params = fo->num_params;
> - nfo->params = ralloc_array(state->ns, nir_parameter, fo->num_params);
> - memcpy(nfo->params, fo->params, sizeof(nir_parameter) * fo->num_params);
> + nfxn->num_params = fxn->num_params;
> + nfxn->params = ralloc_array(state->ns, nir_parameter, fxn->num_params);
> + memcpy(nfxn->params, fxn->params, sizeof(nir_parameter) * fxn->num_params);
>
> - nfo->return_type = fo->return_type;
> + nfxn->return_type = fxn->return_type;
>
> /* At first glance, it looks like we should clone the function_impl here.
> * However, call instructions need to be able to reference at least the
> - * overload and those will get processed as we clone the function_impl's.
> + * function and those will get processed as we clone the function_impl's.
> * We stop here and do function_impls as a second pass.
> */
>
> - return nfo;
> -}
> -
> -static nir_function *
> -clone_function(clone_state *state, const nir_function *fxn, nir_shader *ns)
> -{
> - assert(ns == state->ns);
> - nir_function *nfxn = nir_function_create(ns, fxn->name);
> -
> - foreach_list_typed(nir_function_overload, fo, node, &fxn->overload_list)
> - clone_function_overload(state, fo, nfxn);
> -
> return nfxn;
> }
>
> @@ -639,18 +627,18 @@ nir_shader_clone(void *mem_ctx, const nir_shader *s)
> clone_var_list(&state, &ns->globals, &s->globals);
> clone_var_list(&state, &ns->system_values, &s->system_values);
>
> - /* Go through and clone functions and overloads */
> + /* Go through and clone functions */
> foreach_list_typed(nir_function, fxn, node, &s->functions)
> clone_function(&state, fxn, ns);
>
> - /* Only after all overloads are cloned can we clone the actual function
> + /* Only after all functions are cloned can we clone the actual function
> * implementations. This is because nir_call_instr's need to reference the
> - * overloads of other functions and we don't know what order the functions
> + * functions of other functions and we don't know what order the functions
> * will have in the list.
> */
> - nir_foreach_overload(s, fo) {
> - nir_function_overload *nfo = lookup_ptr(&state, fo);
> - clone_function_impl(&state, fo->impl, nfo);
> + nir_foreach_function(s, fxn) {
> + nir_function *nfxn = lookup_ptr(&state, fxn);
> + clone_function_impl(&state, fxn->impl, nfxn);
> }
>
> clone_reg_list(&state, &ns->registers, &s->registers);
> diff --git a/src/glsl/nir/nir_dominance.c b/src/glsl/nir/nir_dominance.c
> index af4caae..b345b85 100644
> --- a/src/glsl/nir/nir_dominance.c
> +++ b/src/glsl/nir/nir_dominance.c
> @@ -221,9 +221,9 @@ nir_calc_dominance_impl(nir_function_impl *impl)
> void
> nir_calc_dominance(nir_shader *shader)
> {
> - nir_foreach_overload(shader, overload) {
> - if (overload->impl)
> - nir_calc_dominance_impl(overload->impl);
> + nir_foreach_function(shader, function) {
> + if (function->impl)
> + nir_calc_dominance_impl(function->impl);
> }
> }
>
> @@ -277,7 +277,7 @@ dump_block_dom(nir_block *block, void *state)
> void
> nir_dump_dom_tree_impl(nir_function_impl *impl, FILE *fp)
> {
> - fprintf(fp, "digraph doms_%s {\n", impl->overload->function->name);
> + fprintf(fp, "digraph doms_%s {\n", impl->function->name);
> nir_foreach_block(impl, dump_block_dom, fp);
> fprintf(fp, "}\n\n");
> }
> @@ -285,9 +285,9 @@ nir_dump_dom_tree_impl(nir_function_impl *impl, FILE *fp)
> void
> nir_dump_dom_tree(nir_shader *shader, FILE *fp)
> {
> - nir_foreach_overload(shader, overload) {
> - if (overload->impl)
> - nir_dump_dom_tree_impl(overload->impl, fp);
> + nir_foreach_function(shader, function) {
> + if (function->impl)
> + nir_dump_dom_tree_impl(function->impl, fp);
> }
> }
>
> @@ -315,9 +315,9 @@ nir_dump_dom_frontier_impl(nir_function_impl *impl, FILE *fp)
> void
> nir_dump_dom_frontier(nir_shader *shader, FILE *fp)
> {
> - nir_foreach_overload(shader, overload) {
> - if (overload->impl)
> - nir_dump_dom_frontier_impl(overload->impl, fp);
> + nir_foreach_function(shader, function) {
> + if (function->impl)
> + nir_dump_dom_frontier_impl(function->impl, fp);
> }
> }
>
> @@ -335,7 +335,7 @@ dump_block_succs(nir_block *block, void *state)
> void
> nir_dump_cfg_impl(nir_function_impl *impl, FILE *fp)
> {
> - fprintf(fp, "digraph cfg_%s {\n", impl->overload->function->name);
> + fprintf(fp, "digraph cfg_%s {\n", impl->function->name);
> nir_foreach_block(impl, dump_block_succs, fp);
> fprintf(fp, "}\n\n");
> }
> @@ -343,8 +343,8 @@ nir_dump_cfg_impl(nir_function_impl *impl, FILE *fp)
> void
> nir_dump_cfg(nir_shader *shader, FILE *fp)
> {
> - nir_foreach_overload(shader, overload) {
> - if (overload->impl)
> - nir_dump_cfg_impl(overload->impl, fp);
> + nir_foreach_function(shader, function) {
> + if (function->impl)
> + nir_dump_cfg_impl(function->impl, fp);
> }
> }
> diff --git a/src/glsl/nir/nir_from_ssa.c b/src/glsl/nir/nir_from_ssa.c
> index f2797f7..8bc9f24 100644
> --- a/src/glsl/nir/nir_from_ssa.c
> +++ b/src/glsl/nir/nir_from_ssa.c
> @@ -798,8 +798,8 @@ nir_convert_from_ssa_impl(nir_function_impl *impl, bool phi_webs_only)
> void
> nir_convert_from_ssa(nir_shader *shader, bool phi_webs_only)
> {
> - nir_foreach_overload(shader, overload) {
> - if (overload->impl)
> - nir_convert_from_ssa_impl(overload->impl, phi_webs_only);
> + nir_foreach_function(shader, function) {
> + if (function->impl)
> + nir_convert_from_ssa_impl(function->impl, phi_webs_only);
> }
> }
> diff --git a/src/glsl/nir/nir_gs_count_vertices.c b/src/glsl/nir/nir_gs_count_vertices.c
> index 1c36067..db15d16 100644
> --- a/src/glsl/nir/nir_gs_count_vertices.c
> +++ b/src/glsl/nir/nir_gs_count_vertices.c
> @@ -55,15 +55,15 @@ nir_gs_count_vertices(const nir_shader *shader)
> {
> int count = -1;
>
> - nir_foreach_overload(shader, overload) {
> - if (!overload->impl)
> + nir_foreach_function(shader, function) {
> + if (!function->impl)
> continue;
>
> /* set_vertex_count intrinsics only appear in predecessors of the
> * end block. So we don't need to walk all of them.
> */
> struct set_entry *entry;
> - set_foreach(overload->impl->end_block->predecessors, entry) {
> + set_foreach(function->impl->end_block->predecessors, entry) {
> nir_block *block = (nir_block *) entry->key;
>
> nir_foreach_instr_reverse(block, instr) {
> diff --git a/src/glsl/nir/nir_lower_alu_to_scalar.c b/src/glsl/nir/nir_lower_alu_to_scalar.c
> index d267ca3..0a27e66 100644
> --- a/src/glsl/nir/nir_lower_alu_to_scalar.c
> +++ b/src/glsl/nir/nir_lower_alu_to_scalar.c
> @@ -203,8 +203,8 @@ nir_lower_alu_to_scalar_impl(nir_function_impl *impl)
> void
> nir_lower_alu_to_scalar(nir_shader *shader)
> {
> - nir_foreach_overload(shader, overload) {
> - if (overload->impl)
> - nir_lower_alu_to_scalar_impl(overload->impl);
> + nir_foreach_function(shader, function) {
> + if (function->impl)
> + nir_lower_alu_to_scalar_impl(function->impl);
> }
> }
> diff --git a/src/glsl/nir/nir_lower_atomics.c b/src/glsl/nir/nir_lower_atomics.c
> index 40ca3de..259c154 100644
> --- a/src/glsl/nir/nir_lower_atomics.c
> +++ b/src/glsl/nir/nir_lower_atomics.c
> @@ -156,10 +156,10 @@ nir_lower_atomics(nir_shader *shader,
> .shader_program = shader_program,
> };
>
> - nir_foreach_overload(shader, overload) {
> - if (overload->impl) {
> - nir_foreach_block(overload->impl, lower_block, (void *) &state);
> - nir_metadata_preserve(overload->impl, nir_metadata_block_index |
> + nir_foreach_function(shader, function) {
> + if (function->impl) {
> + nir_foreach_block(function->impl, lower_block, (void *) &state);
> + nir_metadata_preserve(function->impl, nir_metadata_block_index |
> nir_metadata_dominance);
> }
> }
> diff --git a/src/glsl/nir/nir_lower_clip.c b/src/glsl/nir/nir_lower_clip.c
> index 4630135..f84a024 100644
> --- a/src/glsl/nir/nir_lower_clip.c
> +++ b/src/glsl/nir/nir_lower_clip.c
> @@ -143,9 +143,9 @@ find_output(nir_shader *shader, unsigned drvloc)
> .drvloc = drvloc,
> };
>
> - nir_foreach_overload(shader, overload) {
> - if (overload->impl) {
> - nir_foreach_block_reverse(overload->impl,
> + nir_foreach_function(shader, function) {
> + if (function->impl) {
> + nir_foreach_block_reverse(function->impl,
> find_output_in_block, &state);
> }
> }
> @@ -257,9 +257,9 @@ nir_lower_clip_vs(nir_shader *shader, unsigned ucp_enables)
> out[1] =
> create_clipdist_var(shader, ++maxloc, true, VARYING_SLOT_CLIP_DIST1);
>
> - nir_foreach_overload(shader, overload) {
> - if (!strcmp(overload->function->name, "main"))
> - lower_clip_vs(overload->impl, ucp_enables, cv, out);
> + nir_foreach_function(shader, function) {
> + if (!strcmp(function->name, "main"))
> + lower_clip_vs(function->impl, ucp_enables, cv, out);
> }
> }
>
> @@ -331,8 +331,8 @@ nir_lower_clip_fs(nir_shader *shader, unsigned ucp_enables)
> create_clipdist_var(shader, ++maxloc, false,
> VARYING_SLOT_CLIP_DIST1);
>
> - nir_foreach_overload(shader, overload) {
> - if (!strcmp(overload->function->name, "main"))
> - lower_clip_fs(overload->impl, ucp_enables, in);
> + nir_foreach_function(shader, function) {
> + if (!strcmp(function->name, "main"))
> + lower_clip_fs(function->impl, ucp_enables, in);
> }
> }
> diff --git a/src/glsl/nir/nir_lower_global_vars_to_local.c b/src/glsl/nir/nir_lower_global_vars_to_local.c
> index d549ee7..7b4cd4e 100644
> --- a/src/glsl/nir/nir_lower_global_vars_to_local.c
> +++ b/src/glsl/nir/nir_lower_global_vars_to_local.c
> @@ -82,10 +82,10 @@ nir_lower_global_vars_to_local(nir_shader *shader)
> state.var_func_table = _mesa_hash_table_create(NULL, _mesa_hash_pointer,
> _mesa_key_pointer_equal);
>
> - nir_foreach_overload(shader, overload) {
> - if (overload->impl) {
> - state.impl = overload->impl;
> - nir_foreach_block(overload->impl, mark_global_var_uses_block, &state);
> + nir_foreach_function(shader, function) {
> + if (function->impl) {
> + state.impl = function->impl;
> + nir_foreach_block(function->impl, mark_global_var_uses_block, &state);
> }
> }
>
> diff --git a/src/glsl/nir/nir_lower_gs_intrinsics.c b/src/glsl/nir/nir_lower_gs_intrinsics.c
> index 1325459..fdff165 100644
> --- a/src/glsl/nir/nir_lower_gs_intrinsics.c
> +++ b/src/glsl/nir/nir_lower_gs_intrinsics.c
> @@ -200,18 +200,18 @@ nir_lower_gs_intrinsics(nir_shader *shader)
> exec_list_push_tail(&shader->globals, &var->node);
> state.vertex_count_var = var;
>
> - nir_foreach_overload(shader, overload) {
> - if (overload->impl) {
> + nir_foreach_function(shader, function) {
> + if (function->impl) {
> nir_builder b;
> - nir_builder_init(&b, overload->impl);
> + nir_builder_init(&b, function->impl);
> state.builder = &b;
>
> - nir_foreach_block(overload->impl, rewrite_intrinsics, &state);
> + nir_foreach_block(function->impl, rewrite_intrinsics, &state);
>
> /* This only works because we have a single main() function. */
> - append_set_vertex_count(overload->impl->end_block, &state);
> + append_set_vertex_count(function->impl->end_block, &state);
>
> - nir_metadata_preserve(overload->impl, 0);
> + nir_metadata_preserve(function->impl, 0);
> }
> }
>
> diff --git a/src/glsl/nir/nir_lower_idiv.c b/src/glsl/nir/nir_lower_idiv.c
> index f64b3ea..a084ad9 100644
> --- a/src/glsl/nir/nir_lower_idiv.c
> +++ b/src/glsl/nir/nir_lower_idiv.c
> @@ -144,8 +144,8 @@ convert_impl(nir_function_impl *impl)
> void
> nir_lower_idiv(nir_shader *shader)
> {
> - nir_foreach_overload(shader, overload) {
> - if (overload->impl)
> - convert_impl(overload->impl);
> + nir_foreach_function(shader, function) {
> + if (function->impl)
> + convert_impl(function->impl);
> }
> }
> diff --git a/src/glsl/nir/nir_lower_io.c b/src/glsl/nir/nir_lower_io.c
> index a3565cc..80c5151 100644
> --- a/src/glsl/nir/nir_lower_io.c
> +++ b/src/glsl/nir/nir_lower_io.c
> @@ -304,9 +304,9 @@ void
> nir_lower_io(nir_shader *shader, nir_variable_mode mode,
> int (*type_size)(const struct glsl_type *))
> {
> - nir_foreach_overload(shader, overload) {
> - if (overload->impl)
> - nir_lower_io_impl(overload->impl, mode, type_size);
> + nir_foreach_function(shader, function) {
> + if (function->impl)
> + nir_lower_io_impl(function->impl, mode, type_size);
> }
> }
>
> diff --git a/src/glsl/nir/nir_lower_load_const_to_scalar.c b/src/glsl/nir/nir_lower_load_const_to_scalar.c
> index 84d0c14..1eeed13 100644
> --- a/src/glsl/nir/nir_lower_load_const_to_scalar.c
> +++ b/src/glsl/nir/nir_lower_load_const_to_scalar.c
> @@ -82,8 +82,8 @@ nir_lower_load_const_to_scalar_impl(nir_function_impl *impl)
> void
> nir_lower_load_const_to_scalar(nir_shader *shader)
> {
> - nir_foreach_overload(shader, overload) {
> - if (overload->impl)
> - nir_lower_load_const_to_scalar_impl(overload->impl);
> + nir_foreach_function(shader, function) {
> + if (function->impl)
> + nir_lower_load_const_to_scalar_impl(function->impl);
> }
> }
> diff --git a/src/glsl/nir/nir_lower_locals_to_regs.c b/src/glsl/nir/nir_lower_locals_to_regs.c
> index 3e21ac0..51b0fa7 100644
> --- a/src/glsl/nir/nir_lower_locals_to_regs.c
> +++ b/src/glsl/nir/nir_lower_locals_to_regs.c
> @@ -348,7 +348,7 @@ nir_lower_locals_to_regs_impl(nir_function_impl *impl)
> {
> struct locals_to_regs_state state;
>
> - state.shader = impl->overload->function->shader;
> + state.shader = impl->function->shader;
> state.impl = impl;
> state.progress = false;
> state.regs_table = _mesa_hash_table_create(NULL, hash_deref, derefs_equal);
> @@ -387,9 +387,9 @@ nir_lower_locals_to_regs(nir_shader *shader)
> {
> bool progress = false;
>
> - nir_foreach_overload(shader, overload) {
> - if (overload->impl)
> - progress = nir_lower_locals_to_regs_impl(overload->impl) || progress;
> + nir_foreach_function(shader, function) {
> + if (function->impl)
> + progress = nir_lower_locals_to_regs_impl(function->impl) || progress;
> }
>
> return progress;
> diff --git a/src/glsl/nir/nir_lower_outputs_to_temporaries.c b/src/glsl/nir/nir_lower_outputs_to_temporaries.c
> index 9441f47..71b06b8 100644
> --- a/src/glsl/nir/nir_lower_outputs_to_temporaries.c
> +++ b/src/glsl/nir/nir_lower_outputs_to_temporaries.c
> @@ -105,27 +105,27 @@ nir_lower_outputs_to_temporaries(nir_shader *shader)
> exec_list_push_tail(&shader->outputs, &output->node);
> }
>
> - nir_foreach_overload(shader, overload) {
> - if (overload->impl == NULL)
> + nir_foreach_function(shader, function) {
> + if (function->impl == NULL)
> continue;
>
> if (shader->stage == MESA_SHADER_GEOMETRY) {
> /* For geometry shaders, we have to emit the output copies right
> * before each EmitVertex call.
> */
> - nir_foreach_block(overload->impl, emit_output_copies_block, &state);
> - } else if (strcmp(overload->function->name, "main") == 0) {
> + nir_foreach_block(function->impl, emit_output_copies_block, &state);
> + } else if (strcmp(function->name, "main") == 0) {
> /* For all other shader types, we need to do the copies right before
> * the jumps to the end block.
> */
> struct set_entry *block_entry;
> - set_foreach(overload->impl->end_block->predecessors, block_entry) {
> + set_foreach(function->impl->end_block->predecessors, block_entry) {
> struct nir_block *block = (void *)block_entry->key;
> emit_output_copies(nir_after_block_before_jump(block), &state);
> }
> }
>
> - nir_metadata_preserve(overload->impl, nir_metadata_block_index |
> + nir_metadata_preserve(function->impl, nir_metadata_block_index |
> nir_metadata_dominance);
> }
>
> diff --git a/src/glsl/nir/nir_lower_phis_to_scalar.c b/src/glsl/nir/nir_lower_phis_to_scalar.c
> index 2f5927f..dd2abcf 100644
> --- a/src/glsl/nir/nir_lower_phis_to_scalar.c
> +++ b/src/glsl/nir/nir_lower_phis_to_scalar.c
> @@ -286,8 +286,8 @@ lower_phis_to_scalar_impl(nir_function_impl *impl)
> void
> nir_lower_phis_to_scalar(nir_shader *shader)
> {
> - nir_foreach_overload(shader, overload) {
> - if (overload->impl)
> - lower_phis_to_scalar_impl(overload->impl);
> + nir_foreach_function(shader, function) {
> + if (function->impl)
> + lower_phis_to_scalar_impl(function->impl);
> }
> }
> diff --git a/src/glsl/nir/nir_lower_samplers.c b/src/glsl/nir/nir_lower_samplers.c
> index 2aab305..95ea072 100644
> --- a/src/glsl/nir/nir_lower_samplers.c
> +++ b/src/glsl/nir/nir_lower_samplers.c
> @@ -180,8 +180,8 @@ void
> nir_lower_samplers(nir_shader *shader,
> const struct gl_shader_program *shader_program)
> {
> - nir_foreach_overload(shader, overload) {
> - if (overload->impl)
> - lower_impl(overload->impl, shader_program, shader->stage);
> + nir_foreach_function(shader, function) {
> + if (function->impl)
> + lower_impl(function->impl, shader_program, shader->stage);
> }
> }
> diff --git a/src/glsl/nir/nir_lower_system_values.c b/src/glsl/nir/nir_lower_system_values.c
> index 402f98e..2bd787d 100644
> --- a/src/glsl/nir/nir_lower_system_values.c
> +++ b/src/glsl/nir/nir_lower_system_values.c
> @@ -87,9 +87,9 @@ nir_lower_system_values(nir_shader *shader)
> {
> bool progress = false;
>
> - nir_foreach_overload(shader, overload) {
> - if (overload->impl)
> - progress = convert_impl(overload->impl) || progress;
> + nir_foreach_function(shader, function) {
> + if (function->impl)
> + progress = convert_impl(function->impl) || progress;
> }
>
> exec_list_make_empty(&shader->system_values);
> diff --git a/src/glsl/nir/nir_lower_tex.c b/src/glsl/nir/nir_lower_tex.c
> index 93ebf8e..ae24fb2 100644
> --- a/src/glsl/nir/nir_lower_tex.c
> +++ b/src/glsl/nir/nir_lower_tex.c
> @@ -346,9 +346,9 @@ nir_lower_tex(nir_shader *shader, const nir_lower_tex_options *options)
> state.options = options;
> state.progress = false;
>
> - nir_foreach_overload(shader, overload) {
> - if (overload->impl)
> - nir_lower_tex_impl(overload->impl, &state);
> + nir_foreach_function(shader, function) {
> + if (function->impl)
> + nir_lower_tex_impl(function->impl, &state);
> }
>
> return state.progress;
> diff --git a/src/glsl/nir/nir_lower_to_source_mods.c b/src/glsl/nir/nir_lower_to_source_mods.c
> index 94c7e36..6c4e1f0 100644
> --- a/src/glsl/nir/nir_lower_to_source_mods.c
> +++ b/src/glsl/nir/nir_lower_to_source_mods.c
> @@ -189,8 +189,8 @@ nir_lower_to_source_mods_impl(nir_function_impl *impl)
> void
> nir_lower_to_source_mods(nir_shader *shader)
> {
> - nir_foreach_overload(shader, overload) {
> - if (overload->impl)
> - nir_lower_to_source_mods_impl(overload->impl);
> + nir_foreach_function(shader, function) {
> + if (function->impl)
> + nir_lower_to_source_mods_impl(function->impl);
> }
> }
> diff --git a/src/glsl/nir/nir_lower_two_sided_color.c b/src/glsl/nir/nir_lower_two_sided_color.c
> index 7df12e0..1294cb8 100644
> --- a/src/glsl/nir/nir_lower_two_sided_color.c
> +++ b/src/glsl/nir/nir_lower_two_sided_color.c
> @@ -204,9 +204,9 @@ nir_lower_two_sided_color(nir_shader *shader)
> if (setup_inputs(&state) != 0)
> return;
>
> - nir_foreach_overload(shader, overload) {
> - if (overload->impl)
> - nir_lower_two_sided_color_impl(overload->impl, &state);
> + nir_foreach_function(shader, function) {
> + if (function->impl)
> + nir_lower_two_sided_color_impl(function->impl, &state);
> }
>
> }
> diff --git a/src/glsl/nir/nir_lower_var_copies.c b/src/glsl/nir/nir_lower_var_copies.c
> index a9017de..350e99c 100644
> --- a/src/glsl/nir/nir_lower_var_copies.c
> +++ b/src/glsl/nir/nir_lower_var_copies.c
> @@ -183,8 +183,8 @@ lower_var_copies_impl(nir_function_impl *impl)
> void
> nir_lower_var_copies(nir_shader *shader)
> {
> - nir_foreach_overload(shader, overload) {
> - if (overload->impl)
> - lower_var_copies_impl(overload->impl);
> + nir_foreach_function(shader, function) {
> + if (function->impl)
> + lower_var_copies_impl(function->impl);
> }
> }
> diff --git a/src/glsl/nir/nir_lower_vars_to_ssa.c b/src/glsl/nir/nir_lower_vars_to_ssa.c
> index 3ec0e1d..75d31ff 100644
> --- a/src/glsl/nir/nir_lower_vars_to_ssa.c
> +++ b/src/glsl/nir/nir_lower_vars_to_ssa.c
> @@ -887,7 +887,7 @@ nir_lower_vars_to_ssa_impl(nir_function_impl *impl)
> {
> struct lower_variables_state state;
>
> - state.shader = impl->overload->function->shader;
> + state.shader = impl->function->shader;
> state.dead_ctx = ralloc_context(state.shader);
> state.impl = impl;
>
> @@ -966,8 +966,8 @@ nir_lower_vars_to_ssa_impl(nir_function_impl *impl)
> void
> nir_lower_vars_to_ssa(nir_shader *shader)
> {
> - nir_foreach_overload(shader, overload) {
> - if (overload->impl)
> - nir_lower_vars_to_ssa_impl(overload->impl);
> + nir_foreach_function(shader, function) {
> + if (function->impl)
> + nir_lower_vars_to_ssa_impl(function->impl);
> }
> }
> diff --git a/src/glsl/nir/nir_lower_vec_to_movs.c b/src/glsl/nir/nir_lower_vec_to_movs.c
> index 736a66c..06d6279 100644
> --- a/src/glsl/nir/nir_lower_vec_to_movs.c
> +++ b/src/glsl/nir/nir_lower_vec_to_movs.c
> @@ -217,7 +217,7 @@ lower_vec_to_movs_block(nir_block *block, void *void_state)
> {
> struct vec_to_movs_state *state = void_state;
> nir_function_impl *impl = state->impl;
> - nir_shader *shader = impl->overload->function->shader;
> + nir_shader *shader = impl->function->shader;
>
> nir_foreach_instr_safe(block, instr) {
> if (instr->type != nir_instr_type_alu)
> @@ -301,9 +301,9 @@ nir_lower_vec_to_movs(nir_shader *shader)
> {
> bool progress = false;
>
> - nir_foreach_overload(shader, overload) {
> - if (overload->impl)
> - progress = nir_lower_vec_to_movs_impl(overload->impl) || progress;
> + nir_foreach_function(shader, function) {
> + if (function->impl)
> + progress = nir_lower_vec_to_movs_impl(function->impl) || progress;
> }
>
> return progress;
> diff --git a/src/glsl/nir/nir_metadata.c b/src/glsl/nir/nir_metadata.c
> index d5324b3..61aae73 100644
> --- a/src/glsl/nir/nir_metadata.c
> +++ b/src/glsl/nir/nir_metadata.c
> @@ -63,9 +63,9 @@ nir_metadata_preserve(nir_function_impl *impl, nir_metadata preserved)
> void
> nir_metadata_set_validation_flag(nir_shader *shader)
> {
> - nir_foreach_overload(shader, overload) {
> - if (overload->impl) {
> - overload->impl->valid_metadata |= nir_metadata_not_properly_reset;
> + nir_foreach_function(shader, function) {
> + if (function->impl) {
> + function->impl->valid_metadata |= nir_metadata_not_properly_reset;
> }
> }
> }
> @@ -80,9 +80,9 @@ nir_metadata_set_validation_flag(nir_shader *shader)
> void
> nir_metadata_check_validation_flag(nir_shader *shader)
> {
> - nir_foreach_overload(shader, overload) {
> - if (overload->impl) {
> - assert(!(overload->impl->valid_metadata &
> + nir_foreach_function(shader, function) {
> + if (function->impl) {
> + assert(!(function->impl->valid_metadata &
> nir_metadata_not_properly_reset));
> }
> }
> diff --git a/src/glsl/nir/nir_move_vec_src_uses_to_dest.c b/src/glsl/nir/nir_move_vec_src_uses_to_dest.c
> index 4c9032d..b5186e6 100644
> --- a/src/glsl/nir/nir_move_vec_src_uses_to_dest.c
> +++ b/src/glsl/nir/nir_move_vec_src_uses_to_dest.c
> @@ -190,8 +190,8 @@ nir_move_vec_src_uses_to_dest_impl(nir_shader *shader, nir_function_impl *impl)
> void
> nir_move_vec_src_uses_to_dest(nir_shader *shader)
> {
> - nir_foreach_overload(shader, overload) {
> - if (overload->impl)
> - nir_move_vec_src_uses_to_dest_impl(shader, overload->impl);
> + nir_foreach_function(shader, function) {
> + if (function->impl)
> + nir_move_vec_src_uses_to_dest_impl(shader, function->impl);
> }
> }
> diff --git a/src/glsl/nir/nir_normalize_cubemap_coords.c b/src/glsl/nir/nir_normalize_cubemap_coords.c
> index 7385576..9c15eb8 100644
> --- a/src/glsl/nir/nir_normalize_cubemap_coords.c
> +++ b/src/glsl/nir/nir_normalize_cubemap_coords.c
> @@ -111,9 +111,9 @@ nir_normalize_cubemap_coords(nir_shader *shader)
> {
> bool progress = false;
>
> - nir_foreach_overload(shader, overload) {
> - if (overload->impl)
> - progress = normalize_cubemap_coords_impl(overload->impl) || progress;
> + nir_foreach_function(shader, function) {
> + if (function->impl)
> + progress = normalize_cubemap_coords_impl(function->impl) || progress;
> }
>
> return progress;
> diff --git a/src/glsl/nir/nir_opt_constant_folding.c b/src/glsl/nir/nir_opt_constant_folding.c
> index 007b81c..28a73f8 100644
> --- a/src/glsl/nir/nir_opt_constant_folding.c
> +++ b/src/glsl/nir/nir_opt_constant_folding.c
> @@ -192,9 +192,9 @@ nir_opt_constant_folding(nir_shader *shader)
> {
> bool progress = false;
>
> - nir_foreach_overload(shader, overload) {
> - if (overload->impl)
> - progress |= nir_opt_constant_folding_impl(overload->impl);
> + nir_foreach_function(shader, function) {
> + if (function->impl)
> + progress |= nir_opt_constant_folding_impl(function->impl);
> }
>
> return progress;
> diff --git a/src/glsl/nir/nir_opt_copy_propagate.c b/src/glsl/nir/nir_opt_copy_propagate.c
> index cfc8e331..d99f78d 100644
> --- a/src/glsl/nir/nir_opt_copy_propagate.c
> +++ b/src/glsl/nir/nir_opt_copy_propagate.c
> @@ -281,8 +281,8 @@ nir_copy_prop(nir_shader *shader)
> {
> bool progress = false;
>
> - nir_foreach_overload(shader, overload) {
> - if (overload->impl && nir_copy_prop_impl(overload->impl))
> + nir_foreach_function(shader, function) {
> + if (function->impl && nir_copy_prop_impl(function->impl))
> progress = true;
> }
>
> diff --git a/src/glsl/nir/nir_opt_cse.c b/src/glsl/nir/nir_opt_cse.c
> index 93a6635..364fb02 100644
> --- a/src/glsl/nir/nir_opt_cse.c
> +++ b/src/glsl/nir/nir_opt_cse.c
> @@ -83,9 +83,9 @@ nir_opt_cse(nir_shader *shader)
> {
> bool progress = false;
>
> - nir_foreach_overload(shader, overload) {
> - if (overload->impl)
> - progress |= nir_opt_cse_impl(overload->impl);
> + nir_foreach_function(shader, function) {
> + if (function->impl)
> + progress |= nir_opt_cse_impl(function->impl);
> }
>
> return progress;
> diff --git a/src/glsl/nir/nir_opt_dce.c b/src/glsl/nir/nir_opt_dce.c
> index 6032528..32436c1 100644
> --- a/src/glsl/nir/nir_opt_dce.c
> +++ b/src/glsl/nir/nir_opt_dce.c
> @@ -174,8 +174,8 @@ bool
> nir_opt_dce(nir_shader *shader)
> {
> bool progress = false;
> - nir_foreach_overload(shader, overload) {
> - if (overload->impl && nir_opt_dce_impl(overload->impl))
> + nir_foreach_function(shader, function) {
> + if (function->impl && nir_opt_dce_impl(function->impl))
> progress = true;
> }
>
> diff --git a/src/glsl/nir/nir_opt_dead_cf.c b/src/glsl/nir/nir_opt_dead_cf.c
> index 356e926..4cc6798 100644
> --- a/src/glsl/nir/nir_opt_dead_cf.c
> +++ b/src/glsl/nir/nir_opt_dead_cf.c
> @@ -350,9 +350,9 @@ nir_opt_dead_cf(nir_shader *shader)
> {
> bool progress = false;
>
> - nir_foreach_overload(shader, overload)
> - if (overload->impl)
> - progress |= opt_dead_cf_impl(overload->impl);
> + nir_foreach_function(shader, function)
> + if (function->impl)
> + progress |= opt_dead_cf_impl(function->impl);
>
> return progress;
> }
> diff --git a/src/glsl/nir/nir_opt_gcm.c b/src/glsl/nir/nir_opt_gcm.c
> index 5b412ee..a8779ce 100644
> --- a/src/glsl/nir/nir_opt_gcm.c
> +++ b/src/glsl/nir/nir_opt_gcm.c
> @@ -487,8 +487,8 @@ opt_gcm_impl(nir_function_impl *impl)
> void
> nir_opt_gcm(nir_shader *shader)
> {
> - nir_foreach_overload(shader, overload) {
> - if (overload->impl)
> - opt_gcm_impl(overload->impl);
> + nir_foreach_function(shader, function) {
> + if (function->impl)
> + opt_gcm_impl(function->impl);
> }
> }
> diff --git a/src/glsl/nir/nir_opt_peephole_select.c b/src/glsl/nir/nir_opt_peephole_select.c
> index 90902b9..0fc658d 100644
> --- a/src/glsl/nir/nir_opt_peephole_select.c
> +++ b/src/glsl/nir/nir_opt_peephole_select.c
> @@ -247,9 +247,9 @@ nir_opt_peephole_select(nir_shader *shader)
> {
> bool progress = false;
>
> - nir_foreach_overload(shader, overload) {
> - if (overload->impl)
> - progress |= nir_opt_peephole_select_impl(overload->impl);
> + nir_foreach_function(shader, function) {
> + if (function->impl)
> + progress |= nir_opt_peephole_select_impl(function->impl);
> }
>
> return progress;
> diff --git a/src/glsl/nir/nir_opt_remove_phis.c b/src/glsl/nir/nir_opt_remove_phis.c
> index 66d3754..6461837 100644
> --- a/src/glsl/nir/nir_opt_remove_phis.c
> +++ b/src/glsl/nir/nir_opt_remove_phis.c
> @@ -121,9 +121,9 @@ nir_opt_remove_phis(nir_shader *shader)
> {
> bool progress = false;
>
> - nir_foreach_overload(shader, overload)
> - if (overload->impl)
> - progress = remove_phis_impl(overload->impl) || progress;
> + nir_foreach_function(shader, function)
> + if (function->impl)
> + progress = remove_phis_impl(function->impl) || progress;
>
> return progress;
> }
> diff --git a/src/glsl/nir/nir_opt_undef.c b/src/glsl/nir/nir_opt_undef.c
> index 4ab27a8..374564d 100644
> --- a/src/glsl/nir/nir_opt_undef.c
> +++ b/src/glsl/nir/nir_opt_undef.c
> @@ -90,11 +90,11 @@ nir_opt_undef(nir_shader *shader)
> {
> bool progress = false;
>
> - nir_foreach_overload(shader, overload) {
> - if (overload->impl) {
> - nir_foreach_block(overload->impl, opt_undef_block, &progress);
> + nir_foreach_function(shader, function) {
> + if (function->impl) {
> + nir_foreach_block(function->impl, opt_undef_block, &progress);
> if (progress)
> - nir_metadata_preserve(overload->impl,
> + nir_metadata_preserve(function->impl,
> nir_metadata_block_index |
> nir_metadata_dominance);
> }
> diff --git a/src/glsl/nir/nir_print.c b/src/glsl/nir/nir_print.c
> index 56e5705..80638ed 100644
> --- a/src/glsl/nir/nir_print.c
> +++ b/src/glsl/nir/nir_print.c
> @@ -644,7 +644,7 @@ print_call_instr(nir_call_instr *instr, print_state *state)
> {
> FILE *fp = state->fp;
>
> - fprintf(fp, "call %s ", instr->callee->function->name);
> + fprintf(fp, "call %s ", instr->callee->name);
>
> for (unsigned i = 0; i < instr->num_params; i++) {
> if (i != 0)
> @@ -910,7 +910,7 @@ print_function_impl(nir_function_impl *impl, print_state *state)
> {
> FILE *fp = state->fp;
>
> - fprintf(fp, "\nimpl %s ", impl->overload->function->name);
> + fprintf(fp, "\nimpl %s ", impl->function->name);
>
> for (unsigned i = 0; i < impl->num_params; i++) {
> if (i != 0)
> @@ -948,18 +948,17 @@ print_function_impl(nir_function_impl *impl, print_state *state)
> }
>
> static void
> -print_function_overload(nir_function_overload *overload,
> - print_state *state)
> +print_function(nir_function *function, print_state *state)
> {
> FILE *fp = state->fp;
>
> - fprintf(fp, "decl_overload %s ", overload->function->name);
> + fprintf(fp, "decl_function %s ", function->name);
>
> - for (unsigned i = 0; i < overload->num_params; i++) {
> + for (unsigned i = 0; i < function->num_params; i++) {
> if (i != 0)
> fprintf(fp, ", ");
>
> - switch (overload->params[i].param_type) {
> + switch (function->params[i].param_type) {
> case nir_parameter_in:
> fprintf(fp, "in ");
> break;
> @@ -973,33 +972,25 @@ print_function_overload(nir_function_overload *overload,
> unreachable("Invalid parameter type");
> }
>
> - glsl_print_type(overload->params[i].type, fp);
> + glsl_print_type(function->params[i].type, fp);
> }
>
> - if (overload->return_type != NULL) {
> - if (overload->num_params != 0)
> + if (function->return_type != NULL) {
> + if (function->num_params != 0)
> fprintf(fp, ", ");
> fprintf(fp, "returning ");
> - glsl_print_type(overload->return_type, fp);
> + glsl_print_type(function->return_type, fp);
> }
>
> fprintf(fp, "\n");
>
> - if (overload->impl != NULL) {
> - print_function_impl(overload->impl, state);
> + if (function->impl != NULL) {
> + print_function_impl(function->impl, state);
> return;
> }
> }
>
> static void
> -print_function(nir_function *func, print_state *state)
> -{
> - foreach_list_typed(nir_function_overload, overload, node, &func->overload_list) {
> - print_function_overload(overload, state);
> - }
> -}
> -
> -static void
> init_print_state(print_state *state, nir_shader *shader, FILE *fp)
> {
> state->fp = fp;
> diff --git a/src/glsl/nir/nir_remove_dead_variables.c b/src/glsl/nir/nir_remove_dead_variables.c
> index 8f0833c..db754e5 100644
> --- a/src/glsl/nir/nir_remove_dead_variables.c
> +++ b/src/glsl/nir/nir_remove_dead_variables.c
> @@ -90,9 +90,9 @@ add_var_use_block(nir_block *block, void *state)
> static void
> add_var_use_shader(nir_shader *shader, struct set *live)
> {
> - nir_foreach_overload(shader, overload) {
> - if (overload->impl) {
> - nir_foreach_block(overload->impl, add_var_use_block, live);
> + nir_foreach_function(shader, function) {
> + if (function->impl) {
> + nir_foreach_block(function->impl, add_var_use_block, live);
> }
> }
> }
> @@ -125,10 +125,10 @@ nir_remove_dead_variables(nir_shader *shader)
>
> progress = remove_dead_vars(&shader->globals, live) || progress;
>
> - nir_foreach_overload(shader, overload) {
> - if (overload->impl) {
> - if (remove_dead_vars(&overload->impl->locals, live)) {
> - nir_metadata_preserve(overload->impl, nir_metadata_block_index |
> + nir_foreach_function(shader, function) {
> + if (function->impl) {
> + if (remove_dead_vars(&function->impl->locals, live)) {
> + nir_metadata_preserve(function->impl, nir_metadata_block_index |
> nir_metadata_dominance |
> nir_metadata_live_ssa_defs);
> progress = true;
> diff --git a/src/glsl/nir/nir_split_var_copies.c b/src/glsl/nir/nir_split_var_copies.c
> index bfbef72..6fdaefa 100644
> --- a/src/glsl/nir/nir_split_var_copies.c
> +++ b/src/glsl/nir/nir_split_var_copies.c
> @@ -276,9 +276,9 @@ nir_split_var_copies(nir_shader *shader)
> {
> bool progress = false;
>
> - nir_foreach_overload(shader, overload) {
> - if (overload->impl)
> - progress = split_var_copies_impl(overload->impl) || progress;
> + nir_foreach_function(shader, function) {
> + if (function->impl)
> + progress = split_var_copies_impl(function->impl) || progress;
> }
>
> return progress;
> diff --git a/src/glsl/nir/nir_sweep.c b/src/glsl/nir/nir_sweep.c
> index 5a22f50..0710bdb 100644
> --- a/src/glsl/nir/nir_sweep.c
> +++ b/src/glsl/nir/nir_sweep.c
> @@ -137,13 +137,10 @@ static void
> sweep_function(nir_shader *nir, nir_function *f)
> {
> ralloc_steal(nir, f);
> + ralloc_steal(nir, f->params);
>
> - foreach_list_typed(nir_function_overload, overload, node, &f->overload_list) {
> - ralloc_steal(nir, overload);
> - ralloc_steal(nir, overload->params);
> - if (overload->impl)
> - sweep_impl(nir, overload->impl);
> - }
> + if (f->impl)
> + sweep_impl(nir, f->impl);
> }
>
> void
> diff --git a/src/glsl/nir/nir_to_ssa.c b/src/glsl/nir/nir_to_ssa.c
> index b089df7..44a5054 100644
> --- a/src/glsl/nir/nir_to_ssa.c
> +++ b/src/glsl/nir/nir_to_ssa.c
> @@ -529,8 +529,8 @@ nir_convert_to_ssa_impl(nir_function_impl *impl)
> void
> nir_convert_to_ssa(nir_shader *shader)
> {
> - nir_foreach_overload(shader, overload) {
> - if (overload->impl)
> - nir_convert_to_ssa_impl(overload->impl);
> + nir_foreach_function(shader, function) {
> + if (function->impl)
> + nir_convert_to_ssa_impl(function->impl);
> }
> }
> diff --git a/src/glsl/nir/nir_validate.c b/src/glsl/nir/nir_validate.c
> index da92055..e4db68d 100644
> --- a/src/glsl/nir/nir_validate.c
> +++ b/src/glsl/nir/nir_validate.c
> @@ -929,17 +929,17 @@ postvalidate_ssa_defs_block(nir_block *block, void *state)
> static void
> validate_function_impl(nir_function_impl *impl, validate_state *state)
> {
> - assert(impl->overload->impl == impl);
> + assert(impl->function->impl == impl);
> assert(impl->cf_node.parent == NULL);
>
> - assert(impl->num_params == impl->overload->num_params);
> + assert(impl->num_params == impl->function->num_params);
> for (unsigned i = 0; i < impl->num_params; i++)
> - assert(impl->params[i]->type == impl->overload->params[i].type);
> + assert(impl->params[i]->type == impl->function->params[i].type);
>
> - if (glsl_type_is_void(impl->overload->return_type))
> + if (glsl_type_is_void(impl->function->return_type))
> assert(impl->return_var == NULL);
> else
> - assert(impl->return_var->type == impl->overload->return_type);
> + assert(impl->return_var->type == impl->function->return_type);
>
> assert(exec_list_is_empty(&impl->end_block->instr_list));
> assert(impl->end_block->successors[0] == NULL);
> @@ -981,20 +981,11 @@ validate_function_impl(nir_function_impl *impl, validate_state *state)
> }
>
> static void
> -validate_function_overload(nir_function_overload *overload,
> - validate_state *state)
> -{
> - if (overload->impl != NULL)
> - validate_function_impl(overload->impl, state);
> -}
> -
> -static void
> validate_function(nir_function *func, validate_state *state)
> {
> - exec_list_validate(&func->overload_list);
> - foreach_list_typed(nir_function_overload, overload, node, &func->overload_list) {
> - assert(overload->function == func);
> - validate_function_overload(overload, state);
> + if (func->impl != NULL) {
> + assert(func->impl->function == func);
> + validate_function_impl(func->impl, state);
> }
> }
>
> diff --git a/src/mesa/drivers/dri/i965/brw_fs_nir.cpp b/src/mesa/drivers/dri/i965/brw_fs_nir.cpp
> index 9728e2a..bb6ab53 100644
> --- a/src/mesa/drivers/dri/i965/brw_fs_nir.cpp
> +++ b/src/mesa/drivers/dri/i965/brw_fs_nir.cpp
> @@ -43,10 +43,10 @@ fs_visitor::emit_nir_code()
> nir_emit_system_values();
>
> /* get the main function and emit it */
> - nir_foreach_overload(nir, overload) {
> - assert(strcmp(overload->function->name, "main") == 0);
> - assert(overload->impl);
> - nir_emit_impl(overload->impl);
> + nir_foreach_function(nir, function) {
> + assert(strcmp(function->name, "main") == 0);
> + assert(function->impl);
> + nir_emit_impl(function->impl);
> }
> }
>
> @@ -338,10 +338,10 @@ fs_visitor::nir_emit_system_values()
> nir_system_values[i] = fs_reg();
> }
>
> - nir_foreach_overload(nir, overload) {
> - assert(strcmp(overload->function->name, "main") == 0);
> - assert(overload->impl);
> - nir_foreach_block(overload->impl, emit_system_values_block, this);
> + nir_foreach_function(nir, function) {
> + assert(strcmp(function->name, "main") == 0);
> + assert(function->impl);
> + nir_foreach_block(function->impl, emit_system_values_block, this);
> }
> }
>
> diff --git a/src/mesa/drivers/dri/i965/brw_nir.c b/src/mesa/drivers/dri/i965/brw_nir.c
> index eebd2a3..e031173 100644
> --- a/src/mesa/drivers/dri/i965/brw_nir.c
> +++ b/src/mesa/drivers/dri/i965/brw_nir.c
> @@ -224,11 +224,11 @@ brw_nir_lower_inputs(nir_shader *nir,
> /* This pass needs actual constants */
> nir_opt_constant_folding(nir);
>
> - nir_foreach_overload(nir, overload) {
> - if (overload->impl) {
> - nir_builder_init(¶ms.b, overload->impl);
> - nir_foreach_block(overload->impl, add_const_offset_to_base, ¶ms);
> - nir_foreach_block(overload->impl, remap_vs_attrs, &inputs_read);
> + nir_foreach_function(nir, function) {
> + if (function->impl) {
> + nir_builder_init(¶ms.b, function->impl);
> + nir_foreach_block(function->impl, add_const_offset_to_base, ¶ms);
> + nir_foreach_block(function->impl, remap_vs_attrs, &inputs_read);
> }
> }
> }
> @@ -270,11 +270,11 @@ brw_nir_lower_inputs(nir_shader *nir,
> /* This pass needs actual constants */
> nir_opt_constant_folding(nir);
>
> - nir_foreach_overload(nir, overload) {
> - if (overload->impl) {
> - nir_builder_init(¶ms.b, overload->impl);
> - nir_foreach_block(overload->impl, add_const_offset_to_base, ¶ms);
> - nir_foreach_block(overload->impl, remap_inputs_with_vue_map,
> + nir_foreach_function(nir, function) {
> + if (function->impl) {
> + nir_builder_init(¶ms.b, function->impl);
> + nir_foreach_block(function->impl, add_const_offset_to_base, ¶ms);
> + nir_foreach_block(function->impl, remap_inputs_with_vue_map,
> &input_vue_map);
> }
> }
> @@ -296,12 +296,12 @@ brw_nir_lower_inputs(nir_shader *nir,
> /* This pass needs actual constants */
> nir_opt_constant_folding(nir);
>
> - nir_foreach_overload(nir, overload) {
> - if (overload->impl) {
> - nir_builder_init(¶ms.b, overload->impl);
> - nir_foreach_block(overload->impl, add_const_offset_to_base, ¶ms);
> - nir_builder_init(&state.b, overload->impl);
> - nir_foreach_block(overload->impl, remap_patch_urb_offsets, &state);
> + nir_foreach_function(nir, function) {
> + if (function->impl) {
> + nir_builder_init(¶ms.b, function->impl);
> + nir_foreach_block(function->impl, add_const_offset_to_base, ¶ms);
> + nir_builder_init(&state.b, function->impl);
> + nir_foreach_block(function->impl, remap_patch_urb_offsets, &state);
> }
> }
> break;
> @@ -356,12 +356,12 @@ brw_nir_lower_outputs(nir_shader *nir,
> /* This pass needs actual constants */
> nir_opt_constant_folding(nir);
>
> - nir_foreach_overload(nir, overload) {
> - if (overload->impl) {
> - nir_builder_init(¶ms.b, overload->impl);
> - nir_foreach_block(overload->impl, add_const_offset_to_base, ¶ms);
> - nir_builder_init(&state.b, overload->impl);
> - nir_foreach_block(overload->impl, remap_patch_urb_offsets, &state);
> + nir_foreach_function(nir, function) {
> + if (function->impl) {
> + nir_builder_init(¶ms.b, function->impl);
> + nir_foreach_block(function->impl, add_const_offset_to_base, ¶ms);
> + nir_builder_init(&state.b, function->impl);
> + nir_foreach_block(function->impl, remap_patch_urb_offsets, &state);
> }
> }
> break;
> @@ -565,9 +565,9 @@ brw_postprocess_nir(nir_shader *nir,
>
> if (unlikely(debug_enabled)) {
> /* Re-index SSA defs so we print more sensible numbers. */
> - nir_foreach_overload(nir, overload) {
> - if (overload->impl)
> - nir_index_ssa_defs(overload->impl);
> + nir_foreach_function(nir, function) {
> + if (function->impl)
> + nir_index_ssa_defs(function->impl);
> }
>
> fprintf(stderr, "NIR (SSA form) for %s shader:\n",
> diff --git a/src/mesa/drivers/dri/i965/brw_nir_analyze_boolean_resolves.c b/src/mesa/drivers/dri/i965/brw_nir_analyze_boolean_resolves.c
> index f4d23d8..56e15ef 100644
> --- a/src/mesa/drivers/dri/i965/brw_nir_analyze_boolean_resolves.c
> +++ b/src/mesa/drivers/dri/i965/brw_nir_analyze_boolean_resolves.c
> @@ -260,7 +260,8 @@ analyze_boolean_resolves_impl(nir_function_impl *impl)
> void
> brw_nir_analyze_boolean_resolves(nir_shader *shader)
> {
> - nir_foreach_overload(shader, overload)
> - if (overload->impl)
> - analyze_boolean_resolves_impl(overload->impl);
> + nir_foreach_function(shader, function) {
> + if (function->impl)
> + analyze_boolean_resolves_impl(function->impl);
> + }
> }
> diff --git a/src/mesa/drivers/dri/i965/brw_nir_opt_peephole_ffma.c b/src/mesa/drivers/dri/i965/brw_nir_opt_peephole_ffma.c
> index 5603129..5ff2cba 100644
> --- a/src/mesa/drivers/dri/i965/brw_nir_opt_peephole_ffma.c
> +++ b/src/mesa/drivers/dri/i965/brw_nir_opt_peephole_ffma.c
> @@ -290,9 +290,9 @@ brw_nir_opt_peephole_ffma(nir_shader *shader)
> {
> bool progress = false;
>
> - nir_foreach_overload(shader, overload) {
> - if (overload->impl)
> - progress |= brw_nir_opt_peephole_ffma_impl(overload->impl);
> + nir_foreach_function(shader, function) {
> + if (function->impl)
> + progress |= brw_nir_opt_peephole_ffma_impl(function->impl);
> }
>
> return progress;
> diff --git a/src/mesa/drivers/dri/i965/brw_vec4_nir.cpp b/src/mesa/drivers/dri/i965/brw_vec4_nir.cpp
> index 2599628..ab71304 100644
> --- a/src/mesa/drivers/dri/i965/brw_vec4_nir.cpp
> +++ b/src/mesa/drivers/dri/i965/brw_vec4_nir.cpp
> @@ -41,10 +41,10 @@ vec4_visitor::emit_nir_code()
> nir_setup_system_values();
>
> /* get the main function and emit it */
> - nir_foreach_overload(nir, overload) {
> - assert(strcmp(overload->function->name, "main") == 0);
> - assert(overload->impl);
> - nir_emit_impl(overload->impl);
> + nir_foreach_function(nir, function) {
> + assert(strcmp(function->name, "main") == 0);
> + assert(function->impl);
> + nir_emit_impl(function->impl);
> }
> }
>
> @@ -107,10 +107,10 @@ vec4_visitor::nir_setup_system_values()
> nir_system_values[i] = dst_reg();
> }
>
> - nir_foreach_overload(nir, overload) {
> - assert(strcmp(overload->function->name, "main") == 0);
> - assert(overload->impl);
> - nir_foreach_block(overload->impl, setup_system_values_block, this);
> + nir_foreach_function(nir, function) {
> + assert(strcmp(function->name, "main") == 0);
> + assert(function->impl);
> + nir_foreach_block(function->impl, setup_system_values_block, this);
> }
> }
>
> diff --git a/src/mesa/program/prog_to_nir.c b/src/mesa/program/prog_to_nir.c
> index 14a339c..c5d4f27 100644
> --- a/src/mesa/program/prog_to_nir.c
> +++ b/src/mesa/program/prog_to_nir.c
> @@ -1098,8 +1098,7 @@ prog_to_nir(const struct gl_program *prog,
> }
>
> nir_function *func = nir_function_create(s, "main");
> - nir_function_overload *overload = nir_function_overload_create(func);
> - nir_function_impl *impl = nir_function_impl_create(overload);
> + nir_function_impl *impl = nir_function_impl_create(func);
>
> c->build.shader = s;
> c->build.impl = impl;
> --
> 2.5.0.400.gff86faf
>
> _______________________________________________
> mesa-dev mailing list
> mesa-dev at lists.freedesktop.org
> http://lists.freedesktop.org/mailman/listinfo/mesa-dev
More information about the mesa-dev
mailing list