fdo-mirrors/mesa
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/mesa/mesa.git synced 2026-05-05 05:18:08 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

nir: make nir_block::predecessors & dom_frontier sets non-malloc'd

Browse source 
We can just place the set structures inside nir_block.

This reduces the number of ralloc calls by 6.7% when compiling Heaven
shaders with radeonsi+ACO using a release build (i.e. not including
nir_validate set allocations, which are also removed).

Reviewed-by: Gert Wollny <gert.wollny@collabora.com>
Acked-by: Pierre-Eric Pelloux-Prayer <pierre-eric.pelloux-prayer@amd.com>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/36728>
This commit is contained in:
Marek Olšák 2025-08-09 16:52:18 -04:00 • committed by Marge Bot
parent 81cb571642
commit 3aadae22ad
41 changed files with 109 additions and 116 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
src/amd/compiler/instruction_selection/aco_isel_setup.cpp
View file

@ -129,7 +129,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_cf_node_cf_tree_next(&loop->cf_node)->predecessors.entries == 0) {
nir_builder b = nir_builder_create(impl);
b.cursor = nir_after_block_before_jump(nir_loop_last_block(loop));

2
src/amd/compiler/instruction_selection/aco_select_nir.cpp
View file

@ -858,7 +858,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_loop_first_block(loop)->predecessors.entries > 1;
ctx->cf_info.in_divergent_cf |= ctx->cf_info.parent_loop.has_divergent_break;
visit_cf_list(ctx, &loop->body);

24
src/compiler/nir/nir.c
View file

@ -703,7 +703,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);
_mesa_set_add(&end_block->predecessors, start_block);
return impl;
}
@ -725,17 +725,9 @@ nir_block_create(nir_shader *shader)
cf_init(&block->cf_node, nir_cf_node_block);
block->successors[0] = block->successors[1] = NULL;
block->predecessors = _mesa_pointer_set_create(block);
_mesa_pointer_set_init(&block->predecessors, block);
block->imm_dom = NULL;
/* XXX maybe it would be worth it to defer allocation? This
* way it doesn't get allocated for shader refs that never run
* nir_calc_dominance? For example, state-tracker creates an
* initial IR, clones that, runs appropriate lowering pass, passes
* to driver which does common lowering/opt, and then stores ref
* which is later used to do state specific lowering and futher
* opt. Do any of the references not need dominance metadata?
*/
block->dom_frontier = _mesa_pointer_set_create(block);
_mesa_pointer_set_init(&block->dom_frontier, block);
exec_list_make_empty(&block->instr_list);
@ -787,7 +779,7 @@ nir_loop_create(nir_shader *shader)
body->cf_node.parent = &loop->cf_node;
body->successors[0] = body;
_mesa_set_add(body->predecessors, body);
_mesa_set_add(&body->predecessors, body);
exec_list_make_empty(&loop->continue_list);
@ -2132,14 +2124,14 @@ 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);
ralloc_array(mem_ctx, nir_block *, block->predecessors.entries);
unsigned i = 0;
set_foreach(block->predecessors, entry)
set_foreach(&block->predecessors, entry)
preds[i++] = (nir_block *)entry->key;
assert(i == block->predecessors->entries);
assert(i == block->predecessors.entries);
qsort(preds, block->predecessors->entries, sizeof(nir_block *),
qsort(preds, block->predecessors.entries, sizeof(nir_block *),
compare_block_index);
return preds;

4
src/compiler/nir/nir.h
View file

@ -3077,7 +3077,7 @@ typedef struct nir_block {
nir_block *successors[2];
/* Set of nir_block predecessors in the CFG */
struct set *predecessors;
struct set predecessors;
/*
* this node's immediate dominator in the dominance tree - set to NULL for
@ -3099,7 +3099,7 @@ typedef struct nir_block {
nir_block *_dom_children_storage[3];
/* Set of nir_blocks on the dominance frontier of this block */
struct set *dom_frontier;
struct set dom_frontier;
/*
* These two indices have the property that dom_{pre,post}_index for each

12
src/compiler/nir/nir_control_flow.c
View file

@ -48,17 +48,17 @@
static inline void
block_add_pred(nir_block *block, nir_block *pred)
{
_mesa_set_add(block->predecessors, 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);
struct set_entry *entry = _mesa_set_search(&block->predecessors, pred);
assert(entry);
_mesa_set_remove(block->predecessors, entry);
_mesa_set_remove(&block->predecessors, entry);
}
static void
@ -188,7 +188,7 @@ 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) {
set_foreach(&block->predecessors, entry) {
nir_block *pred = (nir_block *)entry->key;
replace_successor(pred, block, new_block);
}
@ -438,7 +438,7 @@ 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);
set_foreach(header->predecessors, entry) {
set_foreach(&header->predecessors, entry) {
nir_block *pred = (nir_block *)entry->key;
if (pred != preheader)
replace_successor(pred, header, cont);
@ -455,7 +455,7 @@ 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);
set_foreach(cont->predecessors, entry) {
set_foreach(&cont->predecessors, entry) {
nir_block *pred = (nir_block *)entry->key;
replace_successor(pred, cont, header);
}

2
src/compiler/nir/nir_divergence_analysis.c
View file

@ -1426,7 +1426,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 = loop_header->predecessors.entries == 1;
loop_state.divergent_loop_cf = false;
loop_state.divergent_loop_continue = false;
loop_state.divergent_loop_break = false;

12
src/compiler/nir/nir_dominance.c
View file

@ -46,7 +46,7 @@ init_block(nir_block *block, nir_function_impl *impl)
block->dom_pre_index = UINT32_MAX;
block->dom_post_index = 0;
_mesa_set_clear(block->dom_frontier, NULL);
_mesa_set_clear(&block->dom_frontier, NULL);
return true;
}
@ -73,7 +73,7 @@ static bool
calc_dominance(nir_block *block)
{
nir_block *new_idom = NULL;
set_foreach(block->predecessors, entry) {
set_foreach(&block->predecessors, entry) {
nir_block *pred = (nir_block *)entry->key;
if (pred->imm_dom) {
@ -95,8 +95,8 @@ calc_dominance(nir_block *block)
static bool
calc_dom_frontier(nir_block *block)
{
if (block->predecessors->entries > 1) {
set_foreach(block->predecessors, entry) {
if (block->predecessors.entries > 1) {
set_foreach(&block->predecessors, entry) {
nir_block *runner = (nir_block *)entry->key;
/* Skip unreachable predecessors */
@ -104,7 +104,7 @@ calc_dom_frontier(nir_block *block)
continue;
while (runner != block->imm_dom) {
_mesa_set_add(runner->dom_frontier, block);
_mesa_set_add(&runner->dom_frontier, block);
runner = runner->imm_dom;
}
}
@ -309,7 +309,7 @@ nir_dump_dom_frontier_impl(nir_function_impl *impl, FILE *fp)
{
nir_foreach_block_unstructured(block, impl) {
fprintf(fp, "DF(%u) = {", block->index);
set_foreach(block->dom_frontier, entry) {
set_foreach(&block->dom_frontier, entry) {
nir_block *df = (nir_block *)entry->key;
fprintf(fp, "%u, ", df->index);
}

4
src/compiler/nir/nir_from_ssa.c
View file

@ -1102,7 +1102,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) {
set_foreach(&block->predecessors, entry) {
nir_block *pred = (nir_block *)entry->key;
if (pred->successors[0] && pred->successors[1]) {
all_single_successors = false;
@ -1118,7 +1118,7 @@ place_phi_read(nir_builder *b, nir_def *reg,
*/
_mesa_set_add(visited_blocks, block);
set_foreach(block->predecessors, entry) {
set_foreach(&block->predecessors, entry) {
place_phi_read(b, reg, def, (nir_block *)entry->key, visited_blocks);
}
return;

2
src/compiler/nir/nir_gs_count_vertices.c
View file

@ -70,7 +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) {
set_foreach(&impl->end_block->predecessors, entry) {
nir_block *block = (nir_block *)entry->key;
nir_foreach_instr_reverse(instr, block) {

2
src/compiler/nir/nir_liveness.c
View file

@ -180,7 +180,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) {
set_foreach(&block->predecessors, entry) {
nir_block *pred = (nir_block *)entry->key;
if (propagate_across_edge(pred, block, &state))
nir_block_worklist_push_tail(&state.worklist, pred);

2
src/compiler/nir/nir_lower_clip.c
View file

@ -386,7 +386,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(impl->end_block->predecessors.entries == 1);
b.cursor = nir_after_impl(impl);
struct lower_clip_state state = { NULL };

4
src/compiler/nir/nir_lower_continue_constructs.c
View file

@ -38,10 +38,10 @@ lower_loop_continue_block(nir_builder *b, nir_loop *loop, bool *repair_ssa)
/* count continue statements excluding unreachable ones */
unsigned num_continue = 0;
nir_block *single_predecessor = NULL;
set_foreach(cont->predecessors, entry) {
set_foreach(&cont->predecessors, entry) {
nir_block *pred = (nir_block *)entry->key;
/* If the continue block has no predecessors, it is unreachable. */
if (pred->predecessors->entries == 0)
if (pred->predecessors.entries == 0)
continue;
single_predecessor = pred;

2
src/compiler/nir/nir_lower_discard_if.c
View file

@ -70,7 +70,7 @@ 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) {
set_foreach(&after_loop->predecessors, entry) {
nir_phi_instr_add_src(phi_instr, (nir_block *)entry->key, false_val);
}

12
src/compiler/nir/nir_lower_goto_ifs.c
View file

@ -446,7 +446,7 @@ inside_outside(nir_block *block, struct set *loop_heads, struct set *outside,
set_foreach(remaining, child_entry) {
nir_block *dom_child = (nir_block *)child_entry->key;
bool can_jump_back = false;
set_foreach(dom_child->dom_frontier, entry) {
set_foreach(&dom_child->dom_frontier, entry) {
if (entry->key == dom_child)
continue;
if (_mesa_set_search_pre_hashed(remaining, entry->hash,
@ -587,7 +587,7 @@ handle_irreducible(struct set *remaining, struct strct_lvl *curr_level,
set_foreach(remaining, entry) {
nir_block *remaining_block = (nir_block *)entry->key;
if (!_mesa_set_search(curr_level->blocks, remaining_block) &&
_mesa_set_intersects(remaining_block->dom_frontier,
_mesa_set_intersects(&remaining_block->dom_frontier,
curr_level->blocks)) {
if (_mesa_set_search(old_candidates, remaining_block)) {
_mesa_set_add(curr_level->blocks, remaining_block);
@ -668,7 +668,7 @@ organize_levels(struct list_head *levels, struct set *remaining,
_mesa_set_clear(remaining_frontier, NULL);
set_foreach(remaining, entry) {
nir_block *remain_block = (nir_block *)entry->key;
set_foreach(remain_block->dom_frontier, frontier_entry) {
set_foreach(&remain_block->dom_frontier, frontier_entry) {
nir_block *frontier = (nir_block *)frontier_entry->key;
if (frontier != remain_block) {
_mesa_set_add(remaining_frontier, frontier);
@ -717,9 +717,9 @@ organize_levels(struct list_head *levels, struct set *remaining,
nir_block *level_block = (nir_block *)blocks_entry->key;
if (prev_frontier == NULL) {
prev_frontier =
_mesa_set_clone(level_block->dom_frontier, curr_level);
_mesa_set_clone(&level_block->dom_frontier, curr_level);
} else {
set_foreach(level_block->dom_frontier, entry)
set_foreach(&level_block->dom_frontier, entry)
_mesa_set_add_pre_hashed(prev_frontier, entry->hash,
entry->key);
}
@ -849,7 +849,7 @@ nir_structurize(struct routes *routing, nir_builder *b, nir_block *block,
}
/* If the block can reach back to itself, it is a loop head */
int is_looped = _mesa_set_search(block->dom_frontier, block) != NULL;
int is_looped = _mesa_set_search(&block->dom_frontier, block) != NULL;
struct list_head outside_levels;
if (is_looped) {
struct set *loop_heads = _mesa_pointer_set_create(mem_ctx);

4
src/compiler/nir/nir_lower_gs_intrinsics.c
View file

@ -268,7 +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) {
set_foreach(&end_block->predecessors, entry) {
nir_block *pred = (nir_block *)entry->key;
b->cursor = nir_after_block_before_jump(pred);
@ -319,7 +319,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) {
set_foreach(&end_block->predecessors, entry) {
nir_block *pred = (nir_block *)entry->key;
for (unsigned stream = 0; stream < NIR_MAX_XFB_STREAMS; ++stream) {

2
src/compiler/nir/nir_lower_io_vars_to_temporaries.c
View file

@ -104,7 +104,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) {
set_foreach(&impl->end_block->predecessors, block_entry) {
struct nir_block *block = (void *)block_entry->key;
b.cursor = nir_after_block_before_jump(block);
emit_copies(&b, &state->new_outputs, &state->old_outputs);

2
src/compiler/nir/nir_lower_returns.c
View file

@ -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 (block->predecessors.entries == 0 &&
block != nir_start_block(state->builder.impl)) {
/* This block is unreachable. Delete it and everything after it. */
nir_cf_list list;

2
src/compiler/nir/nir_metadata.c
View file

@ -121,7 +121,7 @@ nir_metadata_invalidate(nir_shader *shader)
block->dom_children = NULL;
block->num_dom_children = 1;
block->dom_pre_index = block->dom_post_index = 0;
_mesa_set_clear(block->dom_frontier, NULL);
_mesa_set_clear(&block->dom_frontier, NULL);
if (block->cf_node.parent->type == nir_cf_node_loop &&
nir_cf_node_is_first(&block->cf_node)) {

2
src/compiler/nir/nir_opt_dce.c
View file

@ -176,7 +176,7 @@ 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;
struct set *predecessors = &nir_loop_first_block(loop)->predecessors;
if (predecessors->entries == 1 &&
_mesa_set_next_entry(predecessors, NULL)->key == inner_state.preheader) {
progress |= dce_cf_list(&loop->body, defs_live, parent_loop, dead_instrs);

2
src/compiler/nir/nir_opt_dead_cf.c
View file

@ -363,7 +363,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 (next->predecessors.entries == 0 &&
(!exec_list_is_empty(&next->instr_list) ||
!exec_node_is_tail_sentinel(next->cf_node.node.next))) {
nir_remove_after_cf_node(cur);

16
src/compiler/nir/nir_opt_if.c
View file

@ -42,9 +42,9 @@ 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(header_block->predecessors.entries == 2);
set_foreach(header_block->predecessors, pred_entry) {
set_foreach(&header_block->predecessors, pred_entry) {
if (pred_entry->key != prev_block)
return (nir_block *)pred_entry->key;
}
@ -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(_mesa_set_search(&header_block->predecessors, 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 (header_block->predecessors.entries != 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(_mesa_set_search(&header_block->predecessors, 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 (header_block->predecessors.entries != 2)
return false;
nir_block *continue_block = find_continue_block(loop);
@ -613,13 +613,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(_mesa_set_search(&header_block->predecessors, 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 (header_block->predecessors.entries != 2)
return false;
/* We can move any bcsel that can guaranteed to execut on every iteration

2
src/compiler/nir/nir_opt_licm.c
View file

@ -57,7 +57,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_loop_first_block(loop)->predecessors.entries == 1)
return false;
nir_foreach_block_in_cf_node(block, &loop->cf_node) {

6
src/compiler/nir/nir_opt_loop.c
View file

@ -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 (after_if->predecessors.entries > 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 (block->predecessors.entries == 0)
return false;
bool progress = false;
@ -367,7 +367,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 (header_block->predecessors.entries != 2)
return false;
nir_cf_node *if_node = nir_cf_node_next(&header_block->cf_node);

2
src/compiler/nir/nir_opt_remove_phis.c
View file

@ -158,7 +158,7 @@ nir_opt_remove_phis(nir_shader *shader)
bool
nir_remove_single_src_phis_block(nir_block *block)
{
assert(block->predecessors->entries <= 1);
assert(block->predecessors.entries <= 1);
bool progress = false;
nir_foreach_phi_safe(phi, block) {
nir_def *def = NULL;

4
src/compiler/nir/nir_opt_sink.c
View file

@ -270,7 +270,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_loop_first_block(loop)->predecessors.entries > 1)
return loop;
}
}
@ -311,7 +311,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_cf_tree_next(cur_block)->predecessors.entries > 1) {
nir_loop *following_loop = nir_cf_node_as_loop(next);
if (loop_contains_block(following_loop, use_block)) {
use_block = cur_block;

4
src/compiler/nir/nir_phi_builder.c
View file

@ -140,7 +140,7 @@ nir_phi_builder_add_value(struct nir_phi_builder *pb, unsigned num_components,
while (w_start != w_end) {
nir_block *cur = pb->W[w_start++];
set_foreach(cur->dom_frontier, dom_entry) {
set_foreach(&cur->dom_frontier, dom_entry) {
nir_block *next = (nir_block *)dom_entry->key;
/* If there's more than one return statement, then the end block
@ -290,7 +290,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 < phi->instr.block->predecessors.entries; i++) {
nir_phi_instr_add_src(phi, preds[i],
nir_phi_builder_value_get_block_def(val, preds[i]));
}

4
src/compiler/nir/nir_print.c
View file

@ -2087,7 +2087,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 < instr->instr.block->predecessors.entries; i++) {
nir_phi_src *src = nir_phi_get_src_from_block(instr, preds[i]);
if (i != 0)
fprintf(fp, ", ");
@ -2248,7 +2248,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 < block->predecessors.entries; i++) {
fprintf(fp, " b%u", state->preds[i]->index);
}
}

4
src/compiler/nir/nir_to_lcssa.c
View file

@ -236,7 +236,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 = state->block_after_loop->predecessors.entries;
for (uint32_t i = 0; i < num_exits; i++) {
nir_phi_instr_add_src(phi, state->exit_blocks[i], def);
}
@ -339,7 +339,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_loop_first_block(loop)->predecessors.entries == 1)
goto end;
nir_foreach_block_in_cf_node(block, cf_node) {

21
src/compiler/nir/nir_validate.c
View file

@ -1055,7 +1055,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);
state->block->predecessors.entries);
}
static void
@ -1294,16 +1294,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));
_mesa_set_search(&block->successors[i]->predecessors, 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, block->predecessors.entries == 0);
set_foreach(block->predecessors, entry) {
set_foreach(&block->predecessors, entry) {
const nir_block *pred = entry->key;
validate_assert(state, _mesa_set_search(state->blocks, pred));
validate_assert(state, pred->successors[0] == block ||
@ -1682,7 +1682,7 @@ typedef struct {
uint32_t index;
unsigned num_dom_children;
struct nir_block **dom_children;
struct set *dom_frontier;
struct set dom_frontier;
uint32_t dom_pre_index, dom_post_index;
} block_dom_metadata;
@ -1703,9 +1703,10 @@ validate_dominance(nir_function_impl *impl, validate_state *state)
md->dom_post_index = block->dom_post_index;
md->dom_children = block->dom_children;
md->dom_frontier = block->dom_frontier;
memset(&block->dom_frontier, 0, sizeof(struct set));
block->dom_children = NULL;
block->dom_frontier = _mesa_pointer_set_create(block);
_mesa_pointer_set_init(&block->dom_frontier, block);
}
/* Call metadata passes and compare it against the preserved metadata and call SSA dominance
@ -1731,9 +1732,9 @@ validate_dominance(nir_function_impl *impl, validate_state *state)
block->num_dom_children * sizeof(md->dom_children[0])));
}
validate_assert(state, block->dom_frontier->entries == md->dom_frontier->entries);
set_foreach(block->dom_frontier, entry) {
validate_assert(state, _mesa_set_search_pre_hashed(md->dom_frontier,
validate_assert(state, block->dom_frontier.entries == md->dom_frontier.entries);
set_foreach(&block->dom_frontier, entry) {
validate_assert(state, _mesa_set_search_pre_hashed(&md->dom_frontier,
entry->hash, entry->key));
}
}
@ -1750,7 +1751,7 @@ validate_dominance(nir_function_impl *impl, validate_state *state)
if (block->dom_children != block->_dom_children_storage)
ralloc_free(block->dom_children);
ralloc_free(block->dom_frontier);
_mesa_set_fini(&block->dom_frontier, NULL);
block->index = md->index;
block->num_dom_children = md->num_dom_children;

30
src/compiler/nir/tests/control_flow_tests.cpp
View file

@ -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, 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));
/* 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, 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));
nir_metadata_require(b->impl, nir_metadata_dominance);
}

4
src/freedreno/ir3/ir3_compiler_nir.c
View file

@ -4617,13 +4617,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 (nstart->predecessors.entries > 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) {
set_foreach (&nstart->predecessors, entry) {
nir_block *pred = (nir_block*)entry->key;
if (pred == nir_loop_last_block(nloop) ||
pred == nir_cf_node_as_block(nir_cf_node_prev(&nloop->cf_node)))

2
src/freedreno/ir3/ir3_nir_lower_tess.c
View file

@ -1065,7 +1065,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(impl->end_block->predecessors.entries == 1);
nir_block *block = nir_impl_last_block(impl);
b.cursor = nir_after_block_before_jump(block);

2
src/gallium/auxiliary/nir/nir_to_tgsi.c
View file

@ -448,7 +448,7 @@ 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) {
set_foreach(&block->predecessors, entry) {
nir_block *pred = (void *)entry->key;
nir_block_worklist_push_tail(&state.worklist, pred);
}

2
src/gallium/drivers/etnaviv/etnaviv_compiler_nir_liveness.c
View file

@ -235,7 +235,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) {
set_foreach(&block->predecessors, entry) {
nir_block *pred = (nir_block *)entry->key;
if (propagate_across_edge(pred, block, &state))
nir_block_worklist_push_tail(&state.worklist, pred);

2
src/gallium/drivers/nouveau/codegen/nv50_ir_from_nir.cpp
View file

@ -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 (!block->predecessors.entries && exec_list_is_empty(&block->instr_list))
return true;
BasicBlock *bb = convert(block);

2
src/gallium/drivers/zink/zink_compiler.c
View file

@ -2552,7 +2552,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(impl->end_block->predecessors.entries == 1);
clamp_layer_output_emit(&b, &state);
nir_progress(true, impl, nir_metadata_dominance);
}

4
src/intel/compiler/brw_nir_lower_intersection_shader.c
View file

@ -171,8 +171,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) {
assert(impl->end_block->predecessors.entries == 1);
set_foreach(&impl->end_block->predecessors, block_entry) {
struct nir_block *block = (void *)block_entry->key;
b->cursor = nir_after_block_before_jump(block);
nir_push_if(b, nir_load_var(b, commit));

6
src/intel/compiler/brw_nir_lower_shader_calls.c
View file

@ -71,7 +71,7 @@ brw_nir_lower_shader_returns(nir_shader *shader)
nir_builder b = nir_builder_create(impl);
set_foreach(impl->end_block->predecessors, block_entry) {
set_foreach(&impl->end_block->predecessors, block_entry) {
struct nir_block *block = (void *)block_entry->key;
b.cursor = nir_after_block_before_jump(block);
@ -81,7 +81,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(impl->end_block->predecessors.entries == 1);
brw_nir_btd_retire(&b);
break;
@ -104,7 +104,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(impl->end_block->predecessors.entries == 1);
brw_nir_btd_return(&b);
break;

4
src/intel/compiler/intel_nir_tcs_workarounds.c
View file

@ -119,11 +119,11 @@ 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 = impl->end_block->predecessors.entries;
nir_block *end_preds[num_end_preds];
unsigned i = 0;
set_foreach(impl->end_block->predecessors, entry) {
set_foreach(&impl->end_block->predecessors, entry) {
end_preds[i++] = (nir_block *) entry->key;
}

2
src/nouveau/compiler/nak_nir_lower_cf.c
View file

@ -238,7 +238,7 @@ block_is_merge(const nir_block *block)
return false;
unsigned num_preds = 0;
set_foreach(block->predecessors, entry) {
set_foreach(&block->predecessors, entry) {
const nir_block *pred = entry->key;
/* We don't care about unreachable blocks */

2
src/nouveau/compiler/nak_nir_lower_gs_intrinsics.c
View file

@ -69,7 +69,7 @@ append_final_primitive_nv(nir_block *end_block, struct state *state)
{
nir_builder *b = state->builder;
set_foreach(end_block->predecessors, entry) {
set_foreach(&end_block->predecessors, entry) {
nir_block *pred = (nir_block *)entry->key;
b->cursor = nir_after_block_before_jump(pred);