treewide: use nir_break_if with named if

Via Coccinelle patch:

    @@
    expression builder, condition;
    identifier nif;
    @@

    -nir_if *nif = nir_push_if(builder, condition);
    -{
    -nir_jump(builder, nir_jump_break);
    -}
    -nir_pop_if(builder, nif);
    +nir_break_if(builder, condition);

Signed-off-by: Alyssa Rosenzweig <alyssa@rosenzweig.io>
Reviewed-by: Jesse Natalie <jenatali@microsoft.com>
Reviewed-by: Mel Henning <mhenning@darkrefraction.com>
Reviewed-by: Samuel Pitoiset <samuel.pitoiset@gmail.com>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/35794>

src/amd/common/nir/ac_nir_lower_ngg_mesh.c

@@ -963,11 +963,7 @@ emit_ms_outputs(nir_builder *b, nir_def *invocation_index, nir_def *row_start,
          nir_phi_instr_add_src(index, preheader, invocation_index);
          nir_phi_instr_add_src(row, preheader, row_start);
 
-         nir_if *if_break = nir_push_if(b, nir_uge(b, &index->def, count));
-         {
-            nir_jump(b, nir_jump_break);
-         }
-         nir_pop_if(b, if_break);
+         nir_break_if(b, nir_uge(b, &index->def, count));
 
          cb(b, &index->def, &row->def, exports, parameters, mask, s);
 
@@ -1204,11 +1200,7 @@ handle_smaller_ms_api_workgroup(nir_builder *b,
                                      .memory_modes = nir_var_shader_out | nir_var_mem_shared);
 
                nir_def *loaded = nir_load_shared(b, 1, 32, zero, .base = api_waves_in_flight_addr);
-               nir_if *if_break = nir_push_if(b, nir_ieq_imm(b, loaded, 0));
-               {
-                  nir_jump(b, nir_jump_break);
-               }
-               nir_pop_if(b, if_break);
+               nir_break_if(b, nir_ieq_imm(b, loaded, 0));
             }
             nir_pop_loop(b, loop);
          }

src/broadcom/vulkan/v3dv_event.c

@@ -70,9 +70,7 @@ get_wait_event_cs(const nir_shader_compiler_options *options)
          nir_load_ssbo(&b, 1, 8, buf, offset, .access = 0, .align_mul = 4);
       nir_def *value = nir_i2i32(&b, load);
 
-      nir_if *if_stmt = nir_push_if(&b, nir_ieq_imm(&b, value, 1));
-      nir_jump(&b, nir_jump_break);
-      nir_pop_if(&b, if_stmt);
+      nir_break_if(&b, nir_ieq_imm(&b, value, 1));
    nir_pop_loop(&b, loop);
 
    return b.shader;

src/compiler/glsl/gl_nir_lower_discard_flow.c

@@ -71,9 +71,7 @@ static void
 generate_discard_break(nir_builder *b, nir_variable *discarded)
 {
    nir_deref_instr *condition = nir_build_deref_var(b, discarded);
-   nir_if *nif = nir_push_if(b, nir_load_deref(b, condition));
-   nir_jump(b, nir_jump_break);
-   nir_pop_if(b, nif);
+   nir_break_if(b, nir_load_deref(b, condition));
 }
 
 static void

src/compiler/nir/nir_lower_multiview.c

@@ -251,9 +251,7 @@ nir_lower_multiview(nir_shader *shader, nir_lower_multiview_options options)
 
    nir_def *loop_index = nir_load_deref(&b, loop_index_deref);
    nir_def *cmp = nir_ige_imm(&b, loop_index, view_count);
-   nir_if *loop_check = nir_push_if(&b, cmp);
-   nir_jump(&b, nir_jump_break);
-   nir_pop_if(&b, loop_check);
+   nir_break_if(&b, cmp);
 
    nir_def *view_index =
       nir_load_deref(&b, nir_build_deref_array(&b, view_index_deref, loop_index));

src/compiler/nir/tests/loop_unroll_tests.cpp

@@ -142,9 +142,7 @@ loop_unroll_test_helper(nir_builder *bld, nir_def *init,
                                   (reverse ? limit : &phi->def),
                                   (reverse ? &phi->def : limit));
 
-   nir_if *nif = nir_push_if(bld, cond);
-   nir_jump(bld, nir_jump_break);
-   nir_pop_if(bld, nif);
+   nir_break_if(bld, cond);
 
    nir_def *var = incr_instr(bld, &phi->def, step);
 

src/gallium/drivers/d3d12/d3d12_compute_transforms.cpp

@@ -316,9 +316,7 @@ get_query_resolve(const nir_shader_compiler_options *options, const d3d12_comput
       nir_loop *loop = nir_push_loop(&b);
 
       nir_def *loop_counter_value = nir_load_var(&b, loop_counter);
-      nir_if *nif = nir_push_if(&b, nir_ieq(&b, loop_counter_value, num_results));
-      nir_jump(&b, nir_jump_break);
-      nir_pop_if(&b, nif);
+      nir_break_if(&b, nir_ieq(&b, loop_counter_value, num_results));
 
       /* For each field in the query result, accumulate */
       nir_def *array_index = nir_iadd(&b, nir_imul_imm(&b, loop_counter_value, stride), base_array_index);

src/gallium/drivers/d3d12/d3d12_gs_variant.cpp

@@ -296,9 +296,7 @@ d3d12_begin_emit_primitives_gs(struct emit_primitives_context *emit_ctx,
 
    emit_ctx->loop_index = nir_load_deref(b, emit_ctx->loop_index_deref);
    nir_def *cmp = nir_ige_imm(b, emit_ctx->loop_index, 3);
-   nir_if *loop_check = nir_push_if(b, cmp);
-   nir_jump(b, nir_jump_break);
-   nir_pop_if(b, loop_check);
+   nir_break_if(b, cmp);
 
    if (edgeflag_var) {
       nir_def *edge_flag =

src/gallium/drivers/radeonsi/si_shaderlib_nir.c

@@ -489,10 +489,7 @@ void *si_create_query_result_cs(struct si_context *sctx)
             nir_def *result_index = nir_load_var(&b, outer_loop_iter);
             nir_def *is_result_index_out_of_bound =
                nir_uge(&b, result_index, nir_channel(&b, buff_0, 2));
-            nir_if *if_out_of_bound = nir_push_if(&b, is_result_index_out_of_bound); {
-               nir_jump(&b, nir_jump_break);
-            }
-            nir_pop_if(&b, if_out_of_bound);
+            nir_break_if(&b, is_result_index_out_of_bound);
 
             /* Load fence and check result availability.
              *    pitch = i * result_stride;
@@ -511,10 +508,7 @@ void *si_create_query_result_cs(struct si_context *sctx)
              *       break;
              *    }
              */
-            nir_if *if_result_available = nir_push_if(&b, nir_i2b(&b, bitmask)); {
-               nir_jump(&b, nir_jump_break);
-            }
-            nir_pop_if(&b, if_result_available);
+            nir_break_if(&b, nir_i2b(&b, bitmask));
 
             /* Inner loop iterator.
              *    uint32_t i = 0;
@@ -591,10 +585,7 @@ void *si_create_query_result_cs(struct si_context *sctx)
                /* } while (i < pair_count);
                */
                nir_def *is_pair_count_exceeded = nir_uge(&b, i, nir_channel(&b, buff_1, 2));
-               nir_if *if_pair_count_exceeded = nir_push_if(&b, is_pair_count_exceeded); {
-                  nir_jump(&b, nir_jump_break);
-               }
-               nir_pop_if(&b, if_pair_count_exceeded);
+               nir_break_if(&b, is_pair_count_exceeded);
             }
             nir_pop_loop(&b, loop_inner);
 
@@ -817,10 +808,7 @@ void *gfx11_create_sh_query_result_cs(struct si_context *sctx)
     */
    nir_loop *loop_outer = nir_push_loop(&b); {
       nir_def *condition = nir_load_var(&b, result_remaining);
-      nir_if *if_not_condition = nir_push_if(&b, nir_ieq(&b, condition, zero)); {
-         nir_jump(&b, nir_jump_break);
-      }
-      nir_pop_if(&b, if_not_condition);
+      nir_break_if(&b, nir_ieq(&b, condition, zero));
 
       /* result_remaining--; */
       condition = nir_iadd(&b, condition, minus_one);
@@ -840,10 +828,7 @@ void *gfx11_create_sh_query_result_cs(struct si_context *sctx)
       nir_def *is_zero = nir_ieq(&b, fence, zero);
       nir_def *y_value = nir_isub(&b, zero, nir_b2i32(&b, is_zero));
       nir_store_var(&b, acc_missing, y_value, 0x1);
-      nir_if *if_ssbo_zero = nir_push_if(&b, is_zero); {
-         nir_jump(&b, nir_jump_break);
-      }
-      nir_pop_if(&b, if_ssbo_zero);
+      nir_break_if(&b, is_zero);
 
       /* stream_offset = base_offset + offset; */
       nir_def *s_offset = nir_iadd(&b, b_offset, nir_channel(&b, buff_0, 1));
@@ -912,10 +897,7 @@ void *gfx11_create_sh_query_result_cs(struct si_context *sctx)
             loop_count = nir_iadd(&b, loop_count, minus_one);
             nir_store_var(&b, count, loop_count, 0x1);
 
-            nir_if *if_zero = nir_push_if(&b, nir_ieq(&b, loop_count, zero)); {
-               nir_jump(&b, nir_jump_break);
-            }
-            nir_pop_if(&b, if_zero);
+            nir_break_if(&b, nir_ieq(&b, loop_count, zero));
          }
          nir_pop_loop(&b, loop_inner); /* Inner loop end */
       }

src/microsoft/vulkan/dzn_nir.c

@@ -942,9 +942,7 @@ dzn_nir_polygon_point_mode_gs(const nir_shader *previous_shader, struct dzn_nir_
    nir_def *loop_index = nir_load_deref(b, loop_index_deref);
    nir_def *cmp = nir_ige(b, loop_index,
                               nir_imm_int(b, 3));
-   nir_if *loop_check = nir_push_if(b, cmp);
-   nir_jump(b, nir_jump_break);
-   nir_pop_if(b, loop_check);
+   nir_break_if(b, cmp);
 
    /**
     *        [...] // Copy all variables