From 463e3643f20fec7f8433df408a57f7a5d808dd89 Mon Sep 17 00:00:00 2001 From: Rhys Perry Date: Thu, 5 Mar 2026 10:25:10 +0000 Subject: [PATCH] nir: add and use block predecessor helpers Signed-off-by: Rhys Perry Acked-by: Alyssa Rosenzweig Reviewed-by: Georg Lehmann Part-of: --- src/.clang-format | 2 + .../instruction_selection/aco_isel_setup.cpp | 2 +- .../instruction_selection/aco_select_nir.cpp | 2 +- src/amd/vulkan/nir/radv_nir_lower_call_abi.c | 5 +- src/compiler/nir/nir.c | 16 +++--- src/compiler/nir/nir.h | 53 +++++++++++++++++++ src/compiler/nir/nir_control_flow.c | 43 ++++----------- src/compiler/nir/nir_divergence_analysis.c | 2 +- src/compiler/nir/nir_dominance.c | 10 ++-- src/compiler/nir/nir_from_ssa.c | 8 ++- src/compiler/nir/nir_gs_count_vertices.c | 4 +- src/compiler/nir/nir_liveness.c | 3 +- src/compiler/nir/nir_lower_clip.c | 2 +- .../nir/nir_lower_continue_constructs.c | 4 +- src/compiler/nir/nir_lower_discard_if.c | 5 +- src/compiler/nir/nir_lower_gs_intrinsics.c | 7 +-- .../nir/nir_lower_io_vars_to_temporaries.c | 3 +- src/compiler/nir/nir_lower_returns.c | 2 +- src/compiler/nir/nir_opt_dce.c | 5 +- src/compiler/nir/nir_opt_dead_cf.c | 2 +- src/compiler/nir/nir_opt_if.c | 20 +++---- src/compiler/nir/nir_opt_licm.c | 2 +- .../nir/nir_opt_load_store_vectorize.c | 6 +-- src/compiler/nir/nir_opt_loop.c | 6 +-- src/compiler/nir/nir_opt_remove_phis.c | 2 +- src/compiler/nir/nir_opt_sink.c | 4 +- src/compiler/nir/nir_phi_builder.c | 2 +- src/compiler/nir/nir_print.c | 4 +- src/compiler/nir/nir_to_lcssa.c | 4 +- src/compiler/nir/nir_validate.c | 11 ++-- src/compiler/nir/tests/control_flow_tests.cpp | 30 +++++------ src/freedreno/ir3/ir3_compiler_nir.c | 5 +- src/freedreno/ir3/ir3_nir_lower_tess.c | 2 +- src/gallium/auxiliary/nir/nir_to_tgsi.c | 4 +- .../etnaviv/etnaviv_compiler_nir_liveness.c | 3 +- .../nouveau/codegen/nv50_ir_from_nir.cpp | 2 +- src/gallium/drivers/zink/zink_compiler.c | 2 +- .../brw/brw_nir_lower_intersection_shader.c | 5 +- .../compiler/brw/brw_nir_lower_shader_calls.c | 7 ++- .../compiler/intel_nir_tcs_workarounds.c | 6 +-- src/nouveau/compiler/nak_nir_lower_cf.c | 4 +- .../compiler/nak_nir_lower_gs_intrinsics.c | 5 +- 42 files changed, 160 insertions(+), 156 deletions(-) diff --git a/src/.clang-format b/src/.clang-format index 22ba63a5b63..7e22bed1676 100644 --- a/src/.clang-format +++ b/src/.clang-format @@ -172,6 +172,8 @@ ForEachMacros: - nir_foreach_block_reverse_safe - nir_foreach_block_safe + - nir_foreach_pred + - nir_precomp_foreach_arg - nir_precomp_foreach_variant_param diff --git a/src/amd/compiler/instruction_selection/aco_isel_setup.cpp b/src/amd/compiler/instruction_selection/aco_isel_setup.cpp index 78836c47f11..c4d28a198f3 100644 --- a/src/amd/compiler/instruction_selection/aco_isel_setup.cpp +++ b/src/amd/compiler/instruction_selection/aco_isel_setup.cpp @@ -141,7 +141,7 @@ sanitize_cf_list(nir_function_impl* impl, struct exec_list* cf_list) * from the loop header are live. Handle this without complicating the ACO IR by creating a * dummy break. */ - if (nir_cf_node_cf_tree_next(&loop->cf_node)->predecessors.entries == 0) { + if (nir_block_num_preds(nir_cf_node_cf_tree_next(&loop->cf_node)) == 0) { nir_builder b = nir_builder_create(impl); b.cursor = nir_after_block_before_jump(nir_loop_last_block(loop)); diff --git a/src/amd/compiler/instruction_selection/aco_select_nir.cpp b/src/amd/compiler/instruction_selection/aco_select_nir.cpp index 0b927033d6d..b4589fc51e3 100644 --- a/src/amd/compiler/instruction_selection/aco_select_nir.cpp +++ b/src/amd/compiler/instruction_selection/aco_select_nir.cpp @@ -944,7 +944,7 @@ visit_loop(isel_context* ctx, nir_loop* loop) loop_context lc; begin_loop(ctx, &lc); ctx->cf_info.parent_loop.has_divergent_break = - loop->divergent_break && nir_loop_first_block(loop)->predecessors.entries > 1; + loop->divergent_break && nir_block_num_preds(nir_loop_first_block(loop)) > 1; ctx->cf_info.in_divergent_cf |= ctx->cf_info.parent_loop.has_divergent_break; visit_cf_list(ctx, &loop->body); diff --git a/src/amd/vulkan/nir/radv_nir_lower_call_abi.c b/src/amd/vulkan/nir/radv_nir_lower_call_abi.c index 60619de53fb..74df17d2d0a 100644 --- a/src/amd/vulkan/nir/radv_nir_lower_call_abi.c +++ b/src/amd/vulkan/nir/radv_nir_lower_call_abi.c @@ -167,9 +167,8 @@ gather_tail_call_instrs_block(nir_function *caller, const struct nir_block *bloc _mesa_set_add(tail_calls, instr); } - set_foreach (&block->predecessors, pred) { - gather_tail_call_instrs_block(caller, pred->key, tail_calls); - } + nir_foreach_pred (pred, block) + gather_tail_call_instrs_block(caller, pred, tail_calls); } struct lower_param_info { diff --git a/src/compiler/nir/nir.c b/src/compiler/nir/nir.c index acb2de72210..8ec562d2fec 100644 --- a/src/compiler/nir/nir.c +++ b/src/compiler/nir/nir.c @@ -715,7 +715,7 @@ nir_function_impl_create_bare(nir_shader *shader) exec_list_push_tail(&impl->body, &start_block->cf_node.node); start_block->successors[0] = end_block; - _mesa_set_add(&end_block->predecessors, start_block); + nir_block_add_pred(end_block, start_block); return impl; } @@ -791,7 +791,7 @@ nir_loop_create(nir_shader *shader) body->cf_node.parent = &loop->cf_node; body->successors[0] = body; - _mesa_set_add(&body->predecessors, body); + nir_block_add_pred(body, body); exec_list_make_empty(&loop->continue_list); @@ -2151,16 +2151,14 @@ compare_block_index(const void *p1, const void *p2) nir_block ** nir_block_get_predecessors_sorted(const nir_block *block, void *mem_ctx) { - nir_block **preds = - ralloc_array(mem_ctx, nir_block *, block->predecessors.entries); + unsigned count = nir_block_num_preds(block); + nir_block **preds = ralloc_array(mem_ctx, nir_block *, count); unsigned i = 0; - set_foreach(&block->predecessors, entry) - preds[i++] = (nir_block *)entry->key; - assert(i == block->predecessors.entries); + nir_foreach_pred(pred, block) + preds[i++] = pred; - qsort(preds, block->predecessors.entries, sizeof(nir_block *), - compare_block_index); + qsort(preds, count, sizeof(nir_block *), compare_block_index); return preds; } diff --git a/src/compiler/nir/nir.h b/src/compiler/nir/nir.h index 2e3fe5d91d3..600ccd21cfe 100644 --- a/src/compiler/nir/nir.h +++ b/src/compiler/nir/nir.h @@ -3311,6 +3311,59 @@ typedef struct nir_block { struct u_sparse_bitset live_out; } nir_block; +static ALWAYS_INLINE nir_block * +_nir_pred_iter_begin(const nir_block *block, nir_block **iter) +{ + struct set_entry *entry = _mesa_set_next_entry(&block->predecessors, NULL); + *iter = (nir_block *)entry; + return entry ? (nir_block *)entry->key : NULL; +} + +static ALWAYS_INLINE nir_block * +_nir_pred_iter_end(const nir_block *block) +{ + struct set_entry *entry = NULL; + return (nir_block *)entry; +} + +static ALWAYS_INLINE nir_block * +_nir_pred_iter_advance(const nir_block *block, nir_block **iter) +{ + struct set_entry *entry = (struct set_entry *)*iter; + entry = _mesa_set_next_entry(&block->predecessors, entry); + *iter = (nir_block *)entry; + return entry ? (nir_block *)entry->key : NULL; +} + +#define nir_foreach_pred(pred, block) \ + for (nir_block * pred##_iter, *pred = _nir_pred_iter_begin((block), &pred##_iter); \ + pred##_iter != _nir_pred_iter_end((block)); \ + pred = _nir_pred_iter_advance((block), &pred##_iter)) + +static inline size_t +nir_block_num_preds(const nir_block *block) +{ + return block->predecessors.entries; +} + +static inline bool +nir_block_has_pred(const nir_block *block, const nir_block *pred) +{ + return _mesa_set_search(&block->predecessors, pred); +} + +static inline void +nir_block_add_pred(nir_block *block, nir_block *pred) +{ + _mesa_set_add(&block->predecessors, pred); +} + +static inline void +nir_block_remove_pred(nir_block *block, nir_block *pred) +{ + _mesa_set_remove_key(&block->predecessors, pred); +} + static inline bool nir_block_is_reachable(nir_block *b) { diff --git a/src/compiler/nir/nir_control_flow.c b/src/compiler/nir/nir_control_flow.c index ab7f151387b..35d0c7ee5d9 100644 --- a/src/compiler/nir/nir_control_flow.c +++ b/src/compiler/nir/nir_control_flow.c @@ -45,32 +45,16 @@ */ /*@{*/ -static inline void -block_add_pred(nir_block *block, nir_block *pred) -{ - _mesa_set_add(&block->predecessors, pred); -} - -static inline void -block_remove_pred(nir_block *block, nir_block *pred) -{ - struct set_entry *entry = _mesa_set_search(&block->predecessors, pred); - - assert(entry); - - _mesa_set_remove(&block->predecessors, entry); -} - static void link_blocks(nir_block *pred, nir_block *succ1, nir_block *succ2) { pred->successors[0] = succ1; if (succ1 != NULL) - block_add_pred(succ1, pred); + nir_block_add_pred(succ1, pred); pred->successors[1] = succ2; if (succ2 != NULL) - block_add_pred(succ2, pred); + nir_block_add_pred(succ2, pred); } static void @@ -84,7 +68,7 @@ unlink_blocks(nir_block *pred, nir_block *succ) pred->successors[1] = NULL; } - block_remove_pred(succ, pred); + nir_block_remove_pred(succ, pred); } static void @@ -169,8 +153,8 @@ replace_successor(nir_block *block, nir_block *old_succ, nir_block *new_succ) block->successors[1] = new_succ; } - block_remove_pred(old_succ, block); - block_add_pred(new_succ, block); + nir_block_remove_pred(old_succ, block); + nir_block_add_pred(new_succ, block); } /** @@ -188,10 +172,8 @@ split_block_beginning(nir_block *block) new_block->cf_node.parent = block->cf_node.parent; exec_node_insert_node_before(&block->cf_node.node, &new_block->cf_node.node); - set_foreach(&block->predecessors, entry) { - nir_block *pred = (nir_block *)entry->key; + nir_foreach_pred(pred, block) replace_successor(pred, block, new_block); - } /* Any phi nodes must stay part of the new block, or else their * sources will be messed up. @@ -437,9 +419,8 @@ nir_loop_add_continue_construct(nir_loop *loop) /* change predecessors and successors */ nir_block *header = nir_loop_first_block(loop); nir_block *preheader = nir_block_cf_tree_prev(header); - assert(header->predecessors.entries <= 2); - set_foreach(&header->predecessors, entry) { - nir_block *pred = (nir_block *)entry->key; + assert(nir_block_num_preds(header) <= 2); + nir_foreach_pred(pred, header) { if (pred != preheader) replace_successor(pred, header, cont); } @@ -455,12 +436,10 @@ nir_loop_remove_continue_construct(nir_loop *loop) /* change predecessors and successors */ nir_block *header = nir_loop_first_block(loop); nir_block *cont = nir_loop_first_continue_block(loop); - assert(cont->predecessors.entries <= 2); - set_foreach(&cont->predecessors, entry) { - nir_block *pred = (nir_block *)entry->key; + assert(nir_block_num_preds(cont) <= 2); + nir_foreach_pred(pred, cont) replace_successor(pred, cont, header); - } - block_remove_pred(header, cont); + nir_block_remove_pred(header, cont); exec_node_remove(&cont->cf_node.node); } diff --git a/src/compiler/nir/nir_divergence_analysis.c b/src/compiler/nir/nir_divergence_analysis.c index 8f428170a3e..32ebac13524 100644 --- a/src/compiler/nir/nir_divergence_analysis.c +++ b/src/compiler/nir/nir_divergence_analysis.c @@ -1511,7 +1511,7 @@ visit_loop(nir_loop *loop, struct divergence_state *state) /* setup loop state */ struct divergence_state loop_state = *state; loop_state.loop = loop; - loop_state.loop_all_invariant = loop_header->predecessors.entries == 1; + loop_state.loop_all_invariant = nir_block_num_preds(loop_header) == 1; loop_state.divergent_cf = false; loop_state.divergent_loop_continue = false; loop_state.divergent_loop_break = false; diff --git a/src/compiler/nir/nir_dominance.c b/src/compiler/nir/nir_dominance.c index dfbcca08ca4..800e04aa29c 100644 --- a/src/compiler/nir/nir_dominance.c +++ b/src/compiler/nir/nir_dominance.c @@ -73,9 +73,7 @@ static bool calc_dominance(nir_block *block) { nir_block *new_idom = NULL; - set_foreach(&block->predecessors, entry) { - nir_block *pred = (nir_block *)entry->key; - + nir_foreach_pred(pred, block) { if (pred->imm_dom) { if (new_idom) new_idom = intersect(pred, new_idom); @@ -95,10 +93,8 @@ calc_dominance(nir_block *block) static bool calc_dom_frontier(nir_block *block) { - if (block->predecessors.entries > 1) { - set_foreach(&block->predecessors, entry) { - nir_block *runner = (nir_block *)entry->key; - + if (nir_block_num_preds(block) > 1) { + nir_foreach_pred(runner, block) { /* Skip unreachable predecessors */ if (runner->imm_dom == NULL) continue; diff --git a/src/compiler/nir/nir_from_ssa.c b/src/compiler/nir/nir_from_ssa.c index 2a5fb798c43..6618dbaa237 100644 --- a/src/compiler/nir/nir_from_ssa.c +++ b/src/compiler/nir/nir_from_ssa.c @@ -1006,8 +1006,7 @@ place_phi_read(nir_builder *b, nir_def *reg, if (_mesa_set_search(visited_blocks, block) == NULL) { /* Try to go up the single-successor tree */ bool all_single_successors = true; - set_foreach(&block->predecessors, entry) { - nir_block *pred = (nir_block *)entry->key; + nir_foreach_pred(pred, block) { if (pred->successors[0] && pred->successors[1]) { all_single_successors = false; break; @@ -1022,9 +1021,8 @@ place_phi_read(nir_builder *b, nir_def *reg, */ _mesa_set_add(visited_blocks, block); - set_foreach(&block->predecessors, entry) { - place_phi_read(b, reg, def, (nir_block *)entry->key, visited_blocks); - } + nir_foreach_pred(pred, block) + place_phi_read(b, reg, def, pred, visited_blocks); return; } } diff --git a/src/compiler/nir/nir_gs_count_vertices.c b/src/compiler/nir/nir_gs_count_vertices.c index f014d02f2db..5b42cfbd735 100644 --- a/src/compiler/nir/nir_gs_count_vertices.c +++ b/src/compiler/nir/nir_gs_count_vertices.c @@ -70,9 +70,7 @@ nir_gs_count_vertices_and_primitives(const nir_shader *shader, /* set_vertex_and_primitive_count intrinsics only appear in predecessors of the * end block. So we don't need to walk all of them. */ - set_foreach(&impl->end_block->predecessors, entry) { - nir_block *block = (nir_block *)entry->key; - + nir_foreach_pred(block, impl->end_block) { nir_foreach_instr_reverse(instr, block) { nir_intrinsic_instr *intrin = as_set_vertex_and_primitive_count(instr); if (!intrin) diff --git a/src/compiler/nir/nir_liveness.c b/src/compiler/nir/nir_liveness.c index 92cb0c2c943..0132fd5e5de 100644 --- a/src/compiler/nir/nir_liveness.c +++ b/src/compiler/nir/nir_liveness.c @@ -171,8 +171,7 @@ nir_live_defs_impl(nir_function_impl *impl) * changed, add the predecessor to the work list so that we ensure * that the new information is used. */ - set_foreach(&block->predecessors, entry) { - nir_block *pred = (nir_block *)entry->key; + nir_foreach_pred(pred, block) { if (propagate_across_edge(pred, block, &state)) nir_block_worklist_push_tail(&state.worklist, pred); } diff --git a/src/compiler/nir/nir_lower_clip.c b/src/compiler/nir/nir_lower_clip.c index 41e8993d3e8..f4632291e29 100644 --- a/src/compiler/nir/nir_lower_clip.c +++ b/src/compiler/nir/nir_lower_clip.c @@ -409,7 +409,7 @@ nir_lower_clip_vs(nir_shader *shader, unsigned ucp_enables, bool use_vars, * if there is a good way to sanity check this, but for now the * users of this pass don't support sub-routines. */ - assert(impl->end_block->predecessors.entries == 1); + assert(nir_block_num_preds(impl->end_block) == 1); b.cursor = nir_after_impl(impl); struct lower_clip_state state = { NULL }; diff --git a/src/compiler/nir/nir_lower_continue_constructs.c b/src/compiler/nir/nir_lower_continue_constructs.c index 1579cc563d3..58b1c6586ed 100644 --- a/src/compiler/nir/nir_lower_continue_constructs.c +++ b/src/compiler/nir/nir_lower_continue_constructs.c @@ -208,7 +208,7 @@ simplify_loop(nir_loop *loop) nir_instr_remove(nir_block_last_instr(last)); /* If the loop has only the trivial continue, there is nothing to do. */ - if (!nir_block_ends_in_jump(last) && cont->predecessors.entries == 1) + if (!nir_block_ends_in_jump(last) && nir_block_num_preds(cont) == 1) return; struct loop_simplify_state state; @@ -240,7 +240,7 @@ lower_loop_continue_block(nir_builder *b, nir_loop *loop) nir_cf_list extracted; nir_cf_list_extract(&extracted, &loop->continue_list); - if (nir_loop_first_continue_block(loop)->predecessors.entries == 0) { + if (nir_block_num_preds(nir_loop_first_continue_block(loop)) == 0) { /* This loop doesn't continue at all. Delete the continue construct. */ nir_cf_delete(&extracted); } else { diff --git a/src/compiler/nir/nir_lower_discard_if.c b/src/compiler/nir/nir_lower_discard_if.c index 2bac9fa448f..b8aa39e1a34 100644 --- a/src/compiler/nir/nir_lower_discard_if.c +++ b/src/compiler/nir/nir_lower_discard_if.c @@ -22,7 +22,6 @@ */ #include "compiler/nir/nir_builder.h" -#include "util/set.h" #include "nir.h" /** @@ -70,8 +69,8 @@ move_out_of_loop(nir_builder *b, nir_intrinsic_instr *instr) b->cursor = nir_before_cf_node(node); nir_def *false_val = nir_imm_false(b); nir_block *after_loop = nir_cf_node_cf_tree_next(node); - set_foreach(&after_loop->predecessors, entry) { - nir_phi_instr_add_src(phi_instr, (nir_block *)entry->key, false_val); + nir_foreach_pred(pred, after_loop) { + nir_phi_instr_add_src(phi_instr, pred, false_val); } /* Break if terminate. */ diff --git a/src/compiler/nir/nir_lower_gs_intrinsics.c b/src/compiler/nir/nir_lower_gs_intrinsics.c index c74cad7e609..16df4909921 100644 --- a/src/compiler/nir/nir_lower_gs_intrinsics.c +++ b/src/compiler/nir/nir_lower_gs_intrinsics.c @@ -268,8 +268,7 @@ append_set_vertex_and_primitive_count(nir_block *end_block, struct state *state) /* Insert the new intrinsic in all of the predecessors of the end block, * but before any jump instructions (return). */ - set_foreach(&end_block->predecessors, entry) { - nir_block *pred = (nir_block *)entry->key; + nir_foreach_pred(pred, end_block) { b->cursor = nir_after_block_before_jump(pred); for (unsigned stream = 0; stream < NIR_MAX_XFB_STREAMS; ++stream) { @@ -319,9 +318,7 @@ append_set_vertex_and_primitive_count(nir_block *end_block, struct state *state) static bool a_block_needs_set_vertex_and_primitive_count(nir_block *end_block, bool per_stream) { - set_foreach(&end_block->predecessors, entry) { - nir_block *pred = (nir_block *)entry->key; - + nir_foreach_pred(pred, end_block) { for (unsigned stream = 0; stream < NIR_MAX_XFB_STREAMS; ++stream) { /* When it's not per-stream, we only need to write one variable. */ if (!per_stream && stream != 0) diff --git a/src/compiler/nir/nir_lower_io_vars_to_temporaries.c b/src/compiler/nir/nir_lower_io_vars_to_temporaries.c index 5423deb79a4..b842268e3f3 100644 --- a/src/compiler/nir/nir_lower_io_vars_to_temporaries.c +++ b/src/compiler/nir/nir_lower_io_vars_to_temporaries.c @@ -137,8 +137,7 @@ emit_output_copies_impl(struct lower_io_state *state, nir_function_impl *impl) /* For all other shader types, we need to do the copies right before * the jumps to the end block. */ - set_foreach(&impl->end_block->predecessors, block_entry) { - struct nir_block *block = (void *)block_entry->key; + nir_foreach_pred(block, impl->end_block) { b.cursor = nir_after_block_before_jump(block); emit_copies(&b, &state->new_outputs, &state->old_outputs, 0); } diff --git a/src/compiler/nir/nir_lower_returns.c b/src/compiler/nir/nir_lower_returns.c index afa9f5c04dc..012dd6bea79 100644 --- a/src/compiler/nir/nir_lower_returns.c +++ b/src/compiler/nir/nir_lower_returns.c @@ -163,7 +163,7 @@ lower_returns_in_if(nir_if *if_stmt, struct lower_returns_state *state) static bool lower_returns_in_block(nir_block *block, struct lower_returns_state *state) { - if (block->predecessors.entries == 0 && + if (nir_block_num_preds(block) == 0 && block != nir_start_block(state->builder.impl)) { /* This block is unreachable. Delete it and everything after it. */ nir_cf_list list; diff --git a/src/compiler/nir/nir_opt_dce.c b/src/compiler/nir/nir_opt_dce.c index 9efd40337ee..040f0bcd6bf 100644 --- a/src/compiler/nir/nir_opt_dce.c +++ b/src/compiler/nir/nir_opt_dce.c @@ -181,9 +181,8 @@ dce_cf_list(struct exec_list *cf_list, BITSET_WORD *defs_live, /* Fast path if the loop has no continues: we can remove instructions * as we mark the others live. */ - struct set *predecessors = &nir_loop_first_block(loop)->predecessors; - if (predecessors->entries == 1 && - _mesa_set_next_entry(predecessors, NULL)->key == inner_state.preheader) { + nir_block *header = nir_loop_first_block(loop); + if (nir_block_num_preds(header) == 1 && nir_block_has_pred(header, inner_state.preheader)) { progress |= dce_cf_list(&loop->body, defs_live, parent_loop, dead_instrs); break; } diff --git a/src/compiler/nir/nir_opt_dead_cf.c b/src/compiler/nir/nir_opt_dead_cf.c index f95a5af86bc..284becaec0a 100644 --- a/src/compiler/nir/nir_opt_dead_cf.c +++ b/src/compiler/nir/nir_opt_dead_cf.c @@ -369,7 +369,7 @@ dead_cf_list(struct exec_list *list, bool *list_ends_in_jump) progress |= dead_cf_list(&loop->body, &dummy); nir_block *next = nir_cf_node_as_block(nir_cf_node_next(cur)); - if (next->predecessors.entries == 0 && + if (nir_block_num_preds(next) == 0 && (!exec_list_is_empty(&next->instr_list) || !exec_node_is_tail_sentinel(next->cf_node.node.next))) { nir_remove_after_cf_node(cur); diff --git a/src/compiler/nir/nir_opt_if.c b/src/compiler/nir/nir_opt_if.c index bab4fb9cfba..011c4af7af5 100644 --- a/src/compiler/nir/nir_opt_if.c +++ b/src/compiler/nir/nir_opt_if.c @@ -42,11 +42,11 @@ find_continue_block(nir_loop *loop) nir_block *prev_block = nir_cf_node_as_block(nir_cf_node_prev(&loop->cf_node)); - assert(header_block->predecessors.entries == 2); + assert(nir_block_num_preds(header_block) == 2); - set_foreach(&header_block->predecessors, pred_entry) { - if (pred_entry->key != prev_block) - return (nir_block *)pred_entry->key; + nir_foreach_pred(pred, header_block) { + if (pred != prev_block) + return pred; } UNREACHABLE("Continue block not found!"); @@ -143,13 +143,13 @@ opt_peel_loop_initial_if(nir_loop *loop) nir_cf_node_as_block(nir_cf_node_prev(&loop->cf_node)); /* It would be insane if this were not true */ - assert(_mesa_set_search(&header_block->predecessors, prev_block)); + assert(nir_block_has_pred(header_block, prev_block)); /* The loop must have exactly one continue block which could be a block * ending in a continue instruction or the "natural" continue from the * last block in the loop back to the top. */ - if (header_block->predecessors.entries != 2) + if (nir_block_num_preds(header_block) != 2) return false; nir_cf_node *if_node = nir_cf_node_next(&header_block->cf_node); @@ -375,13 +375,13 @@ opt_split_alu_of_phi(nir_builder *b, nir_loop *loop, nir_opt_if_options options) nir_cf_node_as_block(nir_cf_node_prev(&loop->cf_node)); /* It would be insane if this were not true */ - assert(_mesa_set_search(&header_block->predecessors, prev_block)); + assert(nir_block_has_pred(header_block, prev_block)); /* The loop must have exactly one continue block which could be a block * ending in a continue instruction or the "natural" continue from the * last block in the loop back to the top. */ - if (header_block->predecessors.entries != 2) + if (nir_block_num_preds(header_block) != 2) return false; nir_block *continue_block = find_continue_block(loop); @@ -611,13 +611,13 @@ opt_simplify_bcsel_of_phi(nir_builder *b, nir_loop *loop) nir_cf_node_as_block(nir_cf_node_prev(&loop->cf_node)); /* It would be insane if this were not true */ - assert(_mesa_set_search(&header_block->predecessors, prev_block)); + assert(nir_block_has_pred(header_block, prev_block)); /* The loop must have exactly one continue block which could be a block * ending in a continue instruction or the "natural" continue from the * last block in the loop back to the top. */ - if (header_block->predecessors.entries != 2) + if (nir_block_num_preds(header_block) != 2) return false; /* We can move any bcsel that can guaranteed to execut on every iteration diff --git a/src/compiler/nir/nir_opt_licm.c b/src/compiler/nir/nir_opt_licm.c index a9d8652c5d8..72b63979b85 100644 --- a/src/compiler/nir/nir_opt_licm.c +++ b/src/compiler/nir/nir_opt_licm.c @@ -58,7 +58,7 @@ static bool should_optimize_loop(nir_loop *loop) { /* Ignore loops without back-edge */ - if (nir_loop_first_block(loop)->predecessors.entries == 1) + if (nir_block_num_preds(nir_loop_first_block(loop)) == 1) return false; nir_foreach_block_in_cf_node(block, &loop->cf_node) { diff --git a/src/compiler/nir/nir_opt_load_store_vectorize.c b/src/compiler/nir/nir_opt_load_store_vectorize.c index 1d9357d99b6..ad250c03478 100644 --- a/src/compiler/nir/nir_opt_load_store_vectorize.c +++ b/src/compiler/nir/nir_opt_load_store_vectorize.c @@ -1865,15 +1865,13 @@ add_entries_from_predecessor(struct vectorize_ctx *ctx, nir_block *block) /* If this isn't reorderable, we would have to consider the loop back-edges to safely use * it, in case there is an interfering store in the loop. */ - bool has_continue = block->predecessors.entries > 1 || - _mesa_set_next_entry(&block->predecessors, NULL)->key != preheader; + bool has_continue = nir_block_num_preds(block) > 1 || !nir_block_has_pred(block, preheader); if (entry && !(entry->access & ACCESS_CAN_REORDER) && has_continue) entry = NULL; } else { /* If all predecessor entries are the same, the entry dominates the block. */ bool first_entry = true; - set_foreach(&block->predecessors, set_entry) { - nir_block *pred = (nir_block *)set_entry->key; + nir_foreach_pred(pred, block) { if (!first_entry && entry != ctx->per_block_ctx[pred->index].last_entry[i]) { entry = NULL; break; diff --git a/src/compiler/nir/nir_opt_loop.c b/src/compiler/nir/nir_opt_loop.c index 10e515db00e..b5465354f19 100644 --- a/src/compiler/nir/nir_opt_loop.c +++ b/src/compiler/nir/nir_opt_loop.c @@ -72,7 +72,7 @@ opt_loop_merge_break_continue(nir_if *nif) nir_block *after_if = nir_cf_node_cf_tree_next(&nif->cf_node); /* The block after the IF must have no predecessors and be empty. */ - if (after_if->predecessors.entries > 0 || !is_block_empty(after_if)) + if (nir_block_num_preds(after_if) > 0 || !is_block_empty(after_if)) return false; nir_block *last_then = nir_if_last_then_block(nif); @@ -209,7 +209,7 @@ static bool opt_loop_last_block(nir_block *block, bool is_trivial_continue, bool is_trivial_break) { /* If this block has no predecessors, let nir_opt_dead_cf() do the cleanup */ - if (block->predecessors.entries == 0) + if (nir_block_num_preds(block) == 0) return false; bool progress = false; @@ -379,7 +379,7 @@ opt_loop_peel_initial_break(nir_loop *loop) nir_block *exit_block = nir_cf_node_cf_tree_next(&loop->cf_node); /* The loop must have exactly one continue block. */ - if (header_block->predecessors.entries != 2) + if (nir_block_num_preds(header_block) != 2) return false; nir_cf_node *if_node = nir_cf_node_next(&header_block->cf_node); diff --git a/src/compiler/nir/nir_opt_remove_phis.c b/src/compiler/nir/nir_opt_remove_phis.c index 9523b04383f..f08e8145e6f 100644 --- a/src/compiler/nir/nir_opt_remove_phis.c +++ b/src/compiler/nir/nir_opt_remove_phis.c @@ -189,7 +189,7 @@ nir_opt_remove_phis(nir_shader *shader) bool nir_remove_single_src_phis_block(nir_block *block) { - assert(block->predecessors.entries <= 1); + assert(nir_block_num_preds(block) <= 1); bool progress = false; nir_foreach_phi_safe(phi, block) { nir_def *def = NULL; diff --git a/src/compiler/nir/nir_opt_sink.c b/src/compiler/nir/nir_opt_sink.c index 2c66ff8e811..541628e1369 100644 --- a/src/compiler/nir/nir_opt_sink.c +++ b/src/compiler/nir/nir_opt_sink.c @@ -301,7 +301,7 @@ get_innermost_loop(nir_cf_node *node) for (; node != NULL; node = node->parent) { if (node->type == nir_cf_node_loop) { nir_loop *loop = nir_cf_node_as_loop(node); - if (nir_loop_first_block(loop)->predecessors.entries > 1) + if (nir_block_num_preds(nir_loop_first_block(loop)) > 1) return loop; } } @@ -342,7 +342,7 @@ adjust_block_for_loops(nir_block *use_block, nir_block *def_block, nir_cf_node *next = nir_cf_node_next(&cur_block->cf_node); if (next && next->type == nir_cf_node_loop && - nir_block_cf_tree_next(cur_block)->predecessors.entries > 1) { + nir_block_num_preds(nir_block_cf_tree_next(cur_block)) > 1) { nir_loop *following_loop = nir_cf_node_as_loop(next); if (loop_contains_block(following_loop, use_block)) { use_block = cur_block; diff --git a/src/compiler/nir/nir_phi_builder.c b/src/compiler/nir/nir_phi_builder.c index 78327c0aa6e..c38f3706c94 100644 --- a/src/compiler/nir/nir_phi_builder.c +++ b/src/compiler/nir/nir_phi_builder.c @@ -291,7 +291,7 @@ nir_phi_builder_finish(struct nir_phi_builder *pb) /* XXX: Constructing the array this many times seems expensive. */ nir_block **preds = nir_block_get_predecessors_sorted(phi->instr.block, pb); - for (unsigned i = 0; i < phi->instr.block->predecessors.entries; i++) { + for (unsigned i = 0; i < nir_block_num_preds(phi->instr.block); i++) { nir_phi_instr_add_src(phi, preds[i], nir_phi_builder_value_get_block_def(val, preds[i])); } diff --git a/src/compiler/nir/nir_print.c b/src/compiler/nir/nir_print.c index 964c77d96bf..b1227cfa028 100644 --- a/src/compiler/nir/nir_print.c +++ b/src/compiler/nir/nir_print.c @@ -2286,7 +2286,7 @@ print_phi_instr(nir_phi_instr *instr, print_state *state) nir_block **preds = state->preds ? state->preds : nir_block_get_predecessors_sorted(instr->instr.block, NULL); - for (unsigned i = 0; i < instr->instr.block->predecessors.entries; i++) { + for (unsigned i = 0; i < nir_block_num_preds(instr->instr.block); i++) { nir_phi_src *src = nir_phi_get_src_from_block(instr, preds[i]); if (i != 0) fprintf(fp, ", "); @@ -2425,7 +2425,7 @@ static void print_block_preds(nir_block *block, print_state *state) { FILE *fp = state->fp; - for (unsigned i = 0; i < block->predecessors.entries; i++) { + for (unsigned i = 0; i < nir_block_num_preds(block); i++) { fprintf(fp, " b%u", state->preds[i]->index); } } diff --git a/src/compiler/nir/nir_to_lcssa.c b/src/compiler/nir/nir_to_lcssa.c index 73d1be9cfd1..d40f6d8ba7b 100644 --- a/src/compiler/nir/nir_to_lcssa.c +++ b/src/compiler/nir/nir_to_lcssa.c @@ -239,7 +239,7 @@ convert_loop_exit_for_ssa(nir_def *def, void *void_state) /* Create a phi node with as many sources pointing to the same ssa_def as * the block has predecessors. */ - uint32_t num_exits = state->block_after_loop->predecessors.entries; + uint32_t num_exits = nir_block_num_preds(state->block_after_loop); for (uint32_t i = 0; i < num_exits; i++) { nir_phi_instr_add_src(phi, state->exit_blocks[i], def); } @@ -342,7 +342,7 @@ convert_to_lcssa(nir_cf_node *cf_node, lcssa_state *state) * The variance then depends on all (nested) break conditions. * We don't consider this, but assume all not_invariant. */ - if (nir_loop_first_block(loop)->predecessors.entries == 1) + if (nir_block_num_preds(nir_loop_first_block(loop)) == 1) goto end; nir_foreach_block_in_cf_node(block, cf_node) { diff --git a/src/compiler/nir/nir_validate.c b/src/compiler/nir/nir_validate.c index ca3d3791cdb..a83145e0c6f 100644 --- a/src/compiler/nir/nir_validate.c +++ b/src/compiler/nir/nir_validate.c @@ -1227,7 +1227,7 @@ validate_phi_instr(nir_phi_instr *instr, validate_state *state) exec_list_validate(&instr->srcs); validate_assert(state, exec_list_length(&instr->srcs) == - state->block->predecessors.entries); + nir_block_num_preds(state->block)); } static void @@ -1473,17 +1473,16 @@ validate_block_predecessors(nir_block *block, validate_state *state) /* And we have to be in our successor's predecessors set */ validate_assert(state, - _mesa_set_search(&block->successors[i]->predecessors, block)); + nir_block_has_pred(block->successors[i], block)); validate_phi_srcs(block, block->successors[i], state); } /* The start block cannot have any predecessors */ if (block == nir_start_block(state->impl)) - validate_assert(state, block->predecessors.entries == 0); + validate_assert(state, nir_block_num_preds(block) == 0); - set_foreach(&block->predecessors, entry) { - const nir_block *pred = entry->key; + nir_foreach_pred(pred, block) { validate_assert(state, _mesa_set_search(state->blocks, pred)); validate_assert(state, pred->successors[0] == block || pred->successors[1] == block); @@ -1631,7 +1630,7 @@ validate_loop(nir_loop *loop, validate_state *state) validate_assert(state, next_node->type == nir_cf_node_block); validate_assert(state, !exec_list_is_empty(&loop->body)); - validate_assert(state, nir_loop_first_block(loop)->predecessors.entries <= 2); + validate_assert(state, nir_block_num_preds(nir_loop_first_block(loop)) <= 2); nir_cf_node *old_parent = state->parent_node; state->parent_node = &loop->cf_node; diff --git a/src/compiler/nir/tests/control_flow_tests.cpp b/src/compiler/nir/tests/control_flow_tests.cpp index 84e7e8f6249..cd8b5a30aec 100644 --- a/src/compiler/nir/tests/control_flow_tests.cpp +++ b/src/compiler/nir/tests/control_flow_tests.cpp @@ -81,13 +81,13 @@ TEST_F(nir_cf_test, delete_break_in_loop) EXPECT_EQ(NULL, block_2->successors[1]); EXPECT_EQ(NULL, block_3->successors[0]); EXPECT_EQ(NULL, block_3->successors[1]); - EXPECT_EQ(0, block_0->predecessors.entries); - EXPECT_EQ(1, block_1->predecessors.entries); - EXPECT_EQ(1, block_2->predecessors.entries); - EXPECT_EQ(1, block_3->predecessors.entries); - EXPECT_TRUE(_mesa_set_search(&block_1->predecessors, block_0)); - EXPECT_TRUE(_mesa_set_search(&block_2->predecessors, block_1)); - EXPECT_TRUE(_mesa_set_search(&block_3->predecessors, block_2)); + EXPECT_EQ(0, nir_block_num_preds(block_0)); + EXPECT_EQ(1, nir_block_num_preds(block_1)); + EXPECT_EQ(1, nir_block_num_preds(block_2)); + EXPECT_EQ(1, nir_block_num_preds(block_3)); + EXPECT_TRUE(nir_block_has_pred(block_1, block_0)); + EXPECT_TRUE(nir_block_has_pred(block_2, block_1)); + EXPECT_TRUE(nir_block_has_pred(block_3, block_2)); /* Now remove the break. */ nir_instr_remove(&jump->instr); @@ -119,14 +119,14 @@ TEST_F(nir_cf_test, delete_break_in_loop) EXPECT_EQ(NULL, block_2->successors[1]); EXPECT_EQ(NULL, block_3->successors[0]); EXPECT_EQ(NULL, block_3->successors[1]); - EXPECT_EQ(0, block_0->predecessors.entries); - EXPECT_EQ(2, block_1->predecessors.entries); - EXPECT_EQ(0, block_2->predecessors.entries); - EXPECT_EQ(1, block_3->predecessors.entries); - EXPECT_TRUE(_mesa_set_search(&block_1->predecessors, block_0)); - EXPECT_TRUE(_mesa_set_search(&block_1->predecessors, block_1)); - EXPECT_FALSE(_mesa_set_search(&block_2->predecessors, block_1)); - EXPECT_TRUE(_mesa_set_search(&block_3->predecessors, block_2)); + EXPECT_EQ(0, nir_block_num_preds(block_0)); + EXPECT_EQ(2, nir_block_num_preds(block_1)); + EXPECT_EQ(0, nir_block_num_preds(block_2)); + EXPECT_EQ(1, nir_block_num_preds(block_3)); + EXPECT_TRUE(nir_block_has_pred(block_1, block_0)); + EXPECT_TRUE(nir_block_has_pred(block_1, block_1)); + EXPECT_FALSE(nir_block_has_pred(block_2, block_1)); + EXPECT_TRUE(nir_block_has_pred(block_3, block_2)); nir_metadata_require(b->impl, nir_metadata_dominance); } diff --git a/src/freedreno/ir3/ir3_compiler_nir.c b/src/freedreno/ir3/ir3_compiler_nir.c index 6915cc18570..1d840f375e3 100644 --- a/src/freedreno/ir3/ir3_compiler_nir.c +++ b/src/freedreno/ir3/ir3_compiler_nir.c @@ -4842,14 +4842,13 @@ has_nontrivial_continue(nir_loop *nloop) * is more than one backedge from inside the loop (so more than 2 total * edges) then one must be a nontrivial continue. */ - if (nstart->predecessors.entries > 2) + if (nir_block_num_preds(nstart) > 2) return true; /* Check whether the one backedge is a nontrivial continue. This can happen * if the loop ends with a break. */ - set_foreach (&nstart->predecessors, entry) { - nir_block *pred = (nir_block*)entry->key; + nir_foreach_pred (pred, nstart) { if (pred == nir_loop_last_block(nloop) || pred == nir_cf_node_as_block(nir_cf_node_prev(&nloop->cf_node))) continue; diff --git a/src/freedreno/ir3/ir3_nir_lower_tess.c b/src/freedreno/ir3/ir3_nir_lower_tess.c index 3de73558227..6fc2f3a92f1 100644 --- a/src/freedreno/ir3/ir3_nir_lower_tess.c +++ b/src/freedreno/ir3/ir3_nir_lower_tess.c @@ -1057,7 +1057,7 @@ ir3_nir_lower_gs(nir_shader *shader) * them to this new if statement, rather than emitting this code at every * return statement. */ - assert(impl->end_block->predecessors.entries == 1); + assert(nir_block_num_preds(impl->end_block) == 1); nir_block *block = nir_impl_last_block(impl); b.cursor = nir_after_block_before_jump(block); diff --git a/src/gallium/auxiliary/nir/nir_to_tgsi.c b/src/gallium/auxiliary/nir/nir_to_tgsi.c index 0be911c8268..39a5ddcc574 100644 --- a/src/gallium/auxiliary/nir/nir_to_tgsi.c +++ b/src/gallium/auxiliary/nir/nir_to_tgsi.c @@ -448,10 +448,8 @@ ntt_live_regs(struct ntt_compile *c, nir_function_impl *impl) ~bs->livein[i]); if (new_livein) { bs->livein[i] |= new_livein; - set_foreach(&block->predecessors, entry) { - nir_block *pred = (void *)entry->key; + nir_foreach_pred(pred, block) nir_block_worklist_push_tail(&state.worklist, pred); - } if (new_livein & state.blocks[block->index].defin[i]) c->liveness[i].start = MIN2(c->liveness[i].start, ntt_block->start_ip); diff --git a/src/gallium/drivers/etnaviv/etnaviv_compiler_nir_liveness.c b/src/gallium/drivers/etnaviv/etnaviv_compiler_nir_liveness.c index 7b3cebfe939..012829f7c62 100644 --- a/src/gallium/drivers/etnaviv/etnaviv_compiler_nir_liveness.c +++ b/src/gallium/drivers/etnaviv/etnaviv_compiler_nir_liveness.c @@ -223,8 +223,7 @@ etna_live_defs(nir_function_impl *impl, struct live_def *defs, unsigned *live_ma * changed, add the predecessor to the work list so that we ensure * that the new information is used. */ - set_foreach(&block->predecessors, entry) { - nir_block *pred = (nir_block *)entry->key; + nir_foreach_pred(pred, block) { if (propagate_across_edge(pred, block, &state)) nir_block_worklist_push_tail(&state.worklist, pred); } diff --git a/src/gallium/drivers/nouveau/codegen/nv50_ir_from_nir.cpp b/src/gallium/drivers/nouveau/codegen/nv50_ir_from_nir.cpp index e79eadd488f..454ec6d6708 100644 --- a/src/gallium/drivers/nouveau/codegen/nv50_ir_from_nir.cpp +++ b/src/gallium/drivers/nouveau/codegen/nv50_ir_from_nir.cpp @@ -1578,7 +1578,7 @@ Converter::visit(nir_cf_node *node) bool Converter::visit(nir_block *block) { - if (!block->predecessors.entries && exec_list_is_empty(&block->instr_list)) + if (!nir_block_num_preds(block) && exec_list_is_empty(&block->instr_list)) return true; BasicBlock *bb = convert(block); diff --git a/src/gallium/drivers/zink/zink_compiler.c b/src/gallium/drivers/zink/zink_compiler.c index f74ec0af153..0b597e84ff2 100644 --- a/src/gallium/drivers/zink/zink_compiler.c +++ b/src/gallium/drivers/zink/zink_compiler.c @@ -2568,7 +2568,7 @@ clamp_layer_output(nir_shader *vs, nir_shader *fs, unsigned *next_location) nir_builder b; nir_function_impl *impl = nir_shader_get_entrypoint(vs); b = nir_builder_at(nir_after_impl(impl)); - assert(impl->end_block->predecessors.entries == 1); + assert(nir_block_num_preds(impl->end_block) == 1); clamp_layer_output_emit(&b, var); nir_progress(true, impl, nir_metadata_control_flow); } diff --git a/src/intel/compiler/brw/brw_nir_lower_intersection_shader.c b/src/intel/compiler/brw/brw_nir_lower_intersection_shader.c index b3d699b6756..f580fbebf5f 100644 --- a/src/intel/compiler/brw/brw_nir_lower_intersection_shader.c +++ b/src/intel/compiler/brw/brw_nir_lower_intersection_shader.c @@ -153,9 +153,8 @@ brw_nir_lower_intersection_shader(nir_shader *intersection, nir_local_variable_create(impl, glsl_bool_type(), "ray_commit"); nir_store_var(b, commit, nir_imm_false(b), 0x1); - assert(impl->end_block->predecessors.entries == 1); - set_foreach(&impl->end_block->predecessors, block_entry) { - struct nir_block *block = (void *)block_entry->key; + assert(nir_block_num_preds(impl->end_block) == 1); + nir_foreach_pred(block, impl->end_block) { b->cursor = nir_after_block_before_jump(block); nir_push_if(b, nir_load_var(b, commit)); { diff --git a/src/intel/compiler/brw/brw_nir_lower_shader_calls.c b/src/intel/compiler/brw/brw_nir_lower_shader_calls.c index 49152ff52bf..7be8e347b82 100644 --- a/src/intel/compiler/brw/brw_nir_lower_shader_calls.c +++ b/src/intel/compiler/brw/brw_nir_lower_shader_calls.c @@ -53,8 +53,7 @@ brw_nir_lower_shader_returns(nir_shader *shader) nir_builder b = nir_builder_create(impl); - set_foreach(&impl->end_block->predecessors, block_entry) { - struct nir_block *block = (void *)block_entry->key; + nir_foreach_pred(block, impl->end_block) { b.cursor = nir_after_block_before_jump(block); switch (shader->info.stage) { @@ -63,7 +62,7 @@ brw_nir_lower_shader_returns(nir_shader *shader) * it ends, we retire the bindless stack ID and no further shaders * will be executed. */ - assert(impl->end_block->predecessors.entries == 1); + assert(nir_block_num_preds(impl->end_block) == 1); brw_nir_btd_retire(&b); break; @@ -86,7 +85,7 @@ brw_nir_lower_shader_returns(nir_shader *shader) * action at the end. They simply return back to the previous shader * in the call stack. */ - assert(impl->end_block->predecessors.entries == 1); + assert(nir_block_num_preds(impl->end_block) == 1); brw_nir_btd_return(&b); break; diff --git a/src/intel/compiler/intel_nir_tcs_workarounds.c b/src/intel/compiler/intel_nir_tcs_workarounds.c index 56dd4161257..cf9adc51102 100644 --- a/src/intel/compiler/intel_nir_tcs_workarounds.c +++ b/src/intel/compiler/intel_nir_tcs_workarounds.c @@ -101,12 +101,12 @@ intel_nir_apply_tcs_quads_workaround(nir_shader *nir) * the end block. We want to process the original set, so to be safe, * save it off to an array first. */ - const unsigned num_end_preds = impl->end_block->predecessors.entries; + const unsigned num_end_preds = nir_block_num_preds(impl->end_block); nir_block *end_preds[num_end_preds]; unsigned i = 0; - set_foreach(&impl->end_block->predecessors, entry) { - end_preds[i++] = (nir_block *) entry->key; + nir_foreach_pred(pred, impl->end_block) { + end_preds[i++] = pred; } for (i = 0; i < num_end_preds; i++) { diff --git a/src/nouveau/compiler/nak_nir_lower_cf.c b/src/nouveau/compiler/nak_nir_lower_cf.c index ec29e715c3b..01276c4a4db 100644 --- a/src/nouveau/compiler/nak_nir_lower_cf.c +++ b/src/nouveau/compiler/nak_nir_lower_cf.c @@ -238,9 +238,7 @@ block_is_merge(const nir_block *block) return false; unsigned num_preds = 0; - set_foreach(&block->predecessors, entry) { - const nir_block *pred = entry->key; - + nir_foreach_pred(pred, block) { /* We don't care about unreachable blocks */ if (pred->imm_dom == NULL) continue; diff --git a/src/nouveau/compiler/nak_nir_lower_gs_intrinsics.c b/src/nouveau/compiler/nak_nir_lower_gs_intrinsics.c index 7f43a1dac1b..2a9ad9123de 100644 --- a/src/nouveau/compiler/nak_nir_lower_gs_intrinsics.c +++ b/src/nouveau/compiler/nak_nir_lower_gs_intrinsics.c @@ -69,8 +69,7 @@ append_final_primitive_nv(nir_block *end_block, struct state *state) { nir_builder *b = state->builder; - set_foreach(&end_block->predecessors, entry) { - nir_block *pred = (nir_block *)entry->key; + nir_foreach_pred(pred, end_block) { b->cursor = nir_after_block_before_jump(pred); nir_def *gs_handle = nir_load_var(b, state->handle_var); @@ -122,4 +121,4 @@ nak_nir_lower_gs_intrinsics(nir_shader *nir) nir_progress(true, impl, nir_metadata_none); return state.progress; -} \ No newline at end of file +}