ac/nir: drop nir_to_llvm_context from visit_load_local_invocation_index()

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

diff --git a/src/compiler/nir/nir_opt_dead_cf.c b/src/compiler/nir/nir_opt_dead_cf.c
index 4cc6798702b3647e113db6c34d58cbdd8af6ea5d..53c92ecc28695ea4519d8bcf6f043cbf896b3c7b 100644 (file)
--- a/src/compiler/nir/nir_opt_dead_cf.c
+++ b/src/compiler/nir/nir_opt_dead_cf.c
@@ -30,7 +30,7 @@
 
 /*
  * This file implements an optimization that deletes statically
- * unreachable/dead code. In NIR, one way this can happen if if an if
+ * unreachable/dead code. In NIR, one way this can happen is when an if
  * statement has a constant condition:
  *
  * if (true) {
@@ -87,17 +87,16 @@ opt_constant_if(nir_if *if_stmt, bool condition)
     * point to the correct source.
     */
    nir_block *after = nir_cf_node_as_block(nir_cf_node_next(&if_stmt->cf_node));
-   nir_block *last_block =
-      nir_cf_node_as_block(condition ? nir_if_last_then_node(if_stmt)
-                                     : nir_if_last_else_node(if_stmt));
+   nir_block *last_block = condition ? nir_if_last_then_block(if_stmt)
+                                     : nir_if_last_else_block(if_stmt);
 
-   nir_foreach_instr_safe(after, instr) {
+   nir_foreach_instr_safe(instr, after) {
       if (instr->type != nir_instr_type_phi)
          break;
 
       nir_phi_instr *phi = nir_instr_as_phi(instr);
       nir_ssa_def *def = NULL;
-      nir_foreach_phi_src(phi, phi_src) {
+      nir_foreach_phi_src(phi_src, phi) {
          if (phi_src->pred != last_block)
             continue;
 
@@ -128,40 +127,39 @@ opt_constant_if(nir_if *if_stmt, bool condition)
                                          : &if_stmt->else_list;
 
    nir_cf_list list;
-   nir_cf_extract(&list, nir_before_cf_list(cf_list),
-                  nir_after_cf_list(cf_list));
+   nir_cf_list_extract(&list, cf_list);
    nir_cf_reinsert(&list, nir_after_cf_node(&if_stmt->cf_node));
    nir_cf_node_remove(&if_stmt->cf_node);
 }
 
 static bool
-block_has_no_side_effects(nir_block *block, void *state)
+cf_node_has_side_effects(nir_cf_node *node)
 {
-   (void) state;
+   nir_foreach_block_in_cf_node(block, node) {
+      nir_foreach_instr(instr, block) {
+         if (instr->type == nir_instr_type_call)
+            return true;
 
-   nir_foreach_instr(block, instr) {
-      if (instr->type == nir_instr_type_call)
-         return false;
-
-      /* Return instructions can cause us to skip over other side-effecting
-       * instructions after the loop, so consider them to have side effects
-       * here.
-       */
+         /* Return instructions can cause us to skip over other side-effecting
+          * instructions after the loop, so consider them to have side effects
+          * here.
+          */
 
-      if (instr->type == nir_instr_type_jump &&
-          nir_instr_as_jump(instr)->type == nir_jump_return)
-         return false;
+         if (instr->type == nir_instr_type_jump &&
+             nir_instr_as_jump(instr)->type == nir_jump_return)
+            return true;
 
-      if (instr->type != nir_instr_type_intrinsic)
-         continue;
+         if (instr->type != nir_instr_type_intrinsic)
+            continue;
 
-      nir_intrinsic_instr *intrin = nir_instr_as_intrinsic(instr);
-      if (!nir_intrinsic_infos[intrin->intrinsic].flags &
-          NIR_INTRINSIC_CAN_ELIMINATE)
-         return false;
+         nir_intrinsic_instr *intrin = nir_instr_as_intrinsic(instr);
+         if (!(nir_intrinsic_infos[intrin->intrinsic].flags &
+             NIR_INTRINSIC_CAN_ELIMINATE))
+            return true;
+      }
    }
 
-   return true;
+   return false;
 }
 
 static bool
@@ -199,16 +197,16 @@ loop_is_dead(nir_loop *loop)
        nir_block_first_instr(after)->type == nir_instr_type_phi)
       return false;
 
-   if (!nir_foreach_block_in_cf_node(&loop->cf_node, block_has_no_side_effects,
-                                     NULL))
+   if (cf_node_has_side_effects(&loop->cf_node))
       return false;
 
    nir_function_impl *impl = nir_cf_node_get_function(&loop->cf_node);
    nir_metadata_require(impl, nir_metadata_live_ssa_defs |
                               nir_metadata_dominance);
 
-   for (nir_block *cur = after->imm_dom; cur != before; cur = cur->imm_dom) {
-      nir_foreach_instr(cur, instr) {
+   for (nir_block *cur = after->imm_dom; cur && cur != before;
+        cur = cur->imm_dom) {
+      nir_foreach_instr(instr, cur) {
          if (!nir_foreach_ssa_def(instr, def_not_live_out, after))
             return false;
       }
@@ -222,13 +220,13 @@ dead_cf_block(nir_block *block)
 {
    nir_if *following_if = nir_block_get_following_if(block);
    if (following_if) {
-     nir_const_value *const_value =
-        nir_src_as_const_value(following_if->condition);
+      nir_const_value *const_value =
+         nir_src_as_const_value(following_if->condition);
 
-     if (!const_value)
-        return false;
+      if (!const_value)
+         return false;
 
-      opt_constant_if(following_if, const_value->u[0] != 0);
+      opt_constant_if(following_if, const_value->u32[0] != 0);
       return true;
    }
 
@@ -350,7 +348,7 @@ nir_opt_dead_cf(nir_shader *shader)
 {
    bool progress = false;
 
-   nir_foreach_function(shader, function)
+   nir_foreach_function(function, shader)
       if (function->impl)
          progress |= opt_dead_cf_impl(function->impl);