Assuming it builds everywhere (probably best to double-check before pushing
anything)
Reviewed-by: Jason Ekstrand <ja...@jlekstrand.net>
On Tue, Dec 4, 2018 at 12:27 PM Karol Herbst <kher...@redhat.com> wrote:
> the naming is a bit confusing no matter how you look at it. Within SPIR-V
> "global" memory is memory accessible from all threads. glsl "global" memory
> normally refers to shader thread private memory declared at global scope.
> As
> we already use "shared" for memory shared across all thrads of a work group
> the solution where everybody could be happy with is to rename "global" to
> "private" and use "global" later for memory usually stored within system
> accessible memory (be it VRAM or system RAM if keeping SVM in mind).
> glsl "local" memory is memory only accessible within a function, while
> SPIR-V
> "local" memory is memory accessible within the same workgroup.
>
> v2: rename local to function as well
>
> Signed-off-by: Karol Herbst <kher...@redhat.com>
> ---
> src/amd/common/ac_nir_to_llvm.c | 6 ++--
> src/amd/vulkan/radv_shader.c | 8 ++---
> src/compiler/glsl/glsl_to_nir.cpp | 10 +++----
> src/compiler/nir/nir.c | 6 ++--
> src/compiler/nir/nir.h | 8 ++---
> src/compiler/nir/nir_linking_helpers.c | 2 +-
> src/compiler/nir/nir_lower_clip.c | 2 +-
> .../nir/nir_lower_constant_initializers.c | 6 ++--
> .../nir/nir_lower_global_vars_to_local.c | 6 ++--
> .../nir/nir_lower_io_to_temporaries.c | 2 +-
> src/compiler/nir/nir_lower_locals_to_regs.c | 4 +--
> src/compiler/nir/nir_lower_vars_to_ssa.c | 8 ++---
> src/compiler/nir/nir_opt_copy_prop_vars.c | 8 ++---
> src/compiler/nir/nir_opt_dead_write_vars.c | 4 +--
> src/compiler/nir/nir_opt_find_array_copies.c | 4 +--
> src/compiler/nir/nir_opt_large_constants.c | 14 ++++-----
> src/compiler/nir/nir_print.c | 8 ++---
> src/compiler/nir/nir_remove_dead_variables.c | 6 ++--
> src/compiler/nir/nir_split_vars.c | 30 +++++++++----------
> src/compiler/nir/nir_validate.c | 2 +-
> src/compiler/nir/tests/vars_tests.cpp | 18 +++++------
> src/compiler/spirv/vtn_cfg.c | 2 +-
> src/compiler/spirv/vtn_private.h | 2 +-
> src/compiler/spirv/vtn_variables.c | 8 ++---
> src/freedreno/ir3/ir3_nir.c | 2 +-
> src/gallium/auxiliary/nir/tgsi_to_nir.c | 2 +-
> src/gallium/drivers/v3d/v3d_program.c | 2 +-
> src/gallium/drivers/vc4/vc4_program.c | 4 +--
> src/intel/compiler/brw_nir.c | 10 +++----
> src/intel/vulkan/anv_pipeline.c | 4 +--
> src/mesa/main/glspirv.c | 2 +-
> src/mesa/state_tracker/st_glsl_to_nir.cpp | 4 +--
> 32 files changed, 102 insertions(+), 102 deletions(-)
>
> diff --git a/src/amd/common/ac_nir_to_llvm.c
> b/src/amd/common/ac_nir_to_llvm.c
> index 18e9b69f3c0..2d8a27a0ab9 100644
> --- a/src/amd/common/ac_nir_to_llvm.c
> +++ b/src/amd/common/ac_nir_to_llvm.c
> @@ -1923,7 +1923,7 @@ static LLVMValueRef visit_load_var(struct
> ac_nir_context *ctx,
> values[chan] = ctx->abi->inputs[idx + chan
> + const_index * stride];
> }
> break;
> - case nir_var_local:
> + case nir_var_function:
> for (unsigned chan = 0; chan < ve; chan++) {
> if (indir_index) {
> unsigned count =
> glsl_count_attribute_slots(
> @@ -2055,7 +2055,7 @@ visit_store_var(struct ac_nir_context *ctx,
> }
> }
> break;
> - case nir_var_local:
> + case nir_var_function:
> for (unsigned chan = 0; chan < 8; chan++) {
> if (!(writemask & (1 << chan)))
> continue;
> @@ -4061,7 +4061,7 @@ ac_lower_indirect_derefs(struct nir_shader *nir,
> enum chip_class chip_class)
> * See the following thread for more details of the problem:
> *
> https://lists.freedesktop.org/archives/mesa-dev/2017-July/162106.html
> */
> - indirect_mask |= nir_var_local;
> + indirect_mask |= nir_var_function;
>
> nir_lower_indirect_derefs(nir, indirect_mask);
> }
> diff --git a/src/amd/vulkan/radv_shader.c b/src/amd/vulkan/radv_shader.c
> index 456c462a230..fa15478ad2d 100644
> --- a/src/amd/vulkan/radv_shader.c
> +++ b/src/amd/vulkan/radv_shader.c
> @@ -126,8 +126,8 @@ radv_optimize_nir(struct nir_shader *shader, bool
> optimize_conservatively,
> do {
> progress = false;
>
> - NIR_PASS(progress, shader, nir_split_array_vars,
> nir_var_local);
> - NIR_PASS(progress, shader, nir_shrink_vec_array_vars,
> nir_var_local);
> + NIR_PASS(progress, shader, nir_split_array_vars,
> nir_var_function);
> + NIR_PASS(progress, shader, nir_shrink_vec_array_vars,
> nir_var_function);
>
> NIR_PASS_V(shader, nir_lower_vars_to_ssa);
> NIR_PASS_V(shader, nir_lower_pack);
> @@ -261,7 +261,7 @@ radv_shader_compile_to_nir(struct radv_device *device,
> * inline functions. That way they get properly
> initialized at the top
> * of the function and not at the top of its caller.
> */
> - NIR_PASS_V(nir, nir_lower_constant_initializers,
> nir_var_local);
> + NIR_PASS_V(nir, nir_lower_constant_initializers,
> nir_var_function);
> NIR_PASS_V(nir, nir_lower_returns);
> NIR_PASS_V(nir, nir_inline_functions);
> NIR_PASS_V(nir, nir_copy_prop);
> @@ -323,7 +323,7 @@ radv_shader_compile_to_nir(struct radv_device *device,
> nir_split_var_copies(nir);
>
> nir_lower_global_vars_to_local(nir);
> - nir_remove_dead_variables(nir, nir_var_local);
> + nir_remove_dead_variables(nir, nir_var_function);
> nir_lower_subgroups(nir, &(struct nir_lower_subgroups_options) {
> .subgroup_size = 64,
> .ballot_bit_size = 64,
> diff --git a/src/compiler/glsl/glsl_to_nir.cpp
> b/src/compiler/glsl/glsl_to_nir.cpp
> index 5e70d230550..259806f03c9 100644
> --- a/src/compiler/glsl/glsl_to_nir.cpp
> +++ b/src/compiler/glsl/glsl_to_nir.cpp
> @@ -310,16 +310,16 @@ nir_visitor::visit(ir_variable *ir)
> case ir_var_auto:
> case ir_var_temporary:
> if (is_global)
> - var->data.mode = nir_var_global;
> + var->data.mode = nir_var_private;
> else
> - var->data.mode = nir_var_local;
> + var->data.mode = nir_var_function;
> break;
>
> case ir_var_function_in:
> case ir_var_function_out:
> case ir_var_function_inout:
> case ir_var_const_in:
> - var->data.mode = nir_var_local;
> + var->data.mode = nir_var_function;
> break;
>
> case ir_var_shader_in:
> @@ -445,7 +445,7 @@ nir_visitor::visit(ir_variable *ir)
>
> var->interface_type = ir->get_interface_type();
>
> - if (var->data.mode == nir_var_local)
> + if (var->data.mode == nir_var_function)
> nir_function_impl_add_variable(impl, var);
> else
> nir_shader_add_variable(shader, var);
> @@ -1444,7 +1444,7 @@ nir_visitor::visit(ir_expression *ir)
> * sense, we'll just turn it into a load which will probably
> * eventually end up as an SSA definition.
> */
> - assert(this->deref->mode == nir_var_global);
> + assert(this->deref->mode == nir_var_private);
> op = nir_intrinsic_load_deref;
> }
>
> diff --git a/src/compiler/nir/nir.c b/src/compiler/nir/nir.c
> index 03199856cc2..45c4a3e8375 100644
> --- a/src/compiler/nir/nir.c
> +++ b/src/compiler/nir/nir.c
> @@ -125,11 +125,11 @@ nir_shader_add_variable(nir_shader *shader,
> nir_variable *var)
> assert(!"invalid mode");
> break;
>
> - case nir_var_local:
> + case nir_var_function:
> assert(!"nir_shader_add_variable cannot be used for local
> variables");
> break;
>
> - case nir_var_global:
> + case nir_var_private:
> exec_list_push_tail(&shader->globals, &var->node);
> break;
>
> @@ -188,7 +188,7 @@ nir_local_variable_create(nir_function_impl *impl,
> nir_variable *var = rzalloc(impl->function->shader, nir_variable);
> var->name = ralloc_strdup(var, name);
> var->type = type;
> - var->data.mode = nir_var_local;
> + var->data.mode = nir_var_function;
>
> nir_function_impl_add_variable(impl, var);
>
> diff --git a/src/compiler/nir/nir.h b/src/compiler/nir/nir.h
> index a111e87ed71..30d22fb9d7d 100644
> --- a/src/compiler/nir/nir.h
> +++ b/src/compiler/nir/nir.h
> @@ -97,8 +97,8 @@ typedef struct {
> typedef enum {
> nir_var_shader_in = (1 << 0),
> nir_var_shader_out = (1 << 1),
> - nir_var_global = (1 << 2),
> - nir_var_local = (1 << 3),
> + nir_var_private = (1 << 2),
> + nir_var_function = (1 << 3),
> nir_var_uniform = (1 << 4),
> nir_var_shader_storage = (1 << 5),
> nir_var_system_value = (1 << 6),
> @@ -439,7 +439,7 @@ typedef struct nir_variable {
> static inline bool
> nir_variable_is_global(const nir_variable *var)
> {
> - return var->data.mode != nir_var_local;
> + return var->data.mode != nir_var_function;
> }
>
> typedef struct nir_register {
> @@ -2291,7 +2291,7 @@ void nir_shader_add_variable(nir_shader *shader,
> nir_variable *var);
> static inline void
> nir_function_impl_add_variable(nir_function_impl *impl, nir_variable *var)
> {
> - assert(var->data.mode == nir_var_local);
> + assert(var->data.mode == nir_var_function);
> exec_list_push_tail(&impl->locals, &var->node);
> }
>
> diff --git a/src/compiler/nir/nir_linking_helpers.c
> b/src/compiler/nir/nir_linking_helpers.c
> index a05890ada43..d8358e08e5a 100644
> --- a/src/compiler/nir/nir_linking_helpers.c
> +++ b/src/compiler/nir/nir_linking_helpers.c
> @@ -134,7 +134,7 @@ nir_remove_unused_io_vars(nir_shader *shader, struct
> exec_list *var_list,
> if (!(other_stage & get_variable_io_mask(var, shader->info.stage)))
> {
> /* This one is invalid, make it a global variable instead */
> var->data.location = 0;
> - var->data.mode = nir_var_global;
> + var->data.mode = nir_var_private;
>
> exec_node_remove(&var->node);
> exec_list_push_tail(&shader->globals, &var->node);
> diff --git a/src/compiler/nir/nir_lower_clip.c
> b/src/compiler/nir/nir_lower_clip.c
> index 880d65c617b..6fdf1a9b008 100644
> --- a/src/compiler/nir/nir_lower_clip.c
> +++ b/src/compiler/nir/nir_lower_clip.c
> @@ -212,7 +212,7 @@ nir_lower_clip_vs(nir_shader *shader, unsigned
> ucp_enables, bool use_vars)
>
> if (clipvertex) {
> exec_node_remove(&clipvertex->node);
> - clipvertex->data.mode = nir_var_global;
> + clipvertex->data.mode = nir_var_private;
> exec_list_push_tail(&shader->globals, &clipvertex->node);
> }
> } else {
> diff --git a/src/compiler/nir/nir_lower_constant_initializers.c
> b/src/compiler/nir/nir_lower_constant_initializers.c
> index 4e9cea46157..b213576bbd5 100644
> --- a/src/compiler/nir/nir_lower_constant_initializers.c
> +++ b/src/compiler/nir/nir_lower_constant_initializers.c
> @@ -92,13 +92,13 @@ nir_lower_constant_initializers(nir_shader *shader,
> nir_variable_mode modes)
> bool progress = false;
>
> nir_builder builder;
> - if (modes & ~nir_var_local)
> + if (modes & ~nir_var_function)
> nir_builder_init(&builder, nir_shader_get_entrypoint(shader));
>
> if (modes & nir_var_shader_out)
> progress |= lower_const_initializer(&builder, &shader->outputs);
>
> - if (modes & nir_var_global)
> + if (modes & nir_var_private)
> progress |= lower_const_initializer(&builder, &shader->globals);
>
> if (modes & nir_var_system_value)
> @@ -114,7 +114,7 @@ nir_lower_constant_initializers(nir_shader *shader,
> nir_variable_mode modes)
> }
> }
>
> - if (modes & nir_var_local) {
> + if (modes & nir_var_function) {
> nir_foreach_function(function, shader) {
> if (!function->impl)
> continue;
> diff --git a/src/compiler/nir/nir_lower_global_vars_to_local.c
> b/src/compiler/nir/nir_lower_global_vars_to_local.c
> index be99cf9ad02..7cc1b2cb69e 100644
> --- a/src/compiler/nir/nir_lower_global_vars_to_local.c
> +++ b/src/compiler/nir/nir_lower_global_vars_to_local.c
> @@ -36,7 +36,7 @@ static void
> register_var_use(nir_variable *var, nir_function_impl *impl,
> struct hash_table *var_func_table)
> {
> - if (var->data.mode != nir_var_global)
> + if (var->data.mode != nir_var_private)
> return;
>
> struct hash_entry *entry =
> @@ -89,11 +89,11 @@ nir_lower_global_vars_to_local(nir_shader *shader)
> nir_variable *var = (void *)entry->key;
> nir_function_impl *impl = entry->data;
>
> - assert(var->data.mode == nir_var_global);
> + assert(var->data.mode == nir_var_private);
>
> if (impl != NULL) {
> exec_node_remove(&var->node);
> - var->data.mode = nir_var_local;
> + var->data.mode = nir_var_function;
> exec_list_push_tail(&impl->locals, &var->node);
> nir_metadata_preserve(impl, nir_metadata_block_index |
> nir_metadata_dominance |
> diff --git a/src/compiler/nir/nir_lower_io_to_temporaries.c
> b/src/compiler/nir/nir_lower_io_to_temporaries.c
> index b83aaf46e6a..2487add33ed 100644
> --- a/src/compiler/nir/nir_lower_io_to_temporaries.c
> +++ b/src/compiler/nir/nir_lower_io_to_temporaries.c
> @@ -134,7 +134,7 @@ create_shadow_temp(struct lower_io_state *state,
> nir_variable *var)
> /* Give the original a new name with @<mode>-temp appended */
> const char *mode = (temp->data.mode == nir_var_shader_in) ? "in" :
> "out";
> temp->name = ralloc_asprintf(var, "%s@%s-temp", mode, nvar->name);
> - temp->data.mode = nir_var_global;
> + temp->data.mode = nir_var_private;
> temp->data.read_only = false;
> temp->data.fb_fetch_output = false;
> temp->data.compact = false;
> diff --git a/src/compiler/nir/nir_lower_locals_to_regs.c
> b/src/compiler/nir/nir_lower_locals_to_regs.c
> index 773b7fde6d0..3b77119b6f8 100644
> --- a/src/compiler/nir/nir_lower_locals_to_regs.c
> +++ b/src/compiler/nir/nir_lower_locals_to_regs.c
> @@ -192,7 +192,7 @@ lower_locals_to_regs_block(nir_block *block,
> switch (intrin->intrinsic) {
> case nir_intrinsic_load_deref: {
> nir_deref_instr *deref = nir_src_as_deref(intrin->src[0]);
> - if (deref->mode != nir_var_local)
> + if (deref->mode != nir_var_function)
> continue;
>
> b->cursor = nir_before_instr(&intrin->instr);
> @@ -218,7 +218,7 @@ lower_locals_to_regs_block(nir_block *block,
>
> case nir_intrinsic_store_deref: {
> nir_deref_instr *deref = nir_src_as_deref(intrin->src[0]);
> - if (deref->mode != nir_var_local)
> + if (deref->mode != nir_var_function)
> continue;
>
> b->cursor = nir_before_instr(&intrin->instr);
> diff --git a/src/compiler/nir/nir_lower_vars_to_ssa.c
> b/src/compiler/nir/nir_lower_vars_to_ssa.c
> index 646efd9ad89..98f3169f6ac 100644
> --- a/src/compiler/nir/nir_lower_vars_to_ssa.c
> +++ b/src/compiler/nir/nir_lower_vars_to_ssa.c
> @@ -208,7 +208,7 @@ get_deref_node(nir_deref_instr *deref, struct
> lower_variables_state *state)
> /* This pass only works on local variables. Just ignore any derefs
> with
> * a non-local mode.
> */
> - if (deref->mode != nir_var_local)
> + if (deref->mode != nir_var_function)
> return NULL;
>
> struct deref_node *node = get_deref_node_recur(deref, state);
> @@ -507,7 +507,7 @@ rename_variables(struct lower_variables_state *state)
> switch (intrin->intrinsic) {
> case nir_intrinsic_load_deref: {
> nir_deref_instr *deref = nir_src_as_deref(intrin->src[0]);
> - if (deref->mode != nir_var_local)
> + if (deref->mode != nir_var_function)
> continue;
>
> struct deref_node *node = get_deref_node(deref, state);
> @@ -557,7 +557,7 @@ rename_variables(struct lower_variables_state *state)
>
> case nir_intrinsic_store_deref: {
> nir_deref_instr *deref = nir_src_as_deref(intrin->src[0]);
> - if (deref->mode != nir_var_local)
> + if (deref->mode != nir_var_function)
> continue;
>
> struct deref_node *node = get_deref_node(deref, state);
> @@ -685,7 +685,7 @@ nir_lower_vars_to_ssa_impl(nir_function_impl *impl)
> assert(path->path[0]->deref_type == nir_deref_type_var);
>
> /* We don't build deref nodes for non-local variables */
> - assert(path->path[0]->var->data.mode == nir_var_local);
> + assert(path->path[0]->var->data.mode == nir_var_function);
>
> if (path_may_be_aliased(path, &state)) {
> exec_node_remove(&node->direct_derefs_link);
> diff --git a/src/compiler/nir/nir_opt_copy_prop_vars.c
> b/src/compiler/nir/nir_opt_copy_prop_vars.c
> index 48070cd5e31..2bf382c96b7 100644
> --- a/src/compiler/nir/nir_opt_copy_prop_vars.c
> +++ b/src/compiler/nir/nir_opt_copy_prop_vars.c
> @@ -134,8 +134,8 @@ gather_vars_written(struct copy_prop_var_state *state,
> nir_foreach_instr(instr, block) {
> if (instr->type == nir_instr_type_call) {
> written->modes |= nir_var_shader_out |
> - nir_var_global |
> - nir_var_local |
> + nir_var_private |
> + nir_var_function |
> nir_var_shader_storage |
> nir_var_shared;
> continue;
> @@ -603,8 +603,8 @@ copy_prop_vars_block(struct copy_prop_var_state *state,
> nir_foreach_instr_safe(instr, block) {
> if (instr->type == nir_instr_type_call) {
> apply_barrier_for_modes(copies, nir_var_shader_out |
> - nir_var_global |
> - nir_var_local |
> + nir_var_private |
> + nir_var_function |
> nir_var_shader_storage |
> nir_var_shared);
> continue;
> diff --git a/src/compiler/nir/nir_opt_dead_write_vars.c
> b/src/compiler/nir/nir_opt_dead_write_vars.c
> index dd949998cc8..a66f8035107 100644
> --- a/src/compiler/nir/nir_opt_dead_write_vars.c
> +++ b/src/compiler/nir/nir_opt_dead_write_vars.c
> @@ -120,8 +120,8 @@ remove_dead_write_vars_local(void *mem_ctx, nir_block
> *block)
> nir_foreach_instr_safe(instr, block) {
> if (instr->type == nir_instr_type_call) {
> clear_unused_for_modes(&unused_writes, nir_var_shader_out |
> - nir_var_global |
> - nir_var_local |
> + nir_var_private |
> + nir_var_function |
> nir_var_shader_storage |
> nir_var_shared);
> continue;
> diff --git a/src/compiler/nir/nir_opt_find_array_copies.c
> b/src/compiler/nir/nir_opt_find_array_copies.c
> index 5cfcd73b6b8..40ba5e21f2c 100644
> --- a/src/compiler/nir/nir_opt_find_array_copies.c
> +++ b/src/compiler/nir/nir_opt_find_array_copies.c
> @@ -225,7 +225,7 @@ opt_find_array_copies_block(nir_builder *b, nir_block
> *block,
> * continue on because it won't affect local stores or read-only
> * variables.
> */
> - if (dst_deref->mode != nir_var_local)
> + if (dst_deref->mode != nir_var_function)
> continue;
>
> /* We keep track of the SSA indices where the two last-written
> @@ -273,7 +273,7 @@ opt_find_array_copies_block(nir_builder *b, nir_block
> *block,
> */
> const nir_variable_mode read_only_modes =
> nir_var_shader_in | nir_var_uniform | nir_var_system_value;
> - if (!(src_deref->mode & (nir_var_local | read_only_modes)))
> + if (!(src_deref->mode & (nir_var_function | read_only_modes)))
> goto reset;
>
> /* If we don't yet have an active copy, then make this instruction
> the
> diff --git a/src/compiler/nir/nir_opt_large_constants.c
> b/src/compiler/nir/nir_opt_large_constants.c
> index 634913aa9e5..651f89cd1e6 100644
> --- a/src/compiler/nir/nir_opt_large_constants.c
> +++ b/src/compiler/nir/nir_opt_large_constants.c
> @@ -174,9 +174,9 @@ nir_opt_large_constants(nir_shader *shader,
> continue;
> }
>
> - if (dst_deref && dst_deref->mode == nir_var_local) {
> + if (dst_deref && dst_deref->mode == nir_var_function) {
> nir_variable *var = nir_deref_instr_get_variable(dst_deref);
> - assert(var->data.mode == nir_var_local);
> + assert(var->data.mode == nir_var_function);
>
> /* We only consider variables constant if they only have
> constant
> * stores, all the stores come before any reads, and all
> stores
> @@ -188,9 +188,9 @@ nir_opt_large_constants(nir_shader *shader,
> info->is_constant = false;
> }
>
> - if (src_deref && src_deref->mode == nir_var_local) {
> + if (src_deref && src_deref->mode == nir_var_function) {
> nir_variable *var = nir_deref_instr_get_variable(src_deref);
> - assert(var->data.mode == nir_var_local);
> + assert(var->data.mode == nir_var_function);
>
> var_infos[var->data.index].found_read = true;
> }
> @@ -236,7 +236,7 @@ nir_opt_large_constants(nir_shader *shader,
> switch (intrin->intrinsic) {
> case nir_intrinsic_load_deref: {
> nir_deref_instr *deref = nir_src_as_deref(intrin->src[0]);
> - if (deref->mode != nir_var_local)
> + if (deref->mode != nir_var_function)
> continue;
>
> nir_variable *var = nir_deref_instr_get_variable(deref);
> @@ -254,7 +254,7 @@ nir_opt_large_constants(nir_shader *shader,
>
> case nir_intrinsic_store_deref: {
> nir_deref_instr *deref = nir_src_as_deref(intrin->src[0]);
> - if (deref->mode != nir_var_local)
> + if (deref->mode != nir_var_function)
> continue;
>
> nir_variable *var = nir_deref_instr_get_variable(deref);
> @@ -270,7 +270,7 @@ nir_opt_large_constants(nir_shader *shader,
>
> case nir_intrinsic_copy_deref: {
> nir_deref_instr *deref = nir_src_as_deref(intrin->src[1]);
> - if (deref->mode != nir_var_local)
> + if (deref->mode != nir_var_function)
> continue;
>
> nir_variable *var = nir_deref_instr_get_variable(deref);
> diff --git a/src/compiler/nir/nir_print.c b/src/compiler/nir/nir_print.c
> index b8549f56eb8..1d409b1da7b 100644
> --- a/src/compiler/nir/nir_print.c
> +++ b/src/compiler/nir/nir_print.c
> @@ -409,10 +409,10 @@ get_variable_mode_str(nir_variable_mode mode, bool
> want_local_global_mode)
> return "system";
> case nir_var_shared:
> return "shared";
> - case nir_var_global:
> - return want_local_global_mode ? "global" : "";
> - case nir_var_local:
> - return want_local_global_mode ? "local" : "";
> + case nir_var_private:
> + return want_local_global_mode ? "private" : "";
> + case nir_var_function:
> + return want_local_global_mode ? "function" : "";
> default:
> return "";
> }
> diff --git a/src/compiler/nir/nir_remove_dead_variables.c
> b/src/compiler/nir/nir_remove_dead_variables.c
> index fadc51a6977..d802d6a60b4 100644
> --- a/src/compiler/nir/nir_remove_dead_variables.c
> +++ b/src/compiler/nir/nir_remove_dead_variables.c
> @@ -71,7 +71,7 @@ add_var_use_deref(nir_deref_instr *deref, struct set
> *live)
> * all means we need to keep it alive.
> */
> assert(deref->mode == deref->var->data.mode);
> - if (!(deref->mode & (nir_var_local | nir_var_global | nir_var_shared))
> ||
> + if (!(deref->mode & (nir_var_function | nir_var_private |
> nir_var_shared)) ||
> deref_used_for_not_store(deref))
> _mesa_set_add(live, deref->var);
> }
> @@ -175,7 +175,7 @@ nir_remove_dead_variables(nir_shader *shader,
> nir_variable_mode modes)
> if (modes & nir_var_shader_out)
> progress = remove_dead_vars(&shader->outputs, live) || progress;
>
> - if (modes & nir_var_global)
> + if (modes & nir_var_private)
> progress = remove_dead_vars(&shader->globals, live) || progress;
>
> if (modes & nir_var_system_value)
> @@ -184,7 +184,7 @@ nir_remove_dead_variables(nir_shader *shader,
> nir_variable_mode modes)
> if (modes & nir_var_shared)
> progress = remove_dead_vars(&shader->shared, live) || progress;
>
> - if (modes & nir_var_local) {
> + if (modes & nir_var_function) {
> nir_foreach_function(function, shader) {
> if (function->impl) {
> if (remove_dead_vars(&function->impl->locals, live))
> diff --git a/src/compiler/nir/nir_split_vars.c
> b/src/compiler/nir/nir_split_vars.c
> index bf9205c5150..2586b11d680 100644
> --- a/src/compiler/nir/nir_split_vars.c
> +++ b/src/compiler/nir/nir_split_vars.c
> @@ -114,7 +114,7 @@ init_field_for_type(struct field *field, struct field
> *parent,
> var_type = wrap_type_in_array(var_type, f->type);
>
> nir_variable_mode mode = state->base_var->data.mode;
> - if (mode == nir_var_local) {
> + if (mode == nir_var_function) {
> field->var = nir_local_variable_create(state->impl, var_type,
> name);
> } else {
> field->var = nir_variable_create(state->shader, mode, var_type,
> name);
> @@ -259,10 +259,10 @@ nir_split_struct_vars(nir_shader *shader,
> nir_variable_mode modes)
> _mesa_hash_table_create(mem_ctx, _mesa_hash_pointer,
> _mesa_key_pointer_equal);
>
> - assert((modes & (nir_var_global | nir_var_local)) == modes);
> + assert((modes & (nir_var_private | nir_var_function)) == modes);
>
> bool has_global_splits = false;
> - if (modes & nir_var_global) {
> + if (modes & nir_var_private) {
> has_global_splits = split_var_list_structs(shader, NULL,
> &shader->globals,
> var_field_map, mem_ctx);
> @@ -274,7 +274,7 @@ nir_split_struct_vars(nir_shader *shader,
> nir_variable_mode modes)
> continue;
>
> bool has_local_splits = false;
> - if (modes & nir_var_local) {
> + if (modes & nir_var_function) {
> has_local_splits = split_var_list_structs(shader, function->impl,
>
> &function->impl->locals,
> var_field_map,
> mem_ctx);
> @@ -453,7 +453,7 @@ create_split_array_vars(struct array_var_info
> *var_info,
> name = ralloc_asprintf(mem_ctx, "(%s)", name);
>
> nir_variable_mode mode = var_info->base_var->data.mode;
> - if (mode == nir_var_local) {
> + if (mode == nir_var_function) {
> split->var = nir_local_variable_create(impl,
> var_info->split_var_type,
> name);
> } else {
> @@ -795,10 +795,10 @@ nir_split_array_vars(nir_shader *shader,
> nir_variable_mode modes)
> _mesa_hash_table_create(mem_ctx, _mesa_hash_pointer,
> _mesa_key_pointer_equal);
>
> - assert((modes & (nir_var_global | nir_var_local)) == modes);
> + assert((modes & (nir_var_private | nir_var_function)) == modes);
>
> bool has_global_array = false;
> - if (modes & nir_var_global) {
> + if (modes & nir_var_private) {
> has_global_array = init_var_list_array_infos(&shader->globals,
> var_info_map, mem_ctx);
> }
> @@ -809,7 +809,7 @@ nir_split_array_vars(nir_shader *shader,
> nir_variable_mode modes)
> continue;
>
> bool has_local_array = false;
> - if (modes & nir_var_local) {
> + if (modes & nir_var_function) {
> has_local_array =
> init_var_list_array_infos(&function->impl->locals,
> var_info_map,
> mem_ctx);
> }
> @@ -827,7 +827,7 @@ nir_split_array_vars(nir_shader *shader,
> nir_variable_mode modes)
> }
>
> bool has_global_splits = false;
> - if (modes & nir_var_global) {
> + if (modes & nir_var_private) {
> has_global_splits = split_var_list_arrays(shader, NULL,
> &shader->globals,
> var_info_map, mem_ctx);
> @@ -839,7 +839,7 @@ nir_split_array_vars(nir_shader *shader,
> nir_variable_mode modes)
> continue;
>
> bool has_local_splits = false;
> - if (modes & nir_var_local) {
> + if (modes & nir_var_function) {
> has_local_splits = split_var_list_arrays(shader, function->impl,
> &function->impl->locals,
> var_info_map, mem_ctx);
> @@ -1494,10 +1494,10 @@
> function_impl_has_vars_with_modes(nir_function_impl *impl,
> {
> nir_shader *shader = impl->function->shader;
>
> - if ((modes & nir_var_global) && !exec_list_is_empty(&shader->globals))
> + if ((modes & nir_var_private) && !exec_list_is_empty(&shader->globals))
> return true;
>
> - if ((modes & nir_var_local) && !exec_list_is_empty(&impl->locals))
> + if ((modes & nir_var_function) && !exec_list_is_empty(&impl->locals))
> return true;
>
> return false;
> @@ -1515,7 +1515,7 @@ function_impl_has_vars_with_modes(nir_function_impl
> *impl,
> bool
> nir_shrink_vec_array_vars(nir_shader *shader, nir_variable_mode modes)
> {
> - assert((modes & (nir_var_global | nir_var_local)) == modes);
> + assert((modes & (nir_var_private | nir_var_function)) == modes);
>
> void *mem_ctx = ralloc_context(NULL);
>
> @@ -1544,7 +1544,7 @@ nir_shrink_vec_array_vars(nir_shader *shader,
> nir_variable_mode modes)
> }
>
> bool globals_shrunk = false;
> - if (modes & nir_var_global)
> + if (modes & nir_var_private)
> globals_shrunk = shrink_vec_var_list(&shader->globals,
> var_usage_map);
>
> bool progress = false;
> @@ -1553,7 +1553,7 @@ nir_shrink_vec_array_vars(nir_shader *shader,
> nir_variable_mode modes)
> continue;
>
> bool locals_shrunk = false;
> - if (modes & nir_var_local) {
> + if (modes & nir_var_function) {
> locals_shrunk = shrink_vec_var_list(&function->impl->locals,
> var_usage_map);
> }
> diff --git a/src/compiler/nir/nir_validate.c
> b/src/compiler/nir/nir_validate.c
> index 62893cad87e..7ee13da258d 100644
> --- a/src/compiler/nir/nir_validate.c
> +++ b/src/compiler/nir/nir_validate.c
> @@ -397,7 +397,7 @@ validate_var_use(nir_variable *var, validate_state
> *state)
> {
> struct hash_entry *entry = _mesa_hash_table_search(state->var_defs,
> var);
> validate_assert(state, entry);
> - if (var->data.mode == nir_var_local)
> + if (var->data.mode == nir_var_function)
> validate_assert(state, (nir_function_impl *) entry->data ==
> state->impl);
> }
>
> diff --git a/src/compiler/nir/tests/vars_tests.cpp
> b/src/compiler/nir/tests/vars_tests.cpp
> index 32763d2db64..102c47d3f79 100644
> --- a/src/compiler/nir/tests/vars_tests.cpp
> +++ b/src/compiler/nir/tests/vars_tests.cpp
> @@ -34,14 +34,14 @@ protected:
> ~nir_vars_test();
>
> nir_variable *create_int(nir_variable_mode mode, const char *name) {
> - if (mode == nir_var_local)
> + if (mode == nir_var_function)
> return nir_local_variable_create(b->impl, glsl_int_type(), name);
> return nir_variable_create(b->shader, mode, glsl_int_type(), name);
> }
>
> nir_variable *create_ivec2(nir_variable_mode mode, const char *name) {
> const glsl_type *var_type = glsl_vector_type(GLSL_TYPE_INT, 2);
> - if (mode == nir_var_local)
> + if (mode == nir_var_function)
> return nir_local_variable_create(b->impl, var_type, name);
> return nir_variable_create(b->shader, mode, var_type, name);
> }
> @@ -191,7 +191,7 @@ TEST_F(nir_redundant_load_vars_test,
> invalidate_inside_if_block)
> * if statement. They should be invalidated accordingly.
> */
>
> - nir_variable **g = create_many_int(nir_var_global, "g", 3);
> + nir_variable **g = create_many_int(nir_var_private, "g", 3);
> nir_variable **out = create_many_int(nir_var_shader_out, "out", 3);
>
> nir_load_var(b, g[0]);
> @@ -259,7 +259,7 @@ TEST_F(nir_redundant_load_vars_test,
> invalidate_live_load_in_the_end_of_loop)
> TEST_F(nir_copy_prop_vars_test, simple_copies)
> {
> nir_variable *in = create_int(nir_var_shader_in, "in");
> - nir_variable *temp = create_int(nir_var_local, "temp");
> + nir_variable *temp = create_int(nir_var_function, "temp");
> nir_variable *out = create_int(nir_var_shader_out, "out");
>
> nir_copy_var(b, temp, in);
> @@ -284,7 +284,7 @@ TEST_F(nir_copy_prop_vars_test, simple_copies)
>
> TEST_F(nir_copy_prop_vars_test, simple_store_load)
> {
> - nir_variable **v = create_many_ivec2(nir_var_local, "v", 2);
> + nir_variable **v = create_many_ivec2(nir_var_function, "v", 2);
> unsigned mask = 1 | 2;
>
> nir_ssa_def *stored_value = nir_imm_ivec2(b, 10, 20);
> @@ -312,7 +312,7 @@ TEST_F(nir_copy_prop_vars_test, simple_store_load)
>
> TEST_F(nir_copy_prop_vars_test, store_store_load)
> {
> - nir_variable **v = create_many_ivec2(nir_var_local, "v", 2);
> + nir_variable **v = create_many_ivec2(nir_var_function, "v", 2);
> unsigned mask = 1 | 2;
>
> nir_ssa_def *first_value = nir_imm_ivec2(b, 10, 20);
> @@ -345,7 +345,7 @@ TEST_F(nir_copy_prop_vars_test, store_store_load)
>
> TEST_F(nir_copy_prop_vars_test, store_store_load_different_components)
> {
> - nir_variable **v = create_many_ivec2(nir_var_local, "v", 2);
> + nir_variable **v = create_many_ivec2(nir_var_function, "v", 2);
>
> nir_ssa_def *first_value = nir_imm_ivec2(b, 10, 20);
> nir_store_var(b, v[0], first_value, 1 << 1);
> @@ -384,7 +384,7 @@ TEST_F(nir_copy_prop_vars_test,
> store_store_load_different_components)
>
> TEST_F(nir_copy_prop_vars_test,
> store_store_load_different_components_in_many_blocks)
> {
> - nir_variable **v = create_many_ivec2(nir_var_local, "v", 2);
> + nir_variable **v = create_many_ivec2(nir_var_function, "v", 2);
>
> nir_ssa_def *first_value = nir_imm_ivec2(b, 10, 20);
> nir_store_var(b, v[0], first_value, 1 << 1);
> @@ -459,7 +459,7 @@ TEST_F(nir_copy_prop_vars_test,
> memory_barrier_in_two_blocks)
>
> TEST_F(nir_copy_prop_vars_test, simple_store_load_in_two_blocks)
> {
> - nir_variable **v = create_many_ivec2(nir_var_local, "v", 2);
> + nir_variable **v = create_many_ivec2(nir_var_function, "v", 2);
> unsigned mask = 1 | 2;
>
> nir_ssa_def *stored_value = nir_imm_ivec2(b, 10, 20);
> diff --git a/src/compiler/spirv/vtn_cfg.c b/src/compiler/spirv/vtn_cfg.c
> index 726f717e8d5..5b3cc703f94 100644
> --- a/src/compiler/spirv/vtn_cfg.c
> +++ b/src/compiler/spirv/vtn_cfg.c
> @@ -876,7 +876,7 @@ vtn_emit_cf_list(struct vtn_builder *b, struct
> list_head *cf_list,
> struct vtn_ssa_value *src = vtn_ssa_value(b,
> block->branch[1]);
> nir_deref_instr *ret_deref =
> nir_build_deref_cast(&b->nb, nir_load_param(&b->nb, 0),
> - nir_var_local, src->type);
> + nir_var_function, src->type);
> vtn_local_store(b, src, ret_deref);
> }
>
> diff --git a/src/compiler/spirv/vtn_private.h
> b/src/compiler/spirv/vtn_private.h
> index 47f26dac642..b84ac2cf0b4 100644
> --- a/src/compiler/spirv/vtn_private.h
> +++ b/src/compiler/spirv/vtn_private.h
> @@ -411,7 +411,7 @@ struct vtn_access_chain {
>
> enum vtn_variable_mode {
> vtn_variable_mode_local,
> - vtn_variable_mode_global,
> + vtn_variable_mode_private,
> vtn_variable_mode_uniform,
> vtn_variable_mode_ubo,
> vtn_variable_mode_ssbo,
> diff --git a/src/compiler/spirv/vtn_variables.c
> b/src/compiler/spirv/vtn_variables.c
> index fe44e71800d..b911b114b70 100644
> --- a/src/compiler/spirv/vtn_variables.c
> +++ b/src/compiler/spirv/vtn_variables.c
> @@ -1566,12 +1566,12 @@ vtn_storage_class_to_mode(struct vtn_builder *b,
> nir_mode = nir_var_shader_out;
> break;
> case SpvStorageClassPrivate:
> - mode = vtn_variable_mode_global;
> - nir_mode = nir_var_global;
> + mode = vtn_variable_mode_private;
> + nir_mode = nir_var_private;
> break;
> case SpvStorageClassFunction:
> mode = vtn_variable_mode_local;
> - nir_mode = nir_var_local;
> + nir_mode = nir_var_function;
> break;
> case SpvStorageClassWorkgroup:
> mode = vtn_variable_mode_workgroup;
> @@ -1732,7 +1732,7 @@ vtn_create_variable(struct vtn_builder *b, struct
> vtn_value *val,
>
> switch (var->mode) {
> case vtn_variable_mode_local:
> - case vtn_variable_mode_global:
> + case vtn_variable_mode_private:
> case vtn_variable_mode_uniform:
> /* For these, we create the variable normally */
> var->var = rzalloc(b->shader, nir_variable);
> diff --git a/src/freedreno/ir3/ir3_nir.c b/src/freedreno/ir3/ir3_nir.c
> index 70c01ee0593..6a3830020d2 100644
> --- a/src/freedreno/ir3/ir3_nir.c
> +++ b/src/freedreno/ir3/ir3_nir.c
> @@ -194,7 +194,7 @@ ir3_optimize_nir(struct ir3_shader *shader, nir_shader
> *s,
> if (OPT(s, nir_lower_idiv))
> ir3_optimize_loop(s);
>
> - OPT_V(s, nir_remove_dead_variables, nir_var_local);
> + OPT_V(s, nir_remove_dead_variables, nir_var_function);
>
> OPT_V(s, nir_move_load_const);
>
> diff --git a/src/gallium/auxiliary/nir/tgsi_to_nir.c
> b/src/gallium/auxiliary/nir/tgsi_to_nir.c
> index 0ad274b535a..f0bcce0feb3 100644
> --- a/src/gallium/auxiliary/nir/tgsi_to_nir.c
> +++ b/src/gallium/auxiliary/nir/tgsi_to_nir.c
> @@ -182,7 +182,7 @@ ttn_emit_declaration(struct ttn_compile *c)
> nir_variable *var = rzalloc(b->shader, nir_variable);
>
> var->type = glsl_array_type(glsl_vec4_type(), array_size);
> - var->data.mode = nir_var_global;
> + var->data.mode = nir_var_private;
> var->name = ralloc_asprintf(var, "arr_%d", decl->Array.ArrayID);
>
> exec_list_push_tail(&b->shader->globals, &var->node);
> diff --git a/src/gallium/drivers/v3d/v3d_program.c
> b/src/gallium/drivers/v3d/v3d_program.c
> index 1dceade950a..7a9067bfc50 100644
> --- a/src/gallium/drivers/v3d/v3d_program.c
> +++ b/src/gallium/drivers/v3d/v3d_program.c
> @@ -225,7 +225,7 @@ v3d_shader_state_create(struct pipe_context *pctx,
>
> v3d_optimize_nir(s);
>
> - NIR_PASS_V(s, nir_remove_dead_variables, nir_var_local);
> + NIR_PASS_V(s, nir_remove_dead_variables, nir_var_function);
>
> /* Garbage collect dead instructions */
> nir_sweep(s);
> diff --git a/src/gallium/drivers/vc4/vc4_program.c
> b/src/gallium/drivers/vc4/vc4_program.c
> index b98baca30cf..143fc2849ec 100644
> --- a/src/gallium/drivers/vc4/vc4_program.c
> +++ b/src/gallium/drivers/vc4/vc4_program.c
> @@ -1598,7 +1598,7 @@ vc4_optimize_nir(struct nir_shader *s)
> NIR_PASS(progress, s, nir_opt_loop_unroll,
> nir_var_shader_in |
> nir_var_shader_out |
> - nir_var_local);
> + nir_var_function);
> } while (progress);
> }
>
> @@ -2515,7 +2515,7 @@ vc4_shader_state_create(struct pipe_context *pctx,
>
> vc4_optimize_nir(s);
>
> - NIR_PASS_V(s, nir_remove_dead_variables, nir_var_local);
> + NIR_PASS_V(s, nir_remove_dead_variables, nir_var_function);
>
> /* Garbage collect dead instructions */
> nir_sweep(s);
> diff --git a/src/intel/compiler/brw_nir.c b/src/intel/compiler/brw_nir.c
> index aa6788b9fe5..5dbcfefa829 100644
> --- a/src/intel/compiler/brw_nir.c
> +++ b/src/intel/compiler/brw_nir.c
> @@ -527,7 +527,7 @@ brw_nir_no_indirect_mask(const struct brw_compiler
> *compiler,
> if (compiler->glsl_compiler_options[stage].EmitNoIndirectOutput)
> indirect_mask |= nir_var_shader_out;
> if (compiler->glsl_compiler_options[stage].EmitNoIndirectTemp)
> - indirect_mask |= nir_var_local;
> + indirect_mask |= nir_var_function;
>
> return indirect_mask;
> }
> @@ -542,8 +542,8 @@ brw_nir_optimize(nir_shader *nir, const struct
> brw_compiler *compiler,
> bool progress;
> do {
> progress = false;
> - OPT(nir_split_array_vars, nir_var_local);
> - OPT(nir_shrink_vec_array_vars, nir_var_local);
> + OPT(nir_split_array_vars, nir_var_function);
> + OPT(nir_shrink_vec_array_vars, nir_var_function);
> OPT(nir_lower_vars_to_ssa);
> if (allow_copies) {
> /* Only run this pass in the first call to brw_nir_optimize.
> Later
> @@ -602,7 +602,7 @@ brw_nir_optimize(nir_shader *nir, const struct
> brw_compiler *compiler,
> /* Workaround Gfxbench unused local sampler variable which will
> trigger an
> * assert in the opt_large_constants pass.
> */
> - OPT(nir_remove_dead_variables, nir_var_local);
> + OPT(nir_remove_dead_variables, nir_var_function);
>
> return nir;
> }
> @@ -664,7 +664,7 @@ brw_preprocess_nir(const struct brw_compiler
> *compiler, nir_shader *nir)
> OPT(nir_lower_global_vars_to_local);
>
> OPT(nir_split_var_copies);
> - OPT(nir_split_struct_vars, nir_var_local);
> + OPT(nir_split_struct_vars, nir_var_function);
>
> /* Run opt_algebraic before int64 lowering so we can hopefully get rid
> * of some int64 instructions.
> diff --git a/src/intel/vulkan/anv_pipeline.c
> b/src/intel/vulkan/anv_pipeline.c
> index ee37685fccf..cd4eccccc9c 100644
> --- a/src/intel/vulkan/anv_pipeline.c
> +++ b/src/intel/vulkan/anv_pipeline.c
> @@ -180,7 +180,7 @@ anv_shader_compile_to_nir(struct anv_pipeline
> *pipeline,
> * inline functions. That way they get properly initialized at the top
> * of the function and not at the top of its caller.
> */
> - NIR_PASS_V(nir, nir_lower_constant_initializers, nir_var_local);
> + NIR_PASS_V(nir, nir_lower_constant_initializers, nir_var_function);
> NIR_PASS_V(nir, nir_lower_returns);
> NIR_PASS_V(nir, nir_inline_functions);
> NIR_PASS_V(nir, nir_copy_prop);
> @@ -780,7 +780,7 @@ anv_pipeline_link_fs(const struct brw_compiler
> *compiler,
> !(stage->key.wm.color_outputs_valid & (1 << rt))) {
> /* Unused or out-of-bounds, throw it away */
> deleted_output = true;
> - var->data.mode = nir_var_local;
> + var->data.mode = nir_var_function;
> exec_node_remove(&var->node);
> exec_list_push_tail(&impl->locals, &var->node);
> continue;
> diff --git a/src/mesa/main/glspirv.c b/src/mesa/main/glspirv.c
> index 04e46ba571e..06a964b7306 100644
> --- a/src/mesa/main/glspirv.c
> +++ b/src/mesa/main/glspirv.c
> @@ -242,7 +242,7 @@ _mesa_spirv_to_nir(struct gl_context *ctx,
> * inline functions. That way they get properly initialized at the top
> * of the function and not at the top of its caller.
> */
> - NIR_PASS_V(nir, nir_lower_constant_initializers, nir_var_local);
> + NIR_PASS_V(nir, nir_lower_constant_initializers, nir_var_function);
> NIR_PASS_V(nir, nir_lower_returns);
> NIR_PASS_V(nir, nir_inline_functions);
> NIR_PASS_V(nir, nir_copy_prop);
> diff --git a/src/mesa/state_tracker/st_glsl_to_nir.cpp
> b/src/mesa/state_tracker/st_glsl_to_nir.cpp
> index d0475fb538a..5ea1986103e 100644
> --- a/src/mesa/state_tracker/st_glsl_to_nir.cpp
> +++ b/src/mesa/state_tracker/st_glsl_to_nir.cpp
> @@ -103,7 +103,7 @@ st_nir_assign_vs_in_locations(struct gl_program *prog,
> nir_shader *nir)
> * set.
> */
> exec_node_remove(&var->node);
> - var->data.mode = nir_var_global;
> + var->data.mode = nir_var_private;
> exec_list_push_tail(&nir->globals, &var->node);
> }
> }
> @@ -609,7 +609,7 @@ st_nir_link_shaders(nir_shader **producer, nir_shader
> **consumer, bool scalar)
> * See the following thread for more details of the problem:
> *
> https://lists.freedesktop.org/archives/mesa-dev/2017-July/162106.html
> */
> - nir_variable_mode indirect_mask = nir_var_local;
> + nir_variable_mode indirect_mask = nir_var_function;
>
> NIR_PASS_V(*producer, nir_lower_indirect_derefs, indirect_mask);
> NIR_PASS_V(*consumer, nir_lower_indirect_derefs, indirect_mask);
> --
> 2.19.2
>
>
_______________________________________________
mesa-dev mailing list
mesa-dev@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/mesa-dev
