i965/vec4: split VEC4_OPCODE_FROM_DOUBLE into one opcode per destination's type

[mesa.git] / src / compiler / nir / nir_lower_var_copies.c

diff --git a/src/compiler/nir/nir_lower_var_copies.c b/src/compiler/nir/nir_lower_var_copies.c
index c994f0fe12c04d306ea40ee6e9332e4f7066f32c..6288bdc465b14cd503fd5c9c44990e898621285c 100644 (file)
--- a/src/compiler/nir/nir_lower_var_copies.c
+++ b/src/compiler/nir/nir_lower_var_copies.c
@@ -77,7 +77,8 @@ deref_next_wildcard_parent(nir_deref *deref)
 static void
 emit_copy_load_store(nir_intrinsic_instr *copy_instr,
                      nir_deref_var *dest_head, nir_deref_var *src_head,
-                     nir_deref *dest_tail, nir_deref *src_tail, void *mem_ctx)
+                     nir_deref *dest_tail, nir_deref *src_tail,
+                     nir_shader *shader)
 {
    /* Find the next pair of wildcards */
    nir_deref *src_arr_parent = deref_next_wildcard_parent(src_tail);
@@ -85,7 +86,7 @@ emit_copy_load_store(nir_intrinsic_instr *copy_instr,
 
    if (src_arr_parent || dest_arr_parent) {
       /* Wildcards had better come in matched pairs */
-      assert(dest_arr_parent && dest_arr_parent);
+      assert(src_arr_parent && dest_arr_parent);
 
       nir_deref_array *src_arr = nir_deref_as_array(src_arr_parent->child);
       nir_deref_array *dest_arr = nir_deref_as_array(dest_arr_parent->child);
@@ -103,7 +104,7 @@ emit_copy_load_store(nir_intrinsic_instr *copy_instr,
          src_arr->base_offset = i;
          dest_arr->base_offset = i;
          emit_copy_load_store(copy_instr, dest_head, src_head,
-                              &dest_arr->deref, &src_arr->deref, mem_ctx);
+                              &dest_arr->deref, &src_arr->deref, shader);
       }
       src_arr->deref_array_type = nir_deref_array_type_wildcard;
       dest_arr->deref_array_type = nir_deref_array_type_wildcard;
@@ -116,23 +117,22 @@ emit_copy_load_store(nir_intrinsic_instr *copy_instr,
       assert(src_tail->type == dest_tail->type);
 
       unsigned num_components = glsl_get_vector_elements(src_tail->type);
-      unsigned bit_size =
-         glsl_get_bit_size(glsl_get_base_type(src_tail->type));
+      unsigned bit_size = glsl_get_bit_size(src_tail->type);
 
       nir_intrinsic_instr *load =
-         nir_intrinsic_instr_create(mem_ctx, nir_intrinsic_load_var);
+         nir_intrinsic_instr_create(shader, nir_intrinsic_load_var);
       load->num_components = num_components;
-      load->variables[0] = nir_deref_as_var(nir_copy_deref(load, &src_head->deref));
+      load->variables[0] = nir_deref_var_clone(src_head, load);
       nir_ssa_dest_init(&load->instr, &load->dest, num_components, bit_size,
                         NULL);
 
       nir_instr_insert_before(&copy_instr->instr, &load->instr);
 
       nir_intrinsic_instr *store =
-         nir_intrinsic_instr_create(mem_ctx, nir_intrinsic_store_var);
+         nir_intrinsic_instr_create(shader, nir_intrinsic_store_var);
       store->num_components = num_components;
       nir_intrinsic_set_write_mask(store, (1 << num_components) - 1);
-      store->variables[0] = nir_deref_as_var(nir_copy_deref(store, &dest_head->deref));
+      store->variables[0] = nir_deref_var_clone(dest_head, store);
 
       store->src[0].is_ssa = true;
       store->src[0].ssa = &load->dest.ssa;
@@ -146,48 +146,56 @@ emit_copy_load_store(nir_intrinsic_instr *copy_instr,
  * The new instructions are placed before the copy instruction in the IR.
  */
 void
-nir_lower_var_copy_instr(nir_intrinsic_instr *copy, void *mem_ctx)
+nir_lower_var_copy_instr(nir_intrinsic_instr *copy, nir_shader *shader)
 {
    assert(copy->intrinsic == nir_intrinsic_copy_var);
    emit_copy_load_store(copy, copy->variables[0], copy->variables[1],
                         &copy->variables[0]->deref,
-                        &copy->variables[1]->deref, mem_ctx);
+                        &copy->variables[1]->deref, shader);
 }
 
 static bool
-lower_var_copies_block(nir_block *block, void *mem_ctx)
+lower_var_copies_impl(nir_function_impl *impl)
 {
-   nir_foreach_instr_safe(block, instr) {
-      if (instr->type != nir_instr_type_intrinsic)
-         continue;
+   nir_shader *shader = impl->function->shader;
+   bool progress = false;
 
-      nir_intrinsic_instr *copy = nir_instr_as_intrinsic(instr);
-      if (copy->intrinsic != nir_intrinsic_copy_var)
-         continue;
+   nir_foreach_block(block, impl) {
+      nir_foreach_instr_safe(instr, block) {
+         if (instr->type != nir_instr_type_intrinsic)
+            continue;
 
-      nir_lower_var_copy_instr(copy, mem_ctx);
+         nir_intrinsic_instr *copy = nir_instr_as_intrinsic(instr);
+         if (copy->intrinsic != nir_intrinsic_copy_var)
+            continue;
 
-      nir_instr_remove(&copy->instr);
-      ralloc_free(copy);
+         nir_lower_var_copy_instr(copy, shader);
+
+         nir_instr_remove(&copy->instr);
+         progress = true;
+         ralloc_free(copy);
+      }
    }
 
-   return true;
-}
+   if (progress)
+      nir_metadata_preserve(impl, nir_metadata_block_index |
+                                  nir_metadata_dominance);
 
-static void
-lower_var_copies_impl(nir_function_impl *impl)
-{
-   nir_foreach_block(impl, lower_var_copies_block, ralloc_parent(impl));
+   return progress;
 }
 
 /* Lowers every copy_var instruction in the program to a sequence of
  * load/store instructions.
  */
-void
+bool
 nir_lower_var_copies(nir_shader *shader)
 {
-   nir_foreach_function(shader, function) {
+   bool progress = false;
+
+   nir_foreach_function(function, shader) {
       if (function->impl)
-         lower_var_copies_impl(function->impl);
+         progress |= lower_var_copies_impl(function->impl);
    }
+
+   return progress;
 }