nir/spirv: add gl_spirv_validation method

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

diff --git a/src/compiler/nir/nir_lower_atomics.c b/src/compiler/nir/nir_lower_atomics.c
index 1e2d65b98017dd9b841fd729a47f1b8f8f7bc920..6b046bc426ea9a095eab73ea809ec217cb51e377 100644 (file)
--- a/src/compiler/nir/nir_lower_atomics.c
+++ b/src/compiler/nir/nir_lower_atomics.c
@@ -35,10 +35,10 @@
  * that directly store the buffer index and byte offset
  */
 
-static void
+static bool
 lower_instr(nir_intrinsic_instr *instr,
             const struct gl_shader_program *shader_program,
-            nir_shader *shader)
+            nir_shader *shader, bool use_binding_as_idx)
 {
    nir_intrinsic_op op;
    switch (instr->intrinsic) {
@@ -54,21 +54,56 @@ lower_instr(nir_intrinsic_instr *instr,
       op = nir_intrinsic_atomic_counter_dec;
       break;
 
+   case nir_intrinsic_atomic_counter_add_var:
+      op = nir_intrinsic_atomic_counter_add;
+      break;
+
+   case nir_intrinsic_atomic_counter_min_var:
+      op = nir_intrinsic_atomic_counter_min;
+      break;
+
+   case nir_intrinsic_atomic_counter_max_var:
+      op = nir_intrinsic_atomic_counter_max;
+      break;
+
+   case nir_intrinsic_atomic_counter_and_var:
+      op = nir_intrinsic_atomic_counter_and;
+      break;
+
+   case nir_intrinsic_atomic_counter_or_var:
+      op = nir_intrinsic_atomic_counter_or;
+      break;
+
+   case nir_intrinsic_atomic_counter_xor_var:
+      op = nir_intrinsic_atomic_counter_xor;
+      break;
+
+   case nir_intrinsic_atomic_counter_exchange_var:
+      op = nir_intrinsic_atomic_counter_exchange;
+      break;
+
+   case nir_intrinsic_atomic_counter_comp_swap_var:
+      op = nir_intrinsic_atomic_counter_comp_swap;
+      break;
+
    default:
-      return;
+      return false;
    }
 
    if (instr->variables[0]->var->data.mode != nir_var_uniform &&
        instr->variables[0]->var->data.mode != nir_var_shader_storage &&
        instr->variables[0]->var->data.mode != nir_var_shared)
-      return; /* atomics passed as function arguments can't be lowered */
+      return false; /* atomics passed as function arguments can't be lowered */
 
    void *mem_ctx = ralloc_parent(instr);
    unsigned uniform_loc = instr->variables[0]->var->data.location;
 
+   unsigned idx = use_binding_as_idx ?
+      instr->variables[0]->var->data.binding :
+      shader_program->data->UniformStorage[uniform_loc].opaque[shader->info.stage].index;
+
    nir_intrinsic_instr *new_instr = nir_intrinsic_instr_create(mem_ctx, op);
-   nir_intrinsic_set_base(new_instr,
-      shader_program->UniformStorage[uniform_loc].opaque[shader->stage].index);
+   nir_intrinsic_set_base(new_instr, idx);
 
    nir_load_const_instr *offset_const =
       nir_load_const_instr_create(mem_ctx, 1, 32);
@@ -80,7 +115,6 @@ lower_instr(nir_intrinsic_instr *instr,
 
    nir_deref *tail = &instr->variables[0]->deref;
    while (tail->child != NULL) {
-      assert(tail->child->deref_type == nir_deref_type_array);
       nir_deref_array *deref_array = nir_deref_as_array(tail->child);
       tail = tail->child;
 
@@ -120,6 +154,12 @@ lower_instr(nir_intrinsic_instr *instr,
    new_instr->src[0].is_ssa = true;
    new_instr->src[0].ssa = offset_def;
 
+   /* Copy the other sources, if any, from the original instruction to the new
+    * instruction.
+    */
+   for (unsigned i = 0; i < nir_intrinsic_infos[instr->intrinsic].num_srcs; i++)
+      nir_src_copy(&new_instr->src[i + 1], &instr->src[i], new_instr);
+
    if (instr->dest.is_ssa) {
       nir_ssa_dest_init(&new_instr->instr, &new_instr->dest,
                         instr->dest.ssa.num_components, 32, NULL);
@@ -131,19 +171,25 @@ lower_instr(nir_intrinsic_instr *instr,
 
    nir_instr_insert_before(&instr->instr, &new_instr->instr);
    nir_instr_remove(&instr->instr);
+
+   return true;
 }
 
-void
+bool
 nir_lower_atomics(nir_shader *shader,
-                  const struct gl_shader_program *shader_program)
+                  const struct gl_shader_program *shader_program,
+                  bool use_binding_as_idx)
 {
-   nir_foreach_function(shader, function) {
+   bool progress = false;
+
+   nir_foreach_function(function, shader) {
       if (function->impl) {
          nir_foreach_block(block, function->impl) {
             nir_foreach_instr_safe(instr, block) {
                if (instr->type == nir_instr_type_intrinsic)
-                  lower_instr(nir_instr_as_intrinsic(instr),
-                              shader_program, shader);
+                  progress |= lower_instr(nir_instr_as_intrinsic(instr),
+                                          shader_program, shader,
+                                          use_binding_as_idx);
             }
          }
 
@@ -151,4 +197,6 @@ nir_lower_atomics(nir_shader *shader,
                                                nir_metadata_dominance);
       }
    }
+
+   return progress;
 }