nir: rename nir_var_function to nir_var_function_temp

Signed-off-by: Karol Herbst <kherbst@redhat.com>
Acked-by: Jason Ekstrand <jason@jlekstrand.net>
Reviewed-by: Eric Anholt <eric@anholt.net>
Reviewed-by: Kenneth Graunke <kenneth@whitecape.org>
Reviewed-by: Bas Nieuwenhuizen <bas@basnieuwenhuizen.nl>

diff --git a/src/amd/common/ac_nir_to_llvm.c b/src/amd/common/ac_nir_to_llvm.c
index 2701ebbd78e3cbfbc5d7c6112c92bd233af9f498..e3475e1e94f4a4ca5d153428bd85191fb82e75da 100644 (file)
--- a/src/amd/common/ac_nir_to_llvm.c
+++ b/src/amd/common/ac_nir_to_llvm.c
@@ -1946,7 +1946,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_function:
+       case nir_var_function_temp:
                for (unsigned chan = 0; chan < ve; chan++) {
                        if (indir_index) {
                                unsigned count = glsl_count_attribute_slots(
@@ -2078,7 +2078,7 @@ visit_store_var(struct ac_nir_context *ctx,
                        }
                }
                break;
-       case nir_var_function:
+       case nir_var_function_temp:
                for (unsigned chan = 0; chan < 8; chan++) {
                        if (!(writemask & (1 << chan)))
                                continue;
@@ -4146,7 +4146,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_function;
+       indirect_mask |= nir_var_function_temp;
 
        nir_lower_indirect_derefs(nir, indirect_mask);
 }

diff --git a/src/amd/vulkan/radv_shader.c b/src/amd/vulkan/radv_shader.c
index 7d78f62c2c48bec57c6d6191f85e8ccd0faa73e0..42f5e4efe6c64bdd5f3c9293e138eb39b379663e 100644 (file)
--- 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_function);
-               NIR_PASS(progress, shader, nir_shrink_vec_array_vars, nir_var_function);
+               NIR_PASS(progress, shader, nir_split_array_vars, nir_var_function_temp);
+               NIR_PASS(progress, shader, nir_shrink_vec_array_vars, nir_var_function_temp);
 
                 NIR_PASS_V(shader, nir_lower_vars_to_ssa);
                NIR_PASS_V(shader, nir_lower_pack);
@@ -267,7 +267,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_function);
+               NIR_PASS_V(nir, nir_lower_constant_initializers, nir_var_function_temp);
                NIR_PASS_V(nir, nir_lower_returns);
                NIR_PASS_V(nir, nir_inline_functions);
                NIR_PASS_V(nir, nir_opt_deref);
@@ -329,7 +329,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_function);
+       nir_remove_dead_variables(nir, nir_var_function_temp);
        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 f04e0d59ab1942b08f95bc1914851a52e4d7fdd8..7a96957f27ea34510c0a2a8f8b82d8378c86477d 100644 (file)
--- a/src/compiler/glsl/glsl_to_nir.cpp
+++ b/src/compiler/glsl/glsl_to_nir.cpp
@@ -326,12 +326,12 @@ nir_visitor::visit(ir_variable *ir)
       if (is_global)
          var->data.mode = nir_var_shader_temp;
       else
-         var->data.mode = nir_var_function;
+         var->data.mode = nir_var_function_temp;
       break;
 
    case ir_var_function_in:
    case ir_var_const_in:
-      var->data.mode = nir_var_function;
+      var->data.mode = nir_var_function_temp;
       break;
 
    case ir_var_shader_in:
@@ -460,7 +460,7 @@ nir_visitor::visit(ir_variable *ir)
 
    var->interface_type = ir->get_interface_type();
 
-   if (var->data.mode == nir_var_function)
+   if (var->data.mode == nir_var_function_temp)
       nir_function_impl_add_variable(impl, var);
    else
       nir_shader_add_variable(shader, var);
@@ -654,7 +654,7 @@ nir_visitor::visit(ir_return *ir)
    if (ir->value != NULL) {
       nir_deref_instr *ret_deref =
          nir_build_deref_cast(&b, nir_load_param(&b, 0),
-                              nir_var_function, ir->value->type, 0);
+                              nir_var_function_temp, ir->value->type, 0);
 
       nir_ssa_def *val = evaluate_rvalue(ir->value);
       nir_store_deref(&b, ret_deref, val, ~0);
@@ -2261,7 +2261,7 @@ nir_visitor::visit(ir_dereference_variable *ir)
       }
 
       this->deref = nir_build_deref_cast(&b, nir_load_param(&b, i),
-                                         nir_var_function, ir->type, 0);
+                                         nir_var_function_temp, ir->type, 0);
       return;
    }
 

diff --git a/src/compiler/nir/nir.c b/src/compiler/nir/nir.c
index 8a92be9f2253640ae87c363a6c118031161cb849..57ae2afc2e7a5c59c61880c3ba6c0befaef64d42 100644 (file)
--- a/src/compiler/nir/nir.c
+++ b/src/compiler/nir/nir.c
@@ -125,7 +125,7 @@ nir_shader_add_variable(nir_shader *shader, nir_variable *var)
       assert(!"invalid mode");
       break;
 
-   case nir_var_function:
+   case nir_var_function_temp:
       assert(!"nir_shader_add_variable cannot be used for local variables");
       break;
 
@@ -189,7 +189,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_function;
+   var->data.mode = nir_var_function_temp;
 
    nir_function_impl_add_variable(impl, var);
 

diff --git a/src/compiler/nir/nir.h b/src/compiler/nir/nir.h
index 534bdcd01c61d84afd8bdc44129bd0a550d9aeca..f09d0ddaea37928ffeca077c1bd5620eac659d6e 100644 (file)
--- a/src/compiler/nir/nir.h
+++ b/src/compiler/nir/nir.h
@@ -98,7 +98,7 @@ typedef enum {
    nir_var_shader_in       = (1 << 0),
    nir_var_shader_out      = (1 << 1),
    nir_var_shader_temp     = (1 << 2),
-   nir_var_function        = (1 << 3),
+   nir_var_function_temp   = (1 << 3),
    nir_var_uniform         = (1 << 4),
    nir_var_ubo             = (1 << 5),
    nir_var_system_value    = (1 << 6),
@@ -441,7 +441,7 @@ typedef struct nir_variable {
 static inline bool
 nir_variable_is_global(const nir_variable *var)
 {
-   return var->data.mode != nir_var_function;
+   return var->data.mode != nir_var_function_temp;
 }
 
 typedef struct nir_register {
@@ -2324,7 +2324,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_function);
+   assert(var->data.mode == nir_var_function_temp);
    exec_list_push_tail(&impl->locals, &var->node);
 }
 

diff --git a/src/compiler/nir/nir_inline_functions.c b/src/compiler/nir/nir_inline_functions.c
index 4e0bb8fcba138a6ece15a58c2b60980cab21b368..c57e16d2b4452b21882e236063c21fd27d37b69c 100644 (file)
--- a/src/compiler/nir/nir_inline_functions.c
+++ b/src/compiler/nir/nir_inline_functions.c
@@ -141,7 +141,7 @@ inline_function_impl(nir_function_impl *impl, struct set *inlined)
  * For most use-cases, function inlining is a multi-step process.  The general
  * pattern employed by SPIR-V consumers and others is as follows:
  *
- *  1. nir_lower_constant_initializers(shader, nir_var_function)
+ *  1. nir_lower_constant_initializers(shader, nir_var_function_temp)
  *
  *     This is needed because local variables from the callee are simply added
  *     to the locals list for the caller and the information about where the
@@ -196,7 +196,7 @@ inline_function_impl(nir_function_impl *impl, struct set *inlined)
  *    spirv_to_nir returns the root function and so we can just use == whereas
  *    with GL, you may have to look for a function named "main".
  *
- *  6. nir_lower_constant_initializers(shader, ~nir_var_function)
+ *  6. nir_lower_constant_initializers(shader, ~nir_var_function_temp)
  *
  *     Lowering constant initializers on inputs, outputs, global variables,
  *     etc. requires that we know the main entrypoint so that we know where to

diff --git a/src/compiler/nir/nir_lower_constant_initializers.c b/src/compiler/nir/nir_lower_constant_initializers.c
index cc100dde63c4eec7a9be9519aabb03c5403efcd4..f165f220f436ffebc660541ae4583715e0164e81 100644 (file)
--- a/src/compiler/nir/nir_lower_constant_initializers.c
+++ b/src/compiler/nir/nir_lower_constant_initializers.c
@@ -109,7 +109,7 @@ nir_lower_constant_initializers(nir_shader *shader, nir_variable_mode modes)
       if ((modes & nir_var_system_value) && function->is_entrypoint)
          impl_progress |= lower_const_initializer(&builder, &shader->system_values);
 
-      if (modes & nir_var_function)
+      if (modes & nir_var_function_temp)
          impl_progress |= lower_const_initializer(&builder, &function->impl->locals);
 
       if (impl_progress) {

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 64eb6a670ae38d11578e23433ef301f4df30564f..4df87aba366fdd93aceed69cca826b0e2fe7b9a0 100644 (file)
--- a/src/compiler/nir/nir_lower_global_vars_to_local.c
+++ b/src/compiler/nir/nir_lower_global_vars_to_local.c
@@ -91,7 +91,7 @@ nir_lower_global_vars_to_local(nir_shader *shader)
 
       if (impl != NULL) {
          exec_node_remove(&var->node);
-         var->data.mode = nir_var_function;
+         var->data.mode = nir_var_function_temp;
          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_locals_to_regs.c b/src/compiler/nir/nir_lower_locals_to_regs.c
index 3b77119b6f8fa8de26174a4ee8bb349d26db858f..88599f4978913d15e66dbf469622fdbf6e96b608 100644 (file)
--- 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_function)
+         if (deref->mode != nir_var_function_temp)
             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_function)
+         if (deref->mode != nir_var_function_temp)
             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 62f9ad8bccac9e8f843852d7d504bff6cee3ea53..065280fb9b8db5e95087715b5823bfc04d6c91fe 100644 (file)
--- 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_function)
+   if (deref->mode != nir_var_function_temp)
       return NULL;
 
    struct deref_node *node = get_deref_node_recur(deref, state);
@@ -504,7 +504,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_function)
+            if (deref->mode != nir_var_function_temp)
                continue;
 
             struct deref_node *node = get_deref_node(deref, state);
@@ -554,7 +554,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_function)
+            if (deref->mode != nir_var_function_temp)
                continue;
 
             struct deref_node *node = get_deref_node(deref, state);
@@ -680,7 +680,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_function);
+      assert(path->path[0]->var->data.mode == nir_var_function_temp);
 
       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 21e58b578f457a14ddb1f7c2acce11569e40e0b9..dee4824754918e3d64c6b685c15312aca19fd19a 100644 (file)
--- a/src/compiler/nir/nir_opt_copy_prop_vars.c
+++ b/src/compiler/nir/nir_opt_copy_prop_vars.c
@@ -134,7 +134,7 @@ gather_vars_written(struct copy_prop_var_state *state,
          if (instr->type == nir_instr_type_call) {
             written->modes |= nir_var_shader_out |
                               nir_var_shader_temp |
-                              nir_var_function |
+                              nir_var_function_temp |
                               nir_var_ssbo |
                               nir_var_shared;
             continue;
@@ -625,7 +625,7 @@ copy_prop_vars_block(struct copy_prop_var_state *state,
       if (instr->type == nir_instr_type_call) {
          apply_barrier_for_modes(copies, nir_var_shader_out |
                                          nir_var_shader_temp |
-                                         nir_var_function |
+                                         nir_var_function_temp |
                                          nir_var_ssbo |
                                          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 d8411e3cad9333db802a9f6649332d20fc7a8c30..01f3ce4a9751b3cb0ffa05e4063d471dfda99e2d 100644 (file)
--- a/src/compiler/nir/nir_opt_dead_write_vars.c
+++ b/src/compiler/nir/nir_opt_dead_write_vars.c
@@ -120,7 +120,7 @@ remove_dead_write_vars_local(void *mem_ctx, nir_block *block)
       if (instr->type == nir_instr_type_call) {
          clear_unused_for_modes(&unused_writes, nir_var_shader_out |
                                                 nir_var_shader_temp |
-                                                nir_var_function |
+                                                nir_var_function_temp |
                                                 nir_var_ssbo |
                                                 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 40ba5e21f2c8ac1752f1a32f92b6013ab2662c96..e50264c590032323c33f0091eda579f856f75c63 100644 (file)
--- 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_function)
+      if (dst_deref->mode != nir_var_function_temp)
          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_function | read_only_modes)))
+      if (!(src_deref->mode & (nir_var_function_temp | 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 282c73a40bdc13f3e2c29e0faa586fd0dacd0e31..74d9ceef87781e4c49d44c768c1c3de67e8d2b91 100644 (file)
--- a/src/compiler/nir/nir_opt_large_constants.c
+++ b/src/compiler/nir/nir_opt_large_constants.c
@@ -196,9 +196,9 @@ nir_opt_large_constants(nir_shader *shader,
             continue;
          }
 
-         if (dst_deref && dst_deref->mode == nir_var_function) {
+         if (dst_deref && dst_deref->mode == nir_var_function_temp) {
             nir_variable *var = nir_deref_instr_get_variable(dst_deref);
-            assert(var->data.mode == nir_var_function);
+            assert(var->data.mode == nir_var_function_temp);
 
             /* We only consider variables constant if they only have constant
              * stores, all the stores come before any reads, and all stores
@@ -210,9 +210,9 @@ nir_opt_large_constants(nir_shader *shader,
                info->is_constant = false;
          }
 
-         if (src_deref && src_deref->mode == nir_var_function) {
+         if (src_deref && src_deref->mode == nir_var_function_temp) {
             nir_variable *var = nir_deref_instr_get_variable(src_deref);
-            assert(var->data.mode == nir_var_function);
+            assert(var->data.mode == nir_var_function_temp);
 
             var_infos[var->data.index].found_read = true;
          }
@@ -258,7 +258,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_function)
+            if (deref->mode != nir_var_function_temp)
                continue;
 
             nir_variable *var = nir_deref_instr_get_variable(deref);
@@ -276,7 +276,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_function)
+            if (deref->mode != nir_var_function_temp)
                continue;
 
             nir_variable *var = nir_deref_instr_get_variable(deref);
@@ -292,7 +292,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_function)
+            if (deref->mode != nir_var_function_temp)
                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 f0142ab3b9261e1fd8a669e9ac953aa505712851..7e1ad61915b13f87a191192601f267a03e1c79a8 100644 (file)
--- a/src/compiler/nir/nir_print.c
+++ b/src/compiler/nir/nir_print.c
@@ -423,8 +423,8 @@ get_variable_mode_str(nir_variable_mode mode, bool want_local_global_mode)
       return "shared";
    case nir_var_shader_temp:
       return want_local_global_mode ? "shader_temp" : "";
-   case nir_var_function:
-      return want_local_global_mode ? "function" : "";
+   case nir_var_function_temp:
+      return want_local_global_mode ? "function_temp" : "";
    default:
       return "";
    }

diff --git a/src/compiler/nir/nir_remove_dead_variables.c b/src/compiler/nir/nir_remove_dead_variables.c
index 8804dfe610515fcf19accebf0449d7862359324f..8b28cb28118a24561655294ca4d06b29fc8cba9e 100644 (file)
--- 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_function | nir_var_shader_temp | nir_var_shared)) ||
+   if (!(deref->mode & (nir_var_function_temp | nir_var_shader_temp | nir_var_shared)) ||
        deref_used_for_not_store(deref))
       _mesa_set_add(live, deref->var);
 }
@@ -186,7 +186,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_function) {
+   if (modes & nir_var_function_temp) {
       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 6d4df61521aaff9b5cf0fc075e8ff08a02c11e5a..244ffd6dcf0ec467399c1b6878b8192a35422ff1 100644 (file)
--- a/src/compiler/nir/nir_split_vars.c
+++ b/src/compiler/nir/nir_split_vars.c
@@ -115,7 +115,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_function) {
+      if (mode == nir_var_function_temp) {
          field->var = nir_local_variable_create(state->impl, var_type, name);
       } else {
          field->var = nir_variable_create(state->shader, mode, var_type, name);
@@ -259,7 +259,7 @@ nir_split_struct_vars(nir_shader *shader, nir_variable_mode modes)
    struct hash_table *var_field_map =
       _mesa_pointer_hash_table_create(mem_ctx);
 
-   assert((modes & (nir_var_shader_temp | nir_var_function)) == modes);
+   assert((modes & (nir_var_shader_temp | nir_var_function_temp)) == modes);
 
    bool has_global_splits = false;
    if (modes & nir_var_shader_temp) {
@@ -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_function) {
+      if (modes & nir_var_function_temp) {
          has_local_splits = split_var_list_structs(shader, function->impl,
                                                    &function->impl->locals,
                                                    var_field_map, mem_ctx);
@@ -454,7 +454,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_function) {
+      if (mode == nir_var_function_temp) {
          split->var = nir_local_variable_create(impl,
                                                 var_info->split_var_type, name);
       } else {
@@ -794,7 +794,7 @@ nir_split_array_vars(nir_shader *shader, nir_variable_mode modes)
    void *mem_ctx = ralloc_context(NULL);
    struct hash_table *var_info_map = _mesa_pointer_hash_table_create(mem_ctx);
 
-   assert((modes & (nir_var_shader_temp | nir_var_function)) == modes);
+   assert((modes & (nir_var_shader_temp | nir_var_function_temp)) == modes);
 
    bool has_global_array = false;
    if (modes & nir_var_shader_temp) {
@@ -808,7 +808,7 @@ nir_split_array_vars(nir_shader *shader, nir_variable_mode modes)
          continue;
 
       bool has_local_array = false;
-      if (modes & nir_var_function) {
+      if (modes & nir_var_function_temp) {
          has_local_array = init_var_list_array_infos(&function->impl->locals,
                                                      var_info_map, mem_ctx);
       }
@@ -838,7 +838,7 @@ nir_split_array_vars(nir_shader *shader, nir_variable_mode modes)
          continue;
 
       bool has_local_splits = false;
-      if (modes & nir_var_function) {
+      if (modes & nir_var_function_temp) {
          has_local_splits = split_var_list_arrays(shader, function->impl,
                                                   &function->impl->locals,
                                                   var_info_map, mem_ctx);
@@ -1494,7 +1494,7 @@ function_impl_has_vars_with_modes(nir_function_impl *impl,
    if ((modes & nir_var_shader_temp) && !exec_list_is_empty(&shader->globals))
       return true;
 
-   if ((modes & nir_var_function) && !exec_list_is_empty(&impl->locals))
+   if ((modes & nir_var_function_temp) && !exec_list_is_empty(&impl->locals))
       return true;
 
    return false;
@@ -1512,7 +1512,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_shader_temp | nir_var_function)) == modes);
+   assert((modes & (nir_var_shader_temp | nir_var_function_temp)) == modes);
 
    void *mem_ctx = ralloc_context(NULL);
 
@@ -1549,7 +1549,7 @@ nir_shrink_vec_array_vars(nir_shader *shader, nir_variable_mode modes)
          continue;
 
       bool locals_shrunk = false;
-      if (modes & nir_var_function) {
+      if (modes & nir_var_function_temp) {
          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 c9732edda14c37cc7d047ae074fd11f2489278f3..43757858207ab3664918780d4719e5ebdfc9da10 100644 (file)
--- a/src/compiler/nir/nir_validate.c
+++ b/src/compiler/nir/nir_validate.c
@@ -395,7 +395,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_function)
+   if (var->data.mode == nir_var_function_temp)
       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 43d87f378addd0c366abae053b74f519ba0aff29..c94fab95c1b6b68d7fb6e7a119d7c1f929fb4157 100644 (file)
--- 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_function)
+      if (mode == nir_var_function_temp)
          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_function)
+      if (mode == nir_var_function_temp)
          return nir_local_variable_create(b->impl, var_type, name);
       return nir_variable_create(b->shader, mode, var_type, name);
    }
@@ -258,9 +258,9 @@ 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_function,   "temp");
-   nir_variable *out  = create_int(nir_var_shader_out, "out");
+   nir_variable *in   = create_int(nir_var_shader_in,     "in");
+   nir_variable *temp = create_int(nir_var_function_temp, "temp");
+   nir_variable *out  = create_int(nir_var_shader_out,    "out");
 
    nir_copy_var(b, temp, in);
    nir_copy_var(b, out, temp);
@@ -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_function, "v", 2);
+   nir_variable **v = create_many_ivec2(nir_var_function_temp, "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_function, "v", 2);
+   nir_variable **v = create_many_ivec2(nir_var_function_temp, "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_function, "v", 2);
+   nir_variable **v = create_many_ivec2(nir_var_function_temp, "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_function, "v", 2);
+   nir_variable **v = create_many_ivec2(nir_var_function_temp, "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_function, "v", 2);
+   nir_variable **v = create_many_ivec2(nir_var_function_temp, "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 dde5b972a297ba65acb4abc53ac0f38a122b5b72..36dbb540463c763c9a66b1383af23289700214f7 100644 (file)
--- a/src/compiler/spirv/vtn_cfg.c
+++ b/src/compiler/spirv/vtn_cfg.c
@@ -908,7 +908,7 @@ vtn_emit_cf_list(struct vtn_builder *b, struct list_head *cf_list,
                glsl_get_bare_type(b->func->type->return_type->type);
             nir_deref_instr *ret_deref =
                nir_build_deref_cast(&b->nb, nir_load_param(&b->nb, 0),
-                                    nir_var_function, ret_type, 0);
+                                    nir_var_function_temp, ret_type, 0);
             vtn_local_store(b, src, ret_deref);
          }
 

diff --git a/src/compiler/spirv/vtn_variables.c b/src/compiler/spirv/vtn_variables.c
index 9f42039aa25f6ee8ab2f6d6c2ebda3cc3ff10518..16cc7aadd718f75a14cf2565b651d0254fb573fe 100644 (file)
--- a/src/compiler/spirv/vtn_variables.c
+++ b/src/compiler/spirv/vtn_variables.c
@@ -1698,7 +1698,7 @@ vtn_storage_class_to_mode(struct vtn_builder *b,
       break;
    case SpvStorageClassFunction:
       mode = vtn_variable_mode_function;
-      nir_mode = nir_var_function;
+      nir_mode = nir_var_function_temp;
       break;
    case SpvStorageClassWorkgroup:
       mode = vtn_variable_mode_workgroup;

diff --git a/src/freedreno/ir3/ir3_nir.c b/src/freedreno/ir3/ir3_nir.c
index e865ac9820595f399a73a324583016e12974cd83..d9fcf798b3d986257556a2436c187db881e1f976 100644 (file)
--- 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_function);
+       OPT_V(s, nir_remove_dead_variables, nir_var_function_temp);
 
        OPT_V(s, nir_move_load_const);
 

diff --git a/src/gallium/drivers/v3d/v3d_program.c b/src/gallium/drivers/v3d/v3d_program.c
index de9cc9ad5c8c5475a6578c4f0f4310021b547462..a5b3f2ebfd9730dfc96d49cc9a27336a04f8ca4b 100644 (file)
--- a/src/gallium/drivers/v3d/v3d_program.c
+++ b/src/gallium/drivers/v3d/v3d_program.c
@@ -296,7 +296,7 @@ v3d_shader_state_create(struct pipe_context *pctx,
 
         v3d_optimize_nir(s);
 
-        NIR_PASS_V(s, nir_remove_dead_variables, nir_var_function);
+        NIR_PASS_V(s, nir_remove_dead_variables, nir_var_function_temp);
 
         /* 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 a0c009f424cce393d114184cd8bccfaec1a75f40..2d0a52bb5fb88a515f3081b1299b0e936d75c86a 100644 (file)
--- 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_function);
+                         nir_var_function_temp);
         } while (progress);
 }
 
@@ -2517,7 +2517,7 @@ vc4_shader_state_create(struct pipe_context *pctx,
 
         vc4_optimize_nir(s);
 
-        NIR_PASS_V(s, nir_remove_dead_variables, nir_var_function);
+        NIR_PASS_V(s, nir_remove_dead_variables, nir_var_function_temp);
 
         /* Garbage collect dead instructions */
         nir_sweep(s);

diff --git a/src/intel/compiler/brw_nir.c b/src/intel/compiler/brw_nir.c
index 92d7fe4bedebb962dcc76473c1cba4a2525acc99..0d4fa0218d2b131e3f52c4b2a39cd6a909fb8661 100644 (file)
--- 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_function;
+      indirect_mask |= nir_var_function_temp;
 
    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_function);
-      OPT(nir_shrink_vec_array_vars, nir_var_function);
+      OPT(nir_split_array_vars, nir_var_function_temp);
+      OPT(nir_shrink_vec_array_vars, nir_var_function_temp);
       OPT(nir_opt_deref);
       OPT(nir_lower_vars_to_ssa);
       if (allow_copies) {
@@ -619,7 +619,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_function);
+   OPT(nir_remove_dead_variables, nir_var_function_temp);
 
    return nir;
 }
@@ -714,7 +714,7 @@ brw_preprocess_nir(const struct brw_compiler *compiler, nir_shader *nir)
    } while (progress);
 
    if (lowered_64bit_ops) {
-      OPT(nir_lower_constant_initializers, nir_var_function);
+      OPT(nir_lower_constant_initializers, nir_var_function_temp);
       OPT(nir_lower_returns);
       OPT(nir_inline_functions);
       OPT(nir_opt_deref);
@@ -728,7 +728,7 @@ brw_preprocess_nir(const struct brw_compiler *compiler, nir_shader *nir)
    }
    assert(exec_list_length(&nir->functions) == 1);
 
-   OPT(nir_lower_constant_initializers, ~nir_var_function);
+   OPT(nir_lower_constant_initializers, ~nir_var_function_temp);
 
    if (nir->info.stage == MESA_SHADER_GEOMETRY)
       OPT(nir_lower_gs_intrinsics);
@@ -754,7 +754,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_function);
+   OPT(nir_split_struct_vars, nir_var_function_temp);
 
    nir = brw_nir_optimize(nir, compiler, is_scalar, true);
 

diff --git a/src/intel/vulkan/anv_pipeline.c b/src/intel/vulkan/anv_pipeline.c
index 899160746d47cffed07aa21d36d42f90bd12f166..e89b78ec1fc1d1cb8edf4a94ca81d0e942188ecb 100644 (file)
--- a/src/intel/vulkan/anv_pipeline.c
+++ b/src/intel/vulkan/anv_pipeline.c
@@ -183,7 +183,7 @@ anv_shader_compile_to_nir(struct anv_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_function);
+   NIR_PASS_V(nir, nir_lower_constant_initializers, nir_var_function_temp);
    NIR_PASS_V(nir, nir_lower_returns);
    NIR_PASS_V(nir, nir_inline_functions);
    NIR_PASS_V(nir, nir_opt_deref);
@@ -835,7 +835,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_function;
+         var->data.mode = nir_var_function_temp;
          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 acad6f42fc75dc1b3f5b02eb3c541af9be473a95..227971091e12d2fd78c098247c4553a4b6823208 100644 (file)
--- a/src/mesa/main/glspirv.c
+++ b/src/mesa/main/glspirv.c
@@ -243,7 +243,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_function);
+   NIR_PASS_V(nir, nir_lower_constant_initializers, nir_var_function_temp);
    NIR_PASS_V(nir, nir_lower_returns);
    NIR_PASS_V(nir, nir_inline_functions);
    NIR_PASS_V(nir, nir_opt_deref);

diff --git a/src/mesa/state_tracker/st_glsl_to_nir.cpp b/src/mesa/state_tracker/st_glsl_to_nir.cpp
index 31cc9faf0e6ba1cea669d6df93758ff72a078ed9..bf8d770db73bc1ebfca80fea37b90000a9b89ab9 100644 (file)
--- a/src/mesa/state_tracker/st_glsl_to_nir.cpp
+++ b/src/mesa/state_tracker/st_glsl_to_nir.cpp
@@ -616,7 +616,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_function;
+      nir_variable_mode indirect_mask = nir_var_function_temp;
 
       NIR_PASS_V(*producer, nir_lower_indirect_derefs, indirect_mask);
       NIR_PASS_V(*consumer, nir_lower_indirect_derefs, indirect_mask);