On Sat, Dec 26, 2015 at 2:09 PM, Jason Ekstrand <ja...@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@lists.freedesktop.org > http://lists.freedesktop.org/mailman/listinfo/mesa-dev _______________________________________________ mesa-dev mailing list mesa-dev@lists.freedesktop.org http://lists.freedesktop.org/mailman/listinfo/mesa-dev