treewide: use nir_metadata_control_flow

Via Coccinelle patch:

    @@
    @@

    -nir_metadata_block_index | nir_metadata_dominance
    +nir_metadata_control_flow

...plus some manual fixups for call sites missed by coccinelle.

Signed-off-by: Alyssa Rosenzweig <alyssa@rosenzweig.io>
Reviewed-by: Faith Ekstrand <faith.ekstrand@collabora.com>
Acked-by: Karol Herbst <kherbst@redhat.com>
Acked-by: Juan A. Suarez Romero <jasuarez@igalia.com> [broadcom]
Acked-by: Vasily Khoruzhick <anarsoul@gmail.com> [lima]
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/29745>

src/amd/common/ac_nir.c

@@ -191,7 +191,7 @@ ac_nir_lower_intrinsics_to_args(nir_shader *shader, const enum amd_gfx_level gfx
    };
 
    return nir_shader_instructions_pass(shader, lower_intrinsic_to_arg,
-                                       nir_metadata_block_index | nir_metadata_dominance, &state);
+                                       nir_metadata_control_flow, &state);
 }
 
 void
@@ -935,7 +935,7 @@ ac_nir_lower_legacy_vs(nir_shader *nir,
                        bool force_vrs)
 {
    nir_function_impl *impl = nir_shader_get_entrypoint(nir);
-   nir_metadata preserved = nir_metadata_block_index | nir_metadata_dominance;
+   nir_metadata preserved = nir_metadata_control_flow;
 
    nir_builder b = nir_builder_at(nir_after_impl(impl));
 
@@ -1334,7 +1334,7 @@ ac_nir_lower_legacy_gs(nir_shader *nir,
    }
 
    nir_shader_instructions_pass(nir, lower_legacy_gs_intrinsic,
-                                nir_metadata_block_index | nir_metadata_dominance, &s);
+                                nir_metadata_control_flow, &s);
 
    nir_function_impl *impl = nir_shader_get_entrypoint(nir);
 
@@ -1501,7 +1501,8 @@ ac_nir_opt_pack_half(nir_shader *shader, enum amd_gfx_level gfx_level)
    }
 
    bool progress = nir_shader_instructions_pass(shader, split_pack_half,
-                                                nir_metadata_block_index | nir_metadata_dominance, &gfx_level);
+                                                nir_metadata_control_flow,
+                                                &gfx_level);
 
    if (set_mode && progress) {
       exec_mode &= ~(FLOAT_CONTROLS_ROUNDING_MODE_RTE_FP16 | FLOAT_CONTROLS_ROUNDING_MODE_RTE_FP64);

src/amd/common/ac_nir_lower_esgs_io_to_mem.c

@@ -323,7 +323,7 @@ ac_nir_lower_es_outputs_to_mem(nir_shader *shader,
    };
 
    nir_shader_intrinsics_pass(shader, lower_es_output_store,
-                                nir_metadata_block_index | nir_metadata_dominance,
+                                nir_metadata_control_flow,
                                 &state);
 }
 

src/amd/common/ac_nir_lower_global_access.c

@@ -143,5 +143,5 @@ bool
 ac_nir_lower_global_access(nir_shader *shader)
 {
    return nir_shader_intrinsics_pass(shader, process_instr,
-                                       nir_metadata_block_index | nir_metadata_dominance, NULL);
+                                       nir_metadata_control_flow, NULL);
 }

src/amd/common/ac_nir_lower_image_opcodes_cdna.c

@@ -482,7 +482,6 @@ static bool lower_image_opcodes(nir_builder *b, nir_instr *instr, void *data)
 bool ac_nir_lower_image_opcodes(nir_shader *nir)
 {
    return nir_shader_instructions_pass(nir, lower_image_opcodes,
-                                       nir_metadata_dominance |
-                                       nir_metadata_block_index,
+                                       nir_metadata_control_flow,
                                        NULL);
 }

src/amd/common/ac_nir_lower_ngg.c

@@ -725,7 +725,7 @@ static void
 remove_culling_shader_outputs(nir_shader *culling_shader, lower_ngg_nogs_state *s)
 {
    nir_shader_instructions_pass(culling_shader, remove_culling_shader_output,
-                                nir_metadata_block_index | nir_metadata_dominance, s);
+                                nir_metadata_control_flow, s);
 
    /* Remove dead code resulting from the deleted outputs. */
    bool progress;
@@ -836,7 +836,7 @@ static void
 remove_extra_pos_outputs(nir_shader *shader, lower_ngg_nogs_state *s)
 {
    nir_shader_instructions_pass(shader, remove_extra_pos_output,
-                                nir_metadata_block_index | nir_metadata_dominance,
+                                nir_metadata_control_flow,
                                 s);
 }
 

src/amd/common/ac_nir_lower_ps.c

@@ -876,7 +876,7 @@ ac_nir_lower_ps(nir_shader *nir, const ac_nir_lower_ps_options *options)
    create_interp_param(b, &state);
 
    nir_shader_instructions_pass(nir, lower_ps_intrinsic,
-                                nir_metadata_block_index | nir_metadata_dominance,
+                                nir_metadata_control_flow,
                                 &state);
 
    /* Must be after lower_ps_intrinsic() to prevent it lower added intrinsic here. */

src/amd/common/ac_nir_lower_resinfo.c

@@ -369,7 +369,6 @@ static bool lower_resinfo(nir_builder *b, nir_instr *instr, void *data)
 bool ac_nir_lower_resinfo(nir_shader *nir, enum amd_gfx_level gfx_level)
 {
    return nir_shader_instructions_pass(nir, lower_resinfo,
-                                       nir_metadata_dominance |
-                                       nir_metadata_block_index,
+                                       nir_metadata_control_flow,
                                        &gfx_level);
 }

src/amd/common/ac_nir_lower_subdword_loads.c

@@ -220,6 +220,5 @@ bool
 ac_nir_lower_subdword_loads(nir_shader *nir, ac_nir_lower_subdword_options options)
 {
    return nir_shader_instructions_pass(nir, lower_subdword_loads,
-                                       nir_metadata_dominance |
-                                       nir_metadata_block_index, &options);
+                                       nir_metadata_control_flow, &options);
 }

src/amd/common/ac_nir_lower_tess_io_to_mem.c

@@ -966,7 +966,7 @@ ac_nir_lower_ls_outputs_to_mem(nir_shader *shader,
    };
 
    nir_shader_intrinsics_pass(shader, lower_ls_output_store,
-                                nir_metadata_block_index | nir_metadata_dominance,
+                                nir_metadata_control_flow,
                                 &state);
 }
 

src/amd/common/ac_nir_lower_tex.c

@@ -499,13 +499,13 @@ ac_nir_lower_tex(nir_shader *nir, const ac_nir_lower_tex_options *options)
 
       bool divergent_discard = false;
       if (move_coords_from_divergent_cf(&state, impl, &impl->body, &divergent_discard, false))
-         nir_metadata_preserve(impl, nir_metadata_block_index | nir_metadata_dominance);
+         nir_metadata_preserve(impl, nir_metadata_control_flow);
       else
          nir_metadata_preserve(impl, nir_metadata_all);
    }
 
    progress |= nir_shader_instructions_pass(
-      nir, lower_tex, nir_metadata_block_index | nir_metadata_dominance, (void *)options);
+      nir, lower_tex, nir_metadata_control_flow, (void *)options);
 
    return progress;
 }

src/amd/common/ac_nir_opt_outputs.c

@@ -301,8 +301,7 @@ bool ac_nir_optimize_outputs(nir_shader *nir, bool sprite_tex_disallowed,
    }
 
    if (progress) {
-      nir_metadata_preserve(impl, nir_metadata_dominance |
-                                  nir_metadata_block_index);
+      nir_metadata_preserve(impl, nir_metadata_control_flow);
    } else {
       nir_metadata_preserve(impl, nir_metadata_all);
    }

src/amd/vulkan/nir/radv_nir_apply_pipeline_layout.c

@@ -513,6 +513,6 @@ radv_nir_apply_pipeline_layout(nir_shader *shader, struct radv_device *device, c
          }
       }
 
-      nir_metadata_preserve(function->impl, nir_metadata_block_index | nir_metadata_dominance);
+      nir_metadata_preserve(function->impl, nir_metadata_control_flow);
    }
 }

src/amd/vulkan/nir/radv_nir_export_multiview.c

@@ -83,7 +83,7 @@ radv_nir_export_multiview(nir_shader *nir)
    }
 
    if (progress)
-      nir_metadata_preserve(impl, nir_metadata_block_index | nir_metadata_dominance);
+      nir_metadata_preserve(impl, nir_metadata_control_flow);
    else
       nir_metadata_preserve(impl, nir_metadata_all);
 

src/amd/vulkan/nir/radv_nir_lower_abi.c

@@ -572,5 +572,5 @@ radv_nir_lower_abi(nir_shader *shader, enum amd_gfx_level gfx_level, const struc
          state.gsvs_ring[i] = load_gsvs_ring(&b, &state, i);
    }
 
-   nir_shader_intrinsics_pass(shader, lower_abi_instr, nir_metadata_dominance | nir_metadata_block_index, &state);
+   nir_shader_intrinsics_pass(shader, lower_abi_instr, nir_metadata_control_flow, &state);
 }

src/amd/vulkan/nir/radv_nir_lower_hit_attrib_derefs.c

@@ -118,8 +118,7 @@ radv_nir_lower_rt_vars(nir_shader *shader, nir_variable_mode mode, uint32_t base
       .base_offset = base_offset,
    };
 
-   progress |= nir_shader_instructions_pass(shader, lower_hit_attrib_deref,
-                                            nir_metadata_block_index | nir_metadata_dominance, &args);
+   progress |= nir_shader_instructions_pass(shader, lower_hit_attrib_deref, nir_metadata_control_flow, &args);
 
    if (progress) {
       nir_remove_dead_derefs(shader);

src/amd/vulkan/nir/radv_nir_lower_intrinsics_early.c

@@ -50,7 +50,7 @@ radv_nir_lower_intrinsics_early(nir_shader *nir, bool lower_view_index_to_zero)
    }
 
    if (progress)
-      nir_metadata_preserve(entry, nir_metadata_block_index | nir_metadata_dominance);
+      nir_metadata_preserve(entry, nir_metadata_control_flow);
    else
       nir_metadata_preserve(entry, nir_metadata_all);
 

src/amd/vulkan/nir/radv_nir_lower_io.c

@@ -186,6 +186,5 @@ radv_nir_lower_draw_id_to_zero_callback(struct nir_builder *b, nir_intrinsic_ins
 bool
 radv_nir_lower_draw_id_to_zero(nir_shader *shader)
 {
-   return nir_shader_intrinsics_pass(shader, radv_nir_lower_draw_id_to_zero_callback,
-                                     nir_metadata_block_index | nir_metadata_dominance, NULL);
+   return nir_shader_intrinsics_pass(shader, radv_nir_lower_draw_id_to_zero_callback, nir_metadata_control_flow, NULL);
 }

src/amd/vulkan/nir/radv_nir_lower_primitive_shading_rate.c

@@ -85,7 +85,7 @@ radv_nir_lower_primitive_shading_rate(nir_shader *nir, enum amd_gfx_level gfx_le
    }
 
    if (progress)
-      nir_metadata_preserve(impl, nir_metadata_block_index | nir_metadata_dominance);
+      nir_metadata_preserve(impl, nir_metadata_control_flow);
    else
       nir_metadata_preserve(impl, nir_metadata_all);
 

src/amd/vulkan/nir/radv_nir_lower_view_index.c

@@ -68,7 +68,7 @@ radv_nir_lower_view_index(nir_shader *nir, bool per_primitive)
    }
 
    if (progress)
-      nir_metadata_preserve(entry, nir_metadata_block_index | nir_metadata_dominance);
+      nir_metadata_preserve(entry, nir_metadata_control_flow);
    else
       nir_metadata_preserve(entry, nir_metadata_all);
 

src/amd/vulkan/nir/radv_nir_lower_viewport_to_zero.c

@@ -43,7 +43,7 @@ radv_nir_lower_viewport_to_zero(nir_shader *nir)
    }
 
    if (progress)
-      nir_metadata_preserve(impl, nir_metadata_block_index | nir_metadata_dominance);
+      nir_metadata_preserve(impl, nir_metadata_control_flow);
    else
       nir_metadata_preserve(impl, nir_metadata_all);
 

src/amd/vulkan/nir/radv_nir_lower_vs_inputs.c

@@ -405,6 +405,5 @@ radv_nir_lower_vs_inputs(nir_shader *shader, const struct radv_shader_stage *vs_
       .gpu_info = gpu_info,
    };
 
-   return nir_shader_intrinsics_pass(shader, lower_vs_input_instr, nir_metadata_dominance | nir_metadata_block_index,
-                                     &state);
+   return nir_shader_intrinsics_pass(shader, lower_vs_input_instr, nir_metadata_control_flow, &state);
 }

src/amd/vulkan/nir/radv_nir_rt_shader.c

@@ -158,7 +158,7 @@ lower_rt_derefs(nir_shader *shader)
    }
 
    if (progress)
-      nir_metadata_preserve(impl, nir_metadata_block_index | nir_metadata_dominance);
+      nir_metadata_preserve(impl, nir_metadata_control_flow);
    else
       nir_metadata_preserve(impl, nir_metadata_all);
 
@@ -879,8 +879,7 @@ radv_nir_lower_rt_io(nir_shader *nir, bool monolithic, uint32_t payload_offset)
          nir_lower_vars_to_explicit_types(nir, nir_var_function_temp, glsl_get_natural_size_align_bytes);
          nir->scratch_size = scratch_size;
 
-         nir_shader_intrinsics_pass(nir, radv_lower_payload_arg_to_offset,
-                                    nir_metadata_block_index | nir_metadata_dominance, NULL);
+         nir_shader_intrinsics_pass(nir, radv_lower_payload_arg_to_offset, nir_metadata_control_flow, NULL);
       }
 
       NIR_PASS(_, nir, radv_nir_lower_ray_payload_derefs, payload_offset);

src/asahi/compiler/agx_compile.c

@@ -3311,7 +3311,7 @@ agx_preprocess_nir(nir_shader *nir, const nir_shader *libagx)
    NIR_PASS(_, nir, nir_lower_flrp, 16 | 32 | 64, false);
    NIR_PASS(_, nir, agx_lower_sincos);
    NIR_PASS(_, nir, nir_shader_intrinsics_pass, agx_lower_front_face,
-            nir_metadata_block_index | nir_metadata_dominance, NULL);
+            nir_metadata_control_flow, NULL);
    NIR_PASS(_, nir, agx_nir_lower_subgroups);
    NIR_PASS(_, nir, nir_lower_phis_to_scalar, true);
 
@@ -3406,7 +3406,7 @@ agx_compile_shader_nir(nir_shader *nir, struct agx_shader_key *key,
 
    NIR_PASS(_, nir, nir_opt_constant_folding);
    NIR_PASS(_, nir, nir_shader_intrinsics_pass, lower_load_from_texture_handle,
-            nir_metadata_block_index | nir_metadata_dominance, NULL);
+            nir_metadata_control_flow, NULL);
 
    info->push_count = key->reserved_preamble;
    agx_optimize_nir(nir, key->secondary ? NULL : &info->push_count);

src/asahi/compiler/agx_nir_lower_address.c

@@ -348,6 +348,6 @@ pass(struct nir_builder *b, nir_intrinsic_instr *intr, void *data)
 bool
 agx_nir_lower_address(nir_shader *shader)
 {
-   return nir_shader_intrinsics_pass(
-      shader, pass, nir_metadata_block_index | nir_metadata_dominance, NULL);
+   return nir_shader_intrinsics_pass(shader, pass, nir_metadata_control_flow,
+                                     NULL);
 }

src/asahi/compiler/agx_nir_lower_cull_distance.c

@@ -78,8 +78,7 @@ agx_nir_lower_cull_distance_vs(nir_shader *s)
    assert(s->info.stage == MESA_SHADER_VERTEX ||
           s->info.stage == MESA_SHADER_TESS_EVAL);
 
-   nir_shader_intrinsics_pass(
-      s, lower_write, nir_metadata_block_index | nir_metadata_dominance, NULL);
+   nir_shader_intrinsics_pass(s, lower_write, nir_metadata_control_flow, NULL);
 
    s->info.outputs_written |=
       BITFIELD64_RANGE(VARYING_SLOT_CULL_PRIMITIVE,
@@ -124,7 +123,6 @@ agx_nir_lower_cull_distance_fs(nir_shader *s, unsigned nr_distances)
                                            DIV_ROUND_UP(nr_distances, 4));
 
    s->info.fs.uses_discard = true;
-   nir_metadata_preserve(b->impl,
-                         nir_metadata_dominance | nir_metadata_block_index);
+   nir_metadata_preserve(b->impl, nir_metadata_control_flow);
    return true;
 }

src/asahi/compiler/agx_nir_lower_discard_zs_emit.c

@@ -111,9 +111,8 @@ agx_nir_lower_discard(nir_shader *s)
    if (!s->info.fs.uses_discard)
       return false;
 
-   return nir_shader_intrinsics_pass(
-      s, lower_discard, nir_metadata_block_index | nir_metadata_dominance,
-      NULL);
+   return nir_shader_intrinsics_pass(s, lower_discard,
+                                     nir_metadata_control_flow, NULL);
 }
 
 static bool
@@ -134,8 +133,7 @@ agx_nir_lower_zs_emit(nir_shader *s)
       }
 
       if (progress) {
-         nir_metadata_preserve(
-            impl, nir_metadata_block_index | nir_metadata_dominance);
+         nir_metadata_preserve(impl, nir_metadata_control_flow);
       } else {
          nir_metadata_preserve(impl, nir_metadata_all);
       }

src/asahi/compiler/agx_nir_lower_frag_sidefx.c

@@ -89,8 +89,7 @@ agx_nir_lower_frag_sidefx(nir_shader *s)
       return false;
 
    bool done = false;
-   nir_shader_intrinsics_pass(
-      s, pass, nir_metadata_block_index | nir_metadata_dominance, &done);
+   nir_shader_intrinsics_pass(s, pass, nir_metadata_control_flow, &done);
 
    /* If there's no render targets written, just put the write at the end */
    if (!done) {

src/asahi/compiler/agx_nir_lower_sample_mask.c

@@ -217,12 +217,10 @@ agx_nir_lower_sample_mask(nir_shader *shader)
       return false;
    }
 
-   nir_metadata_preserve(impl,
-                         nir_metadata_block_index | nir_metadata_dominance);
+   nir_metadata_preserve(impl, nir_metadata_control_flow);
 
    nir_shader_intrinsics_pass(shader, lower_discard_to_sample_mask_0,
-                              nir_metadata_block_index | nir_metadata_dominance,
-                              NULL);
+                              nir_metadata_control_flow, NULL);
 
    return true;
 }

src/asahi/compiler/agx_nir_lower_shared_bitsize.c

@@ -32,6 +32,6 @@ pass(struct nir_builder *b, nir_intrinsic_instr *intr, UNUSED void *data)
 bool
 agx_nir_lower_shared_bitsize(nir_shader *shader)
 {
-   return nir_shader_intrinsics_pass(
-      shader, pass, nir_metadata_block_index | nir_metadata_dominance, NULL);
+   return nir_shader_intrinsics_pass(shader, pass, nir_metadata_control_flow,
+                                     NULL);
 }

src/asahi/compiler/agx_nir_lower_subgroups.c

@@ -217,8 +217,8 @@ agx_nir_lower_subgroups(nir_shader *s)
    bool progress = nir_lower_subgroups(s, &opts);
 
    /* Then do AGX-only lowerings on top */
-   progress |= nir_shader_intrinsics_pass(
-      s, lower, nir_metadata_block_index | nir_metadata_dominance, NULL);
+   progress |=
+      nir_shader_intrinsics_pass(s, lower, nir_metadata_control_flow, NULL);
 
    return progress;
 }

src/asahi/lib/agx_bg_eot.c

@@ -40,9 +40,8 @@ agx_compile_bg_eot_shader(struct agx_bg_eot_cache *cache, nir_shader *shader,
       agx_nir_lower_multisampled_image_store(shader);
       agx_nir_lower_texture(shader);
 
-      nir_shader_intrinsics_pass(
-         shader, lower_tex_handle_to_u0,
-         nir_metadata_dominance | nir_metadata_block_index, NULL);
+      nir_shader_intrinsics_pass(shader, lower_tex_handle_to_u0,
+                                 nir_metadata_control_flow, NULL);
    }
 
    key->libagx = cache->dev->libagx;

src/asahi/lib/agx_nir_lower_alpha.c

@@ -68,8 +68,7 @@ agx_nir_lower_alpha_to_coverage(nir_shader *shader, uint8_t nr_samples)
    /* Discard samples that aren't covered */
    nir_discard_agx(b, nir_inot(b, mask));
    shader->info.fs.uses_discard = true;
-   nir_metadata_preserve(impl,
-                         nir_metadata_dominance | nir_metadata_block_index);
+   nir_metadata_preserve(impl, nir_metadata_control_flow);
    return true;
 }
 
@@ -119,8 +118,7 @@ agx_nir_lower_alpha_to_one(nir_shader *shader)
    }
 
    if (progress) {
-      nir_metadata_preserve(impl,
-                            nir_metadata_block_index | nir_metadata_dominance);
+      nir_metadata_preserve(impl, nir_metadata_control_flow);
    } else {
       nir_metadata_preserve(impl, nir_metadata_all);
    }

src/asahi/lib/agx_nir_lower_gs.c

@@ -360,9 +360,8 @@ lower_prolog_id(nir_builder *b, nir_intrinsic_instr *intr, void *data)
 bool
 agx_nir_lower_sw_vs_id(nir_shader *s)
 {
-   return nir_shader_intrinsics_pass(
-      s, lower_prolog_id, nir_metadata_dominance | nir_metadata_block_index,
-      NULL);
+   return nir_shader_intrinsics_pass(s, lower_prolog_id,
+                                     nir_metadata_control_flow, NULL);
 }
 
 static bool
@@ -409,10 +408,10 @@ agx_nir_create_geometry_count_shader(nir_shader *gs, const nir_shader *libagx,
    }
 
    NIR_PASS(_, shader, nir_shader_intrinsics_pass, lower_gs_count_instr,
-            nir_metadata_block_index | nir_metadata_dominance, state);
+            nir_metadata_control_flow, state);
 
    NIR_PASS(_, shader, nir_shader_intrinsics_pass, lower_id,
-            nir_metadata_block_index | nir_metadata_dominance, NULL);
+            nir_metadata_control_flow, NULL);
 
    agx_preprocess_nir(shader, libagx);
    return shader;
@@ -553,8 +552,7 @@ strip_side_effects_from_rast(nir_shader *s, bool *side_effects_for_rast)
       progress = false;
       any = false;
       NIR_PASS(progress, clone, nir_shader_intrinsics_pass,
-               strip_side_effect_from_rast,
-               nir_metadata_block_index | nir_metadata_dominance, &any);
+               strip_side_effect_from_rast, nir_metadata_control_flow, &any);
 
       NIR_PASS(progress, clone, nir_opt_dce);
       NIR_PASS(progress, clone, nir_opt_dead_cf);
@@ -573,8 +571,7 @@ strip_side_effects_from_rast(nir_shader *s, bool *side_effects_for_rast)
       progress = false;
       any = false;
       NIR_PASS(progress, s, nir_shader_intrinsics_pass,
-               strip_side_effect_from_rast,
-               nir_metadata_block_index | nir_metadata_dominance, &any);
+               strip_side_effect_from_rast, nir_metadata_control_flow, &any);
 
       NIR_PASS(progress, s, nir_opt_dce);
       NIR_PASS(progress, s, nir_opt_dead_cf);
@@ -677,8 +674,7 @@ agx_nir_create_gs_rast_shader(const nir_shader *gs, const nir_shader *libagx,
    }
 
    nir_shader_intrinsics_pass(shader, lower_to_gs_rast,
-                              nir_metadata_block_index | nir_metadata_dominance,
-                              &rast_state);
+                              nir_metadata_control_flow, &rast_state);
 
    b->cursor = nir_after_impl(b->impl);
 
@@ -1229,8 +1225,7 @@ agx_nir_lower_gs_instancing(nir_shader *gs)
 
    /* Use the loop counter as the invocation ID each iteration */
    nir_shader_intrinsics_pass(gs, rewrite_invocation_id,
-                              nir_metadata_block_index | nir_metadata_dominance,
-                              index);
+                              nir_metadata_control_flow, index);
 }
 
 static void
@@ -1283,13 +1278,12 @@ agx_nir_lower_gs(nir_shader *gs, const nir_shader *libagx,
       nir_function_impl *impl = nir_shader_get_entrypoint(gs);
       nir_builder b = nir_builder_at(nir_before_impl(impl));
 
-      nir_shader_intrinsics_pass(
-         gs, rewrite_invocation_id,
-         nir_metadata_block_index | nir_metadata_dominance, nir_imm_int(&b, 0));
+      nir_shader_intrinsics_pass(gs, rewrite_invocation_id,
+                                 nir_metadata_control_flow, nir_imm_int(&b, 0));
    }
 
    NIR_PASS(_, gs, nir_shader_intrinsics_pass, lower_gs_inputs,
-            nir_metadata_block_index | nir_metadata_dominance, NULL);
+            nir_metadata_control_flow, NULL);
 
    /* Lower geometry shader writes to contain all of the required counts, so we
     * know where in the various buffers we should write vertices.
@@ -1350,7 +1344,7 @@ agx_nir_lower_gs(nir_shader *gs, const nir_shader *libagx,
    *gs_copy = agx_nir_create_gs_rast_shader(gs, libagx, &side_effects_for_rast);
 
    NIR_PASS(_, gs, nir_shader_intrinsics_pass, lower_id,
-            nir_metadata_block_index | nir_metadata_dominance, NULL);
+            nir_metadata_control_flow, NULL);
 
    link_libagx(gs, libagx);
 
@@ -1392,7 +1386,7 @@ agx_nir_lower_gs(nir_shader *gs, const nir_shader *libagx,
    }
 
    NIR_PASS(_, gs, nir_shader_instructions_pass, agx_lower_output_to_var,
-            nir_metadata_block_index | nir_metadata_dominance, &state);
+            nir_metadata_control_flow, &state);
 
    NIR_PASS(_, gs, nir_shader_intrinsics_pass, lower_gs_instr,
             nir_metadata_none, &gs_state);
@@ -1427,8 +1421,7 @@ agx_nir_lower_gs(nir_shader *gs, const nir_shader *libagx,
       do {
          progress = false;
          NIR_PASS(progress, gs, nir_shader_intrinsics_pass,
-                  strip_side_effect_from_main,
-                  nir_metadata_block_index | nir_metadata_dominance, NULL);
+                  strip_side_effect_from_main, nir_metadata_control_flow, NULL);
 
          NIR_PASS(progress, gs, nir_opt_dce);
          NIR_PASS(progress, gs, nir_opt_dead_cf);
@@ -1442,7 +1435,7 @@ agx_nir_lower_gs(nir_shader *gs, const nir_shader *libagx,
    NIR_PASS(_, gs, nir_opt_move, ~0);
 
    NIR_PASS(_, gs, nir_shader_intrinsics_pass, lower_id,
-            nir_metadata_block_index | nir_metadata_dominance, NULL);
+            nir_metadata_control_flow, NULL);
 
    /* Create auxiliary programs */
    *pre_gs = agx_nir_create_pre_gs(
@@ -1513,9 +1506,8 @@ agx_nir_lower_vs_before_gs(struct nir_shader *vs,
    bool progress = false;
 
    /* Lower vertex stores to memory stores */
-   progress |= nir_shader_intrinsics_pass(
-      vs, lower_vs_before_gs, nir_metadata_block_index | nir_metadata_dominance,
-      NULL);
+   progress |= nir_shader_intrinsics_pass(vs, lower_vs_before_gs,
+                                          nir_metadata_control_flow, NULL);
 
    /* Link libagx, used in lower_vs_before_gs */
    if (progress)

src/asahi/lib/agx_nir_lower_ia.c

@@ -67,7 +67,7 @@ lower_vertex_id(nir_builder *b, nir_intrinsic_instr *intr, void *data)
 bool
 agx_nir_lower_index_buffer(nir_shader *s, unsigned index_size_B, bool patches)
 {
-   return nir_shader_intrinsics_pass(
-      s, lower_vertex_id, nir_metadata_block_index | nir_metadata_dominance,
-      &(struct state){index_size_B, patches});
+   return nir_shader_intrinsics_pass(s, lower_vertex_id,
+                                     nir_metadata_control_flow,
+                                     &(struct state){index_size_B, patches});
 }

src/asahi/lib/agx_nir_lower_msaa.c

@@ -50,9 +50,8 @@ lower_to_per_sample(nir_builder *b, nir_intrinsic_instr *intr, void *data)
 bool
 agx_nir_lower_to_per_sample(nir_shader *shader)
 {
-   return nir_shader_intrinsics_pass(
-      shader, lower_to_per_sample,
-      nir_metadata_block_index | nir_metadata_dominance, NULL);
+   return nir_shader_intrinsics_pass(shader, lower_to_per_sample,
+                                     nir_metadata_control_flow, NULL);
 }
 
 static bool
@@ -112,8 +111,7 @@ agx_nir_wrap_per_sample_loop(nir_shader *shader, uint8_t nr_samples)
 
    /* Use the loop variable for the active sampple mask each iteration */
    nir_shader_intrinsics_pass(shader, lower_active_samples,
-                              nir_metadata_block_index | nir_metadata_dominance,
-                              bit);
+                              nir_metadata_control_flow, bit);
    return true;
 }
 

src/asahi/lib/agx_nir_lower_sample_intrinsics.c

@@ -206,7 +206,6 @@ bool
 agx_nir_lower_sample_intrinsics(nir_shader *shader,
                                 bool ignore_sample_mask_without_msaa)
 {
-   return nir_shader_intrinsics_pass(
-      shader, lower, nir_metadata_block_index | nir_metadata_dominance,
-      &ignore_sample_mask_without_msaa);
+   return nir_shader_intrinsics_pass(shader, lower, nir_metadata_control_flow,
+                                     &ignore_sample_mask_without_msaa);
 }

src/asahi/lib/agx_nir_lower_tess.c

@@ -201,8 +201,7 @@ link_libagx(nir_shader *nir, const nir_shader *libagx)
 bool
 agx_nir_lower_tcs(nir_shader *tcs, const struct nir_shader *libagx)
 {
-   nir_shader_intrinsics_pass(
-      tcs, lower_tcs, nir_metadata_block_index | nir_metadata_dominance, NULL);
+   nir_shader_intrinsics_pass(tcs, lower_tcs, nir_metadata_control_flow, NULL);
 
    link_libagx(tcs, libagx);
    return true;
@@ -261,8 +260,7 @@ agx_nir_lower_tes(nir_shader *tes, const nir_shader *libagx)
    nir_lower_tess_coord_z(
       tes, tes->info.tess._primitive_mode == TESS_PRIMITIVE_TRIANGLES);
 
-   nir_shader_intrinsics_pass(
-      tes, lower_tes, nir_metadata_block_index | nir_metadata_dominance, NULL);
+   nir_shader_intrinsics_pass(tes, lower_tes, nir_metadata_control_flow, NULL);
 
    /* Points mode renders as points, make sure we write point size for the HW */
    if (tes->info.tess.point_mode &&

src/asahi/lib/agx_nir_lower_texture.c

@@ -693,7 +693,7 @@ agx_nir_lower_texture_early(nir_shader *s, bool support_lod_bias)
    bool progress = false;
 
    NIR_PASS(progress, s, nir_shader_intrinsics_pass, lower_robustness,
-            nir_metadata_block_index | nir_metadata_dominance, NULL);
+            nir_metadata_control_flow, NULL);
 
    nir_lower_tex_options lower_tex_options = {
       .lower_txp = ~0,
@@ -717,7 +717,7 @@ agx_nir_lower_texture_early(nir_shader *s, bool support_lod_bias)
     */
    if (support_lod_bias) {
       NIR_PASS(progress, s, nir_shader_instructions_pass, lower_sampler_bias,
-               nir_metadata_block_index | nir_metadata_dominance, NULL);
+               nir_metadata_control_flow, NULL);
    }
 
    return progress;
@@ -740,14 +740,14 @@ agx_nir_lower_texture(nir_shader *s)
     * different fencing than other image operations.
     */
    NIR_PASS(progress, s, nir_shader_intrinsics_pass, fence_image,
-            nir_metadata_block_index | nir_metadata_dominance, NULL);
+            nir_metadata_control_flow, NULL);
 
    NIR_PASS(progress, s, nir_lower_image_atomics_to_global);
 
    NIR_PASS(progress, s, nir_shader_intrinsics_pass, legalize_image_lod,
-            nir_metadata_block_index | nir_metadata_dominance, NULL);
+            nir_metadata_control_flow, NULL);
    NIR_PASS(progress, s, nir_shader_intrinsics_pass, lower_images,
-            nir_metadata_block_index | nir_metadata_dominance, NULL);
+            nir_metadata_control_flow, NULL);
    NIR_PASS(progress, s, nir_legalize_16bit_sampler_srcs, tex_constraints);
 
    /* Fold constants after nir_legalize_16bit_sampler_srcs so we can detect 0 in
@@ -762,7 +762,7 @@ agx_nir_lower_texture(nir_shader *s)
    NIR_PASS(progress, s, nir_shader_instructions_pass, lower_regular_texture,
             nir_metadata_none, NULL);
    NIR_PASS(progress, s, nir_shader_instructions_pass, lower_tex_crawl,
-            nir_metadata_block_index | nir_metadata_dominance, NULL);
+            nir_metadata_control_flow, NULL);
 
    return progress;
 }
@@ -792,9 +792,8 @@ lower_multisampled_store(nir_builder *b, nir_intrinsic_instr *intr,
 bool
 agx_nir_lower_multisampled_image_store(nir_shader *s)
 {
-   return nir_shader_intrinsics_pass(
-      s, lower_multisampled_store,
-      nir_metadata_block_index | nir_metadata_dominance, NULL);
+   return nir_shader_intrinsics_pass(s, lower_multisampled_store,
+                                     nir_metadata_control_flow, NULL);
 }
 
 /*

src/asahi/lib/agx_nir_lower_uvs.c

@@ -148,7 +148,7 @@ agx_nir_lower_uvs(nir_shader *s, struct agx_unlinked_uvs_layout *layout)
 
    /* Determine the unlinked UVS layout */
    NIR_PASS(progress, s, nir_shader_intrinsics_pass, gather_components,
-            nir_metadata_block_index | nir_metadata_dominance, layout);
+            nir_metadata_control_flow, layout);
 
    unsigned sizes[UVS_NUM_GROUP] = {
       [UVS_POSITION] = 4,
@@ -179,7 +179,7 @@ agx_nir_lower_uvs(nir_shader *s, struct agx_unlinked_uvs_layout *layout)
    /* Now lower in terms of the unlinked layout */
    struct ctx ctx = {.layout = layout};
    NIR_PASS(progress, s, nir_shader_intrinsics_pass, lower,
-            nir_metadata_block_index | nir_metadata_dominance, &ctx);
+            nir_metadata_control_flow, &ctx);
 
    if (ctx.layer || ctx.viewport) {
       write_layer_viewport_sysval(&ctx);

src/asahi/lib/agx_nir_lower_vbo.c

@@ -306,6 +306,6 @@ agx_nir_lower_vbo(nir_shader *shader, struct agx_attribute *attribs,
    assert(shader->info.stage == MESA_SHADER_VERTEX);
 
    struct ctx ctx = {.attribs = attribs, .rs = robustness};
-   return nir_shader_intrinsics_pass(
-      shader, pass, nir_metadata_block_index | nir_metadata_dominance, &ctx);
+   return nir_shader_intrinsics_pass(shader, pass, nir_metadata_control_flow,
+                                     &ctx);
 }

src/asahi/lib/agx_nir_prolog_epilog.c

@@ -50,8 +50,7 @@ agx_nir_lower_poly_stipple(nir_shader *s)
    nir_demote_if(b, nir_ieq_imm(b, bit, 0));
    s->info.fs.uses_discard = true;
 
-   nir_metadata_preserve(b->impl,
-                         nir_metadata_dominance | nir_metadata_block_index);
+   nir_metadata_preserve(b->impl, nir_metadata_control_flow);
    return true;
 }
 
@@ -177,8 +176,7 @@ agx_nir_vs_prolog(nir_builder *b, const void *key_)
    /* Finally, lower uniforms according to our ABI */
    unsigned nr = DIV_ROUND_UP(BITSET_LAST_BIT(key->component_mask), 4);
    nir_shader_intrinsics_pass(b->shader, lower_non_monolithic_uniforms,
-                              nir_metadata_dominance | nir_metadata_block_index,
-                              &nr);
+                              nir_metadata_control_flow, &nr);
    b->shader->info.io_lowered = true;
 }
 
@@ -214,10 +212,9 @@ bool
 agx_nir_lower_vs_input_to_prolog(nir_shader *s,
                                  BITSET_WORD *attrib_components_read)
 {
-   return nir_shader_intrinsics_pass(
-      s, lower_input_to_prolog,
-      nir_metadata_dominance | nir_metadata_block_index,
-      attrib_components_read);
+   return nir_shader_intrinsics_pass(s, lower_input_to_prolog,
+                                     nir_metadata_control_flow,
+                                     attrib_components_read);
 }
 
 static bool
@@ -253,9 +250,8 @@ lower_tests_zs(nir_shader *s, bool value)
    if (!s->info.fs.uses_discard)
       return false;
 
-   return nir_shader_intrinsics_pass(
-      s, lower_tests_zs_intr, nir_metadata_dominance | nir_metadata_block_index,
-      &value);
+   return nir_shader_intrinsics_pass(s, lower_tests_zs_intr,
+                                     nir_metadata_control_flow, &value);
 }
 
 static inline bool
@@ -443,8 +439,7 @@ agx_nir_fs_epilog(nir_builder *b, const void *key_)
 
    /* Finally, lower uniforms according to our ABI */
    nir_shader_intrinsics_pass(b->shader, lower_non_monolithic_uniforms,
-                              nir_metadata_dominance | nir_metadata_block_index,
-                              NULL);
+                              nir_metadata_control_flow, NULL);
 
    /* There is no shader part after the epilog, so we're always responsible for
     * running our own tests, unless the fragment shader forced early tests.
@@ -576,8 +571,7 @@ agx_nir_lower_fs_output_to_epilog(nir_shader *s,
    struct lower_epilog_ctx ctx = {.info = out};
 
    nir_shader_intrinsics_pass(s, lower_output_to_epilog,
-                              nir_metadata_dominance | nir_metadata_block_index,
-                              &ctx);
+                              nir_metadata_control_flow, &ctx);
 
    if (ctx.masked_samples) {
       nir_builder b =
@@ -601,9 +595,8 @@ agx_nir_lower_fs_output_to_epilog(nir_shader *s,
 bool
 agx_nir_lower_fs_active_samples_to_register(nir_shader *s)
 {
-   return nir_shader_intrinsics_pass(
-      s, lower_active_samples_to_register,
-      nir_metadata_dominance | nir_metadata_block_index, NULL);
+   return nir_shader_intrinsics_pass(s, lower_active_samples_to_register,
+                                     nir_metadata_control_flow, NULL);
 }
 
 static bool
@@ -620,8 +613,7 @@ agx_nir_lower_stats_fs(nir_shader *s)
    nir_def *addr = nir_load_stat_query_address_agx(b, .base = query);
    nir_global_atomic(b, 32, addr, samples, .atomic_op = nir_atomic_op_iadd);
 
-   nir_metadata_preserve(b->impl,
-                         nir_metadata_block_index | nir_metadata_dominance);
+   nir_metadata_preserve(b->impl, nir_metadata_control_flow);
    return true;
 }
 
@@ -656,8 +648,7 @@ agx_nir_fs_prolog(nir_builder *b, const void *key_)
    NIR_PASS(_, b->shader, agx_nir_lower_discard_zs_emit);
    NIR_PASS(_, b->shader, agx_nir_lower_sample_mask);
    NIR_PASS(_, b->shader, nir_shader_intrinsics_pass,
-            lower_non_monolithic_uniforms,
-            nir_metadata_dominance | nir_metadata_block_index, NULL);
+            lower_non_monolithic_uniforms, nir_metadata_control_flow, NULL);
    NIR_PASS(_, b->shader, lower_tests_zs, key->run_zs_tests);
 
    b->shader->info.io_lowered = true;

src/broadcom/compiler/v3d_nir_lower_image_load_store.c

@@ -453,6 +453,5 @@ v3d_nir_lower_image_load_store(nir_shader *s, struct v3d_compile *c)
 {
         return nir_shader_intrinsics_pass(s,
                                             v3d_nir_lower_image_load_store_cb,
-                                            nir_metadata_block_index |
-                                            nir_metadata_dominance, c);
+                                            nir_metadata_control_flow, c);
 }

src/broadcom/compiler/v3d_nir_lower_io.c

@@ -652,8 +652,7 @@ v3d_nir_lower_io(nir_shader *s, struct v3d_compile *c)
                 }
 
                 nir_metadata_preserve(impl,
-                                      nir_metadata_block_index |
-                                      nir_metadata_dominance);
+                                      nir_metadata_control_flow);
         }
 
         v3d_nir_lower_io_update_output_var_base(c, &state);

src/broadcom/compiler/v3d_nir_lower_line_smooth.c

@@ -166,8 +166,7 @@ v3d_nir_lower_line_smooth(nir_shader *s)
 
                 if (progress) {
                         nir_metadata_preserve(impl,
-                                              nir_metadata_block_index |
-                                              nir_metadata_dominance);
+                                              nir_metadata_control_flow);
                 } else {
                         nir_metadata_preserve(impl, nir_metadata_all);
                 }

src/broadcom/compiler/v3d_nir_lower_load_store_bitsize.c

@@ -225,8 +225,7 @@ v3d_nir_lower_load_store_bitsize(nir_shader *s)
         };
 
         bool res = nir_shader_intrinsics_pass(s, lower_load_store_bitsize,
-                                              nir_metadata_block_index |
-                                              nir_metadata_dominance,
+                                              nir_metadata_control_flow,
                                               NULL);
         res |= nir_lower_mem_access_bit_sizes(s, &lower_options);
         return res;
@@ -236,7 +235,6 @@ bool
 v3d_nir_lower_global_2x32(nir_shader *s)
 {
         return  nir_shader_intrinsics_pass(s, lower_global_2x32,
-                                           nir_metadata_block_index |
-                                           nir_metadata_dominance,
+                                           nir_metadata_control_flow,
                                            NULL);
 }

src/broadcom/compiler/v3d_nir_lower_logic_ops.c

@@ -410,8 +410,7 @@ v3d_nir_lower_logic_ops(nir_shader *s, struct v3d_compile *c)
 
                 if (progress) {
                         nir_metadata_preserve(impl,
-                                              nir_metadata_block_index |
-                                              nir_metadata_dominance);
+                                              nir_metadata_control_flow);
                 } else {
                         nir_metadata_preserve(impl,
                                               nir_metadata_all);

src/broadcom/compiler/v3d_nir_lower_scratch.c

@@ -80,6 +80,5 @@ bool
 v3d_nir_lower_scratch(nir_shader *s)
 {
         return nir_shader_intrinsics_pass(s, v3d_nir_lower_scratch_cb,
-                                            nir_metadata_block_index |
-                                            nir_metadata_dominance, NULL);
+                                            nir_metadata_control_flow, NULL);
 }

src/broadcom/compiler/vir.c

@@ -676,8 +676,7 @@ static bool
 v3d_nir_lower_null_pointers(nir_shader *s)
 {
         return nir_shader_intrinsics_pass(s, v3d_nir_lower_null_pointers_cb,
-                                            nir_metadata_block_index |
-                                            nir_metadata_dominance, NULL);
+                                            nir_metadata_control_flow, NULL);
 }
 
 static void
@@ -1518,8 +1517,7 @@ v3d_nir_sort_constant_ubo_loads(nir_shader *s, struct v3d_compile *c)
                                 v3d_nir_sort_constant_ubo_loads_block(c, block);
                 }
                 nir_metadata_preserve(impl,
-                                      nir_metadata_block_index |
-                                      nir_metadata_dominance);
+                                      nir_metadata_control_flow);
         }
         return c->sorted_any_ubo_loads;
 }
@@ -1616,8 +1614,7 @@ v3d_nir_lower_subgroup_intrinsics(nir_shader *s, struct v3d_compile *c)
                         progress |= lower_subgroup_intrinsics(c, block, &b);
 
                 nir_metadata_preserve(impl,
-                                      nir_metadata_block_index |
-                                      nir_metadata_dominance);
+                                      nir_metadata_control_flow);
         }
         return progress;
 }

src/broadcom/vulkan/v3dv_pipeline.c

@@ -887,8 +887,7 @@ lower_pipeline_layout_info(nir_shader *shader,
    };
 
    progress = nir_shader_instructions_pass(shader, lower_pipeline_layout_cb,
-                                           nir_metadata_block_index |
-                                           nir_metadata_dominance,
+                                           nir_metadata_control_flow,
                                            &state);
 
    *needs_default_sampler_state = state.needs_default_sampler_state;
@@ -921,8 +920,7 @@ v3d_nir_lower_point_coord(nir_shader *s)
 {
    assert(s->info.stage == MESA_SHADER_FRAGMENT);
    return nir_shader_intrinsics_pass(s, lower_point_coord_cb,
-                                       nir_metadata_block_index |
-                                       nir_metadata_dominance, NULL);
+                                       nir_metadata_control_flow, NULL);
 }
 
 static void

src/compiler/glsl/gl_nir_link_varyings.c

@@ -3475,8 +3475,7 @@ fixup_vars_lowered_to_temp(nir_shader *shader, nir_variable_mode mode)
    if (mode == nir_var_shader_in && shader->info.stage == MESA_SHADER_FRAGMENT) {
       (void) nir_shader_instructions_pass(shader,
                                           replace_unused_interpolate_at_with_undef,
-                                          nir_metadata_block_index |
-                                          nir_metadata_dominance,
+                                          nir_metadata_control_flow,
                                           NULL);
    }
 

src/compiler/glsl/gl_nir_linker.c

@@ -1138,7 +1138,7 @@ gl_nir_add_point_size(nir_shader *nir)
    nir->info.outputs_written |= VARYING_BIT_PSIZ;
 
    /* We always modify the entrypoint */
-   nir_metadata_preserve(impl, nir_metadata_block_index | nir_metadata_dominance);
+   nir_metadata_preserve(impl, nir_metadata_control_flow);
    return true;
 }
 
@@ -1174,8 +1174,7 @@ gl_nir_zero_initialize_clip_distance(nir_shader *nir)
    if (clip_dist1)
       zero_array_members(&b, clip_dist1);
 
-   nir_metadata_preserve(impl, nir_metadata_dominance |
-                               nir_metadata_block_index);
+   nir_metadata_preserve(impl, nir_metadata_control_flow);
    return true;
 }
 

src/compiler/glsl/gl_nir_lower_atomics.c

@@ -179,7 +179,6 @@ gl_nir_lower_atomics(nir_shader *shader,
    };
 
    return nir_shader_instructions_pass(shader, gl_nir_lower_atomics_instr,
-                                       nir_metadata_block_index |
-                                       nir_metadata_dominance,
+                                       nir_metadata_control_flow,
                                        &data);
 }

src/compiler/glsl/gl_nir_lower_buffers.c

@@ -313,8 +313,7 @@ lower_buffer_interface_derefs_impl(nir_function_impl *impl,
    }
 
    if (progress) {
-      nir_metadata_preserve(impl, nir_metadata_block_index |
-                                  nir_metadata_dominance);
+      nir_metadata_preserve(impl, nir_metadata_control_flow);
    } else {
       nir_metadata_preserve(impl, nir_metadata_all);
    }

src/compiler/glsl/gl_nir_lower_images.c

@@ -109,7 +109,6 @@ bool
 gl_nir_lower_images(nir_shader *shader, bool bindless_only)
 {
    return nir_shader_instructions_pass(shader, lower_instr,
-                                       nir_metadata_block_index |
-                                       nir_metadata_dominance,
+                                       nir_metadata_control_flow,
                                        &bindless_only);
 }

src/compiler/glsl/gl_nir_lower_named_interface_blocks.c

@@ -307,8 +307,7 @@ lower_named_interface_blocks(struct gl_linked_shader *sh)
    state.mem_ctx = mem_ctx;
    state.interface_namespace = interface_namespace;
    nir_shader_intrinsics_pass(sh->Program->nir, flatten_named_interface_derefs,
-                              nir_metadata_block_index |
-                              nir_metadata_dominance, &state);
+                              nir_metadata_control_flow, &state);
 
    /* Third pass: Mark now lowered blks as ordinary globals to be dead code
     * eliminated. Also use this oppotunity to set the compact flag where

src/compiler/glsl/gl_nir_lower_samplers_as_deref.c

@@ -362,8 +362,7 @@ gl_nir_lower_samplers_as_deref(nir_shader *shader,
                                                _mesa_key_string_equal);
 
    bool progress = nir_shader_instructions_pass(shader, lower_instr,
-                                                nir_metadata_block_index |
-                                                nir_metadata_dominance,
+                                                nir_metadata_control_flow,
                                                 &state);
 
    if (progress) {

src/compiler/nir/nir.c

@@ -2058,8 +2058,7 @@ nir_function_impl_lower_instructions(nir_function_impl *impl,
 {
    nir_builder b = nir_builder_create(impl);
 
-   nir_metadata preserved = nir_metadata_block_index |
-                            nir_metadata_dominance;
+   nir_metadata preserved = nir_metadata_control_flow;
 
    bool progress = false;
    nir_cursor iter = nir_before_impl(impl);

src/compiler/nir/nir_deref.c

@@ -394,8 +394,7 @@ nir_remove_dead_derefs_impl(nir_function_impl *impl)
    }
 
    if (progress) {
-      nir_metadata_preserve(impl, nir_metadata_block_index |
-                                     nir_metadata_dominance);
+      nir_metadata_preserve(impl, nir_metadata_control_flow);
    } else {
       nir_metadata_preserve(impl, nir_metadata_all);
    }
@@ -453,10 +452,9 @@ void
 nir_fixup_deref_modes(nir_shader *shader)
 {
    nir_shader_instructions_pass(shader, nir_fixup_deref_modes_instr,
-                                nir_metadata_block_index |
-                                   nir_metadata_dominance |
-                                   nir_metadata_live_defs |
-                                   nir_metadata_instr_index,
+                                nir_metadata_control_flow |
+                                nir_metadata_live_defs |
+                                nir_metadata_instr_index,
                                 NULL);
 }
 
@@ -497,10 +495,9 @@ void
 nir_fixup_deref_types(nir_shader *shader)
 {
    nir_shader_instructions_pass(shader, nir_fixup_deref_types_instr,
-                                nir_metadata_block_index |
-                                   nir_metadata_dominance |
-                                   nir_metadata_live_defs |
-                                   nir_metadata_instr_index,
+                                nir_metadata_control_flow |
+                                nir_metadata_live_defs |
+                                nir_metadata_instr_index,
                                 NULL);
 }
 
@@ -1548,8 +1545,7 @@ nir_opt_deref_impl(nir_function_impl *impl)
    }
 
    if (progress) {
-      nir_metadata_preserve(impl, nir_metadata_block_index |
-                                     nir_metadata_dominance);
+      nir_metadata_preserve(impl, nir_metadata_control_flow);
    } else {
       nir_metadata_preserve(impl, nir_metadata_all);
    }

src/compiler/nir/nir_from_ssa.c

@@ -1051,8 +1051,7 @@ nir_convert_from_ssa_impl(nir_function_impl *impl,
    }
 
    /* Mark metadata as dirty before we ask for liveness analysis */
-   nir_metadata_preserve(impl, nir_metadata_block_index |
-                                  nir_metadata_dominance);
+   nir_metadata_preserve(impl, nir_metadata_control_flow);
 
    nir_metadata_require(impl, nir_metadata_instr_index |
                                  nir_metadata_live_defs |
@@ -1072,8 +1071,7 @@ nir_convert_from_ssa_impl(nir_function_impl *impl,
       resolve_parallel_copies_block(block, &state);
    }
 
-   nir_metadata_preserve(impl, nir_metadata_block_index |
-                                  nir_metadata_dominance);
+   nir_metadata_preserve(impl, nir_metadata_control_flow);
 
    /* Clean up dead instructions and the hash tables */
    nir_instr_free_list(&state.dead_instrs);

src/compiler/nir/nir_group_loads.c

@@ -475,8 +475,7 @@ nir_group_loads(nir_shader *shader, nir_load_grouping grouping,
          process_block(block, grouping, max_distance);
       }
 
-      nir_metadata_preserve(impl, nir_metadata_block_index |
-                                     nir_metadata_dominance |
+      nir_metadata_preserve(impl, nir_metadata_control_flow |
                                      nir_metadata_loop_analysis);
    }
 }

src/compiler/nir/nir_inline_uniforms.c

@@ -465,8 +465,7 @@ nir_inline_uniforms(nir_shader *shader, unsigned num_uniforms,
             }
          }
 
-         nir_metadata_preserve(impl, nir_metadata_block_index |
-                                        nir_metadata_dominance);
+         nir_metadata_preserve(impl, nir_metadata_control_flow);
       }
    }
 }

src/compiler/nir/nir_legacy.c

@@ -328,8 +328,7 @@ nir_legacy_trivialize(nir_shader *s, bool fuse_fabs)
     * chase registers recursively, allowing registers to be trivialized easier.
     */
    if (nir_shader_instructions_pass(s, fuse_mods_with_registers,
-                                    nir_metadata_block_index |
-                                       nir_metadata_dominance,
+                                    nir_metadata_control_flow,
                                     &fuse_fabs)) {
       /* If we made progress, we likely left dead loads. Clean them up. */
       NIR_PASS_V(s, nir_opt_dce);

src/compiler/nir/nir_linking_helpers.c

@@ -167,8 +167,7 @@ nir_remove_unused_io_vars(nir_shader *shader,
 
    nir_function_impl *impl = nir_shader_get_entrypoint(shader);
    if (progress) {
-      nir_metadata_preserve(impl, nir_metadata_dominance |
-                                     nir_metadata_block_index);
+      nir_metadata_preserve(impl, nir_metadata_control_flow);
       nir_fixup_deref_modes(shader);
    } else {
       nir_metadata_preserve(impl, nir_metadata_all);

src/compiler/nir/nir_lower_alpha_test.c

@@ -103,7 +103,6 @@ nir_lower_alpha_test(nir_shader *shader, enum compare_func func,
    };
 
    return nir_shader_intrinsics_pass(shader, lower,
-                                     nir_metadata_block_index |
-                                        nir_metadata_dominance,
+                                     nir_metadata_control_flow,
                                      &state);
 }

src/compiler/nir/nir_lower_alu.c

@@ -231,7 +231,6 @@ nir_lower_alu(nir_shader *shader)
       return false;
 
    return nir_shader_instructions_pass(shader, lower_alu_instr,
-                                       nir_metadata_block_index |
-                                          nir_metadata_dominance,
+                                       nir_metadata_control_flow,
                                        NULL);
 }

src/compiler/nir/nir_lower_alu_width.c

@@ -493,6 +493,6 @@ bool
 nir_lower_alu_vec8_16_srcs(nir_shader *shader)
 {
    return nir_shader_instructions_pass(shader, lower_alu_vec8_16_src,
-      nir_metadata_block_index | nir_metadata_dominance,
+      nir_metadata_control_flow,
       NULL);
 }

src/compiler/nir/nir_lower_amul.c

@@ -269,8 +269,7 @@ nir_lower_amul(nir_shader *shader,
          }
       }
 
-      nir_metadata_preserve(impl, nir_metadata_block_index |
-                                     nir_metadata_dominance);
+      nir_metadata_preserve(impl, nir_metadata_control_flow);
    }
 
    return state.progress;

src/compiler/nir/nir_lower_array_deref_of_vec.c

@@ -127,8 +127,7 @@ nir_lower_array_deref_of_vec_impl(nir_function_impl *impl,
    }
 
    if (progress) {
-      nir_metadata_preserve(impl, nir_metadata_block_index |
-                                     nir_metadata_dominance);
+      nir_metadata_preserve(impl, nir_metadata_control_flow);
    } else {
       nir_metadata_preserve(impl, nir_metadata_all);
    }

src/compiler/nir/nir_lower_atomics_to_ssbo.c

@@ -196,8 +196,7 @@ nir_lower_atomics_to_ssbo(nir_shader *shader, unsigned offset_align_state)
          }
       }
 
-      nir_metadata_preserve(impl, nir_metadata_block_index |
-                                     nir_metadata_dominance);
+      nir_metadata_preserve(impl, nir_metadata_control_flow);
    }
 
    if (progress) {

src/compiler/nir/nir_lower_bit_size.c

@@ -285,8 +285,7 @@ lower_impl(nir_function_impl *impl,
    }
 
    if (progress) {
-      nir_metadata_preserve(impl, nir_metadata_block_index |
-                                     nir_metadata_dominance);
+      nir_metadata_preserve(impl, nir_metadata_control_flow);
    } else {
       nir_metadata_preserve(impl, nir_metadata_all);
    }
@@ -362,7 +361,6 @@ bool
 nir_lower_64bit_phis(nir_shader *shader)
 {
    return nir_shader_instructions_pass(shader, lower_64bit_phi_instr,
-                                       nir_metadata_block_index |
-                                          nir_metadata_dominance,
+                                       nir_metadata_control_flow,
                                        NULL);
 }

src/compiler/nir/nir_lower_bitmap.c

@@ -106,8 +106,7 @@ lower_bitmap_impl(nir_function_impl *impl,
 
    lower_bitmap(impl->function->shader, &b, options);
 
-   nir_metadata_preserve(impl, nir_metadata_block_index |
-                                  nir_metadata_dominance);
+   nir_metadata_preserve(impl, nir_metadata_control_flow);
 }
 
 bool

src/compiler/nir/nir_lower_blend.c

@@ -645,13 +645,11 @@ nir_lower_blend(nir_shader *shader, const nir_lower_blend_options *options)
 
    struct ctx ctx = { .options = options };
    bool progress = nir_shader_intrinsics_pass(shader, consume_dual_stores,
-                                              nir_metadata_block_index |
-                                                 nir_metadata_dominance,
+                                              nir_metadata_control_flow,
                                               ctx.src1);
 
    progress |= nir_shader_intrinsics_pass(shader, nir_lower_blend_instr,
-                                          nir_metadata_block_index |
-                                             nir_metadata_dominance,
+                                          nir_metadata_control_flow,
                                           &ctx);
    return progress;
 }

src/compiler/nir/nir_lower_bool_to_bitsize.c

@@ -413,7 +413,6 @@ bool
 nir_lower_bool_to_bitsize(nir_shader *shader)
 {
    return nir_shader_instructions_pass(shader, nir_lower_bool_to_bitsize_instr,
-                                       nir_metadata_block_index |
-                                          nir_metadata_dominance,
+                                       nir_metadata_control_flow,
                                        NULL);
 }

src/compiler/nir/nir_lower_bool_to_float.c

@@ -261,7 +261,6 @@ nir_lower_bool_to_float(nir_shader *shader, bool has_fcsel_ne)
    };
 
    return nir_shader_instructions_pass(shader, nir_lower_bool_to_float_instr,
-                                       nir_metadata_block_index |
-                                          nir_metadata_dominance,
+                                       nir_metadata_control_flow,
                                        &data);
 }

src/compiler/nir/nir_lower_bool_to_int32.c

@@ -228,8 +228,7 @@ nir_lower_bool_to_int32(nir_shader *shader)
 
    progress |=
       nir_shader_instructions_pass(shader, nir_lower_bool_to_int32_instr,
-                                   nir_metadata_block_index |
-                                      nir_metadata_dominance,
+                                   nir_metadata_control_flow,
                                    NULL);
    return progress;
 }

src/compiler/nir/nir_lower_cl_images.c

@@ -84,8 +84,7 @@ nir_dedup_inline_samplers(nir_shader *nir)
    exec_list_make_empty(&inline_samplers);
 
    nir_shader_instructions_pass(nir, nir_dedup_inline_samplers_instr,
-                                nir_metadata_block_index |
-                                   nir_metadata_dominance,
+                                nir_metadata_control_flow,
                                 &inline_samplers);
 
    /* If we found any inline samplers in the instructions pass, they'll now be
@@ -287,8 +286,7 @@ nir_lower_cl_images(nir_shader *shader, bool lower_image_derefs, bool lower_samp
    }
 
    if (progress) {
-      nir_metadata_preserve(impl, nir_metadata_block_index |
-                                     nir_metadata_dominance);
+      nir_metadata_preserve(impl, nir_metadata_control_flow);
    } else {
       nir_metadata_preserve(impl, nir_metadata_all);
    }

src/compiler/nir/nir_lower_clamp_color_outputs.c

@@ -93,7 +93,6 @@ bool
 nir_lower_clamp_color_outputs(nir_shader *shader)
 {
    return nir_shader_instructions_pass(shader, lower_instr,
-                                       nir_metadata_block_index |
-                                          nir_metadata_dominance,
+                                       nir_metadata_control_flow,
                                        shader);
 }

src/compiler/nir/nir_lower_clip_cull_distance_arrays.c

@@ -369,8 +369,7 @@ lower_distance_to_vec4(nir_shader *shader, struct lower_distance_state *state)
 
    /* Replace derefs */
    nir_shader_intrinsics_pass(shader, replace_with_derefs_to_vec4,
-                              nir_metadata_block_index |
-                              nir_metadata_dominance, state);
+                              nir_metadata_control_flow, state);
 
    /* Mark now lowered vars as ordinary globals to be dead code eliminated.
     * Also clear the compact flag to avoid issues with validation.
@@ -518,10 +517,9 @@ nir_lower_clip_cull_distance_arrays(nir_shader *nir)
    nir_foreach_function_impl(impl, nir) {
       if (progress) {
          nir_metadata_preserve(impl,
-                               nir_metadata_block_index |
-                                  nir_metadata_dominance |
-                                  nir_metadata_live_defs |
-                                  nir_metadata_loop_analysis);
+                               nir_metadata_control_flow |
+                               nir_metadata_live_defs |
+                               nir_metadata_loop_analysis);
       } else {
          nir_metadata_preserve(impl, nir_metadata_all);
       }

src/compiler/nir/nir_lower_clip_disable.c

@@ -174,7 +174,6 @@ nir_lower_clip_disable(nir_shader *shader, unsigned clip_plane_enable)
 
    return nir_shader_intrinsics_pass(shader,
                                      shader->info.io_lowered ? lower_clip_plane_store_io : lower_clip_plane_store,
-                                       nir_metadata_block_index |
-                                          nir_metadata_dominance,
+                                       nir_metadata_control_flow,
                                        &clip_plane_enable);
 }

src/compiler/nir/nir_lower_clip_halfz.c

@@ -60,7 +60,6 @@ nir_lower_clip_halfz(nir_shader *shader)
       return;
 
    nir_shader_intrinsics_pass(shader, lower_pos_write,
-                                nir_metadata_block_index |
-                                   nir_metadata_dominance,
+                                nir_metadata_control_flow,
                                 NULL);
 }

src/compiler/nir/nir_lower_const_arrays_to_uniforms.c

@@ -407,8 +407,7 @@ nir_lower_const_arrays_to_uniforms(nir_shader *shader,
       }
    }
 
-   nir_metadata_preserve(impl, nir_metadata_block_index |
-                                  nir_metadata_dominance);
+   nir_metadata_preserve(impl, nir_metadata_control_flow);
 
    ralloc_free(var_infos);
    _mesa_hash_table_destroy(const_array_vars, NULL);

src/compiler/nir/nir_lower_convert_alu_types.c

@@ -94,8 +94,7 @@ opt_simplify_convert_alu_types_impl(nir_function_impl *impl)
    }
 
    if (lowered_instr) {
-      nir_metadata_preserve(impl, nir_metadata_block_index |
-                                     nir_metadata_dominance);
+      nir_metadata_preserve(impl, nir_metadata_control_flow);
    } else {
       nir_metadata_preserve(impl, nir_metadata_all);
    }
@@ -142,8 +141,7 @@ lower_convert_alu_types_impl(nir_function_impl *impl,
    }
 
    if (progress) {
-      nir_metadata_preserve(impl, nir_metadata_block_index |
-                                     nir_metadata_dominance);
+      nir_metadata_preserve(impl, nir_metadata_control_flow);
    } else {
       nir_metadata_preserve(impl, nir_metadata_all);
    }

src/compiler/nir/nir_lower_double_ops.c

@@ -871,8 +871,7 @@ nir_lower_doubles_impl(nir_function_impl *impl,
        */
       nir_opt_deref_impl(impl);
    } else if (progress) {
-      nir_metadata_preserve(impl, nir_metadata_block_index |
-                                     nir_metadata_dominance);
+      nir_metadata_preserve(impl, nir_metadata_control_flow);
    } else {
       nir_metadata_preserve(impl, nir_metadata_all);
    }

src/compiler/nir/nir_lower_drawpixels.c

@@ -254,7 +254,6 @@ nir_lower_drawpixels(nir_shader *shader,
    assert(shader->info.stage == MESA_SHADER_FRAGMENT);
 
    return nir_shader_instructions_pass(shader, lower_drawpixels_instr,
-                                       nir_metadata_block_index |
-                                          nir_metadata_dominance,
+                                       nir_metadata_control_flow,
                                        &state);
 }

src/compiler/nir/nir_lower_fb_read.c

@@ -87,7 +87,6 @@ nir_lower_fb_read(nir_shader *shader)
    assert(shader->info.stage == MESA_SHADER_FRAGMENT);
 
    return nir_shader_intrinsics_pass(shader, nir_lower_fb_read_instr,
-                                       nir_metadata_block_index |
-                                          nir_metadata_dominance,
+                                       nir_metadata_control_flow,
                                        NULL);
 }

src/compiler/nir/nir_lower_flrp.c

@@ -634,8 +634,7 @@ lower_flrp_impl(nir_function_impl *impl,
       }
    }
 
-   nir_metadata_preserve(impl, nir_metadata_block_index |
-                                  nir_metadata_dominance);
+   nir_metadata_preserve(impl, nir_metadata_control_flow);
 }
 
 /**

src/compiler/nir/nir_lower_frag_coord_to_pixel_coord.c

@@ -29,6 +29,6 @@ bool
 nir_lower_frag_coord_to_pixel_coord(nir_shader *shader)
 {
    return nir_shader_intrinsics_pass(shader, lower,
-                                     nir_metadata_block_index | nir_metadata_dominance,
+                                     nir_metadata_control_flow,
                                      NULL);
 }

src/compiler/nir/nir_lower_fragcolor.c

@@ -97,7 +97,6 @@ nir_lower_fragcolor(nir_shader *shader, unsigned max_draw_buffers)
       return false;
 
    return nir_shader_intrinsics_pass(shader, lower_fragcolor_intrin,
-                                     nir_metadata_block_index |
-                                       nir_metadata_dominance,
+                                     nir_metadata_control_flow,
                                      &max_draw_buffers);
 }

src/compiler/nir/nir_lower_frexp.c

@@ -189,7 +189,6 @@ bool
 nir_lower_frexp(nir_shader *shader)
 {
    return nir_shader_instructions_pass(shader, lower_frexp_instr,
-                                       nir_metadata_block_index |
-                                          nir_metadata_dominance,
+                                       nir_metadata_control_flow,
                                        NULL);
 }

src/compiler/nir/nir_lower_global_vars_to_local.c

@@ -88,8 +88,7 @@ nir_lower_global_vars_to_local(nir_shader *shader)
          exec_node_remove(&var->node);
          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 |
+         nir_metadata_preserve(impl, nir_metadata_control_flow |
                                         nir_metadata_live_defs);
          progress = true;
       }

src/compiler/nir/nir_lower_image.c

@@ -218,7 +218,6 @@ bool
 nir_lower_image(nir_shader *nir, const nir_lower_image_options *options)
 {
    return nir_shader_intrinsics_pass(nir, lower_image_intrin,
-                                     nir_metadata_block_index |
-                                        nir_metadata_dominance,
+                                     nir_metadata_control_flow,
                                      (void *)options);
 }

src/compiler/nir/nir_lower_image_atomics_to_global.c

@@ -98,7 +98,6 @@ bool
 nir_lower_image_atomics_to_global(nir_shader *shader)
 {
    return nir_shader_intrinsics_pass(shader, lower,
-                                     nir_metadata_block_index |
-                                        nir_metadata_dominance,
+                                     nir_metadata_control_flow,
                                      NULL);
 }

src/compiler/nir/nir_lower_input_attachments.c

@@ -215,7 +215,6 @@ nir_lower_input_attachments(nir_shader *shader,
    assert(shader->info.stage == MESA_SHADER_FRAGMENT);
 
    return nir_shader_instructions_pass(shader, lower_input_attachments_instr,
-                                       nir_metadata_block_index |
-                                          nir_metadata_dominance,
+                                       nir_metadata_control_flow,
                                        (void *)options);
 }

src/compiler/nir/nir_lower_int_to_float.c

@@ -299,8 +299,7 @@ nir_lower_int_to_float_impl(nir_function_impl *impl)
    }
 
    if (progress) {
-      nir_metadata_preserve(impl, nir_metadata_block_index |
-                                     nir_metadata_dominance);
+      nir_metadata_preserve(impl, nir_metadata_control_flow);
    } else {
       nir_metadata_preserve(impl, nir_metadata_all);
    }

src/compiler/nir/nir_lower_interpolation.c

@@ -125,7 +125,6 @@ bool
 nir_lower_interpolation(nir_shader *shader, nir_lower_interpolation_options options)
 {
    return nir_shader_instructions_pass(shader, nir_lower_interpolation_instr,
-                                       nir_metadata_block_index |
-                                          nir_metadata_dominance,
+                                       nir_metadata_control_flow,
                                        &options);
 }

src/compiler/nir/nir_lower_io.c

@@ -2487,8 +2487,7 @@ nir_lower_vars_to_explicit_types_impl(nir_function_impl *impl,
    }
 
    if (progress) {
-      nir_metadata_preserve(impl, nir_metadata_block_index |
-                                     nir_metadata_dominance |
+      nir_metadata_preserve(impl, nir_metadata_control_flow |
                                      nir_metadata_live_defs |
                                      nir_metadata_loop_analysis);
    } else {
@@ -3042,7 +3041,7 @@ nir_io_add_const_offset_to_base(nir_shader *nir, nir_variable_mode modes)
       }
       progress |= impl_progress;
       if (impl_progress)
-         nir_metadata_preserve(impl, nir_metadata_block_index | nir_metadata_dominance);
+         nir_metadata_preserve(impl, nir_metadata_control_flow);
       else
          nir_metadata_preserve(impl, nir_metadata_all);
    }
@@ -3123,8 +3122,7 @@ nir_lower_color_inputs(nir_shader *nir)
    }
 
    if (progress) {
-      nir_metadata_preserve(impl, nir_metadata_dominance |
-                                     nir_metadata_block_index);
+      nir_metadata_preserve(impl, nir_metadata_control_flow);
    } else {
       nir_metadata_preserve(impl, nir_metadata_all);
    }

src/compiler/nir/nir_lower_io_to_scalar.c

@@ -315,8 +315,7 @@ nir_lower_io_to_scalar(nir_shader *shader, nir_variable_mode mask, nir_instr_fil
    };
    return nir_shader_instructions_pass(shader,
                                        nir_lower_io_to_scalar_instr,
-                                       nir_metadata_block_index |
-                                          nir_metadata_dominance,
+                                       nir_metadata_control_flow,
                                        &state);
 }
 
@@ -564,8 +563,7 @@ nir_lower_io_to_scalar_early(nir_shader *shader, nir_variable_mode mask)
 
    bool progress = nir_shader_instructions_pass(shader,
                                                 nir_lower_io_to_scalar_early_instr,
-                                                nir_metadata_block_index |
-                                                   nir_metadata_dominance,
+                                                nir_metadata_control_flow,
                                                 &state);
 
    /* Remove old input from the shaders inputs list */

src/compiler/nir/nir_lower_io_to_temporaries.c

@@ -368,8 +368,7 @@ nir_lower_io_to_temporaries(nir_shader *shader, nir_function_impl *entrypoint,
       if (outputs)
          emit_output_copies_impl(&state, impl);
 
-      nir_metadata_preserve(impl, nir_metadata_block_index |
-                                     nir_metadata_dominance);
+      nir_metadata_preserve(impl, nir_metadata_control_flow);
    }
 
    exec_list_append(&shader->variables, &state.old_inputs);

src/compiler/nir/nir_lower_io_to_vector.c

@@ -597,8 +597,7 @@ nir_lower_io_to_vector_impl(nir_function_impl *impl, nir_variable_mode modes)
    util_dynarray_fini(&demote_vars);
 
    if (progress) {
-      nir_metadata_preserve(impl, nir_metadata_block_index |
-                                     nir_metadata_dominance);
+      nir_metadata_preserve(impl, nir_metadata_control_flow);
    }
 
    return progress;
@@ -688,7 +687,7 @@ nir_vectorize_tess_levels_impl(nir_function_impl *impl)
    }
 
    if (progress)
-      nir_metadata_preserve(impl, nir_metadata_block_index | nir_metadata_dominance);
+      nir_metadata_preserve(impl, nir_metadata_control_flow);
    else
       nir_metadata_preserve(impl, nir_metadata_all);
 

src/compiler/nir/nir_lower_is_helper_invocation.c

@@ -112,7 +112,6 @@ nir_lower_is_helper_invocation(nir_shader *shader)
    nir_store_deref(&b, is_helper_deref, started_as_helper, 1);
 
    return nir_shader_intrinsics_pass(shader, lower_load_and_store_is_helper,
-                                     nir_metadata_block_index |
-                                        nir_metadata_dominance,
+                                     nir_metadata_control_flow,
                                      is_helper_deref);
 }