diff --git a/src/amd/compiler/instruction_selection/aco_isel_setup.cpp b/src/amd/compiler/instruction_selection/aco_isel_setup.cpp
index 9e168388f96..d04e7df9d99 100644
--- a/src/amd/compiler/instruction_selection/aco_isel_setup.cpp
+++ b/src/amd/compiler/instruction_selection/aco_isel_setup.cpp
@@ -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));
 
diff --git a/src/amd/compiler/instruction_selection/aco_select_nir.cpp b/src/amd/compiler/instruction_selection/aco_select_nir.cpp
index 66948911d41..ec782774879 100644
--- a/src/amd/compiler/instruction_selection/aco_select_nir.cpp
+++ b/src/amd/compiler/instruction_selection/aco_select_nir.cpp
@@ -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);
diff --git a/src/compiler/nir/nir.c b/src/compiler/nir/nir.c
index 990978ec175..72da9f3ef18 100644
--- a/src/compiler/nir/nir.c
+++ b/src/compiler/nir/nir.c
@@ -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;
diff --git a/src/compiler/nir/nir.h b/src/compiler/nir/nir.h
index 60bf28ac22f..a7666f1d000 100644
--- a/src/compiler/nir/nir.h
+++ b/src/compiler/nir/nir.h
@@ -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
diff --git a/src/compiler/nir/nir_control_flow.c b/src/compiler/nir/nir_control_flow.c
index 3adce4f5f12..fcd86826915 100644
--- a/src/compiler/nir/nir_control_flow.c
+++ b/src/compiler/nir/nir_control_flow.c
@@ -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);
    }
diff --git a/src/compiler/nir/nir_divergence_analysis.c b/src/compiler/nir/nir_divergence_analysis.c
index 56506b18213..37dd14f5f12 100644
--- a/src/compiler/nir/nir_divergence_analysis.c
+++ b/src/compiler/nir/nir_divergence_analysis.c
@@ -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;
diff --git a/src/compiler/nir/nir_dominance.c b/src/compiler/nir/nir_dominance.c
index 53168e7c29a..36f54c651ad 100644
--- a/src/compiler/nir/nir_dominance.c
+++ b/src/compiler/nir/nir_dominance.c
@@ -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);
       }
diff --git a/src/compiler/nir/nir_from_ssa.c b/src/compiler/nir/nir_from_ssa.c
index f5cfdbe4d4b..83c257e85d6 100644
--- a/src/compiler/nir/nir_from_ssa.c
+++ b/src/compiler/nir/nir_from_ssa.c
@@ -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;
diff --git a/src/compiler/nir/nir_gs_count_vertices.c b/src/compiler/nir/nir_gs_count_vertices.c
index 176b813b80a..f014d02f2db 100644
--- a/src/compiler/nir/nir_gs_count_vertices.c
+++ b/src/compiler/nir/nir_gs_count_vertices.c
@@ -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) {
diff --git a/src/compiler/nir/nir_liveness.c b/src/compiler/nir/nir_liveness.c
index 9f0a17e82c4..27b6481ad7b 100644
--- a/src/compiler/nir/nir_liveness.c
+++ b/src/compiler/nir/nir_liveness.c
@@ -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);
diff --git a/src/compiler/nir/nir_lower_clip.c b/src/compiler/nir/nir_lower_clip.c
index 04a83bcb2c4..44020680e93 100644
--- a/src/compiler/nir/nir_lower_clip.c
+++ b/src/compiler/nir/nir_lower_clip.c
@@ -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 };
diff --git a/src/compiler/nir/nir_lower_continue_constructs.c b/src/compiler/nir/nir_lower_continue_constructs.c
index 39f334fa84c..69bd9c2b5f2 100644
--- a/src/compiler/nir/nir_lower_continue_constructs.c
+++ b/src/compiler/nir/nir_lower_continue_constructs.c
@@ -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;
diff --git a/src/compiler/nir/nir_lower_discard_if.c b/src/compiler/nir/nir_lower_discard_if.c
index 023a805e487..2bac9fa448f 100644
--- a/src/compiler/nir/nir_lower_discard_if.c
+++ b/src/compiler/nir/nir_lower_discard_if.c
@@ -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);
    }
 
diff --git a/src/compiler/nir/nir_lower_goto_ifs.c b/src/compiler/nir/nir_lower_goto_ifs.c
index 3d53ecdcdd4..c3be4eb2741 100644
--- a/src/compiler/nir/nir_lower_goto_ifs.c
+++ b/src/compiler/nir/nir_lower_goto_ifs.c
@@ -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);
diff --git a/src/compiler/nir/nir_lower_gs_intrinsics.c b/src/compiler/nir/nir_lower_gs_intrinsics.c
index ac1dc416da3..c74cad7e609 100644
--- a/src/compiler/nir/nir_lower_gs_intrinsics.c
+++ b/src/compiler/nir/nir_lower_gs_intrinsics.c
@@ -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) {
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 a455d5cdda2..360e986db68 100644
--- a/src/compiler/nir/nir_lower_io_vars_to_temporaries.c
+++ b/src/compiler/nir/nir_lower_io_vars_to_temporaries.c
@@ -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);
diff --git a/src/compiler/nir/nir_lower_returns.c b/src/compiler/nir/nir_lower_returns.c
index d7997a1830d..afa9f5c04dc 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 (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;
diff --git a/src/compiler/nir/nir_metadata.c b/src/compiler/nir/nir_metadata.c
index 6dcf37d90d0..fc90b9b5c33 100644
--- a/src/compiler/nir/nir_metadata.c
+++ b/src/compiler/nir/nir_metadata.c
@@ -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)) {
diff --git a/src/compiler/nir/nir_opt_dce.c b/src/compiler/nir/nir_opt_dce.c
index eb90008cd88..5ec3c959d8a 100644
--- a/src/compiler/nir/nir_opt_dce.c
+++ b/src/compiler/nir/nir_opt_dce.c
@@ -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);
diff --git a/src/compiler/nir/nir_opt_dead_cf.c b/src/compiler/nir/nir_opt_dead_cf.c
index ba8999b4d52..e51685b507c 100644
--- a/src/compiler/nir/nir_opt_dead_cf.c
+++ b/src/compiler/nir/nir_opt_dead_cf.c
@@ -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);
diff --git a/src/compiler/nir/nir_opt_if.c b/src/compiler/nir/nir_opt_if.c
index 63dbb5a233a..a3c09bfdeaf 100644
--- a/src/compiler/nir/nir_opt_if.c
+++ b/src/compiler/nir/nir_opt_if.c
@@ -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
diff --git a/src/compiler/nir/nir_opt_licm.c b/src/compiler/nir/nir_opt_licm.c
index 1c6f500611e..8ede208b4cc 100644
--- a/src/compiler/nir/nir_opt_licm.c
+++ b/src/compiler/nir/nir_opt_licm.c
@@ -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) {
diff --git a/src/compiler/nir/nir_opt_loop.c b/src/compiler/nir/nir_opt_loop.c
index 71fa66cefb0..ee19a052f28 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 (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);
diff --git a/src/compiler/nir/nir_opt_remove_phis.c b/src/compiler/nir/nir_opt_remove_phis.c
index a63ed4e2c69..6f35e59f31f 100644
--- a/src/compiler/nir/nir_opt_remove_phis.c
+++ b/src/compiler/nir/nir_opt_remove_phis.c
@@ -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;
diff --git a/src/compiler/nir/nir_opt_sink.c b/src/compiler/nir/nir_opt_sink.c
index 358bd969ce6..4415bd29c6f 100644
--- a/src/compiler/nir/nir_opt_sink.c
+++ b/src/compiler/nir/nir_opt_sink.c
@@ -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;
diff --git a/src/compiler/nir/nir_phi_builder.c b/src/compiler/nir/nir_phi_builder.c
index 246be2ac944..e59a33cb10a 100644
--- a/src/compiler/nir/nir_phi_builder.c
+++ b/src/compiler/nir/nir_phi_builder.c
@@ -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]));
          }
diff --git a/src/compiler/nir/nir_print.c b/src/compiler/nir/nir_print.c
index 4a2132cda87..3fb633fad46 100644
--- a/src/compiler/nir/nir_print.c
+++ b/src/compiler/nir/nir_print.c
@@ -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);
    }
 }
diff --git a/src/compiler/nir/nir_to_lcssa.c b/src/compiler/nir/nir_to_lcssa.c
index cebbb483fe6..afeb59359f5 100644
--- a/src/compiler/nir/nir_to_lcssa.c
+++ b/src/compiler/nir/nir_to_lcssa.c
@@ -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) {
diff --git a/src/compiler/nir/nir_validate.c b/src/compiler/nir/nir_validate.c
index 3b6b71d6772..2f724ae3748 100644
--- a/src/compiler/nir/nir_validate.c
+++ b/src/compiler/nir/nir_validate.c
@@ -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;
diff --git a/src/compiler/nir/tests/control_flow_tests.cpp b/src/compiler/nir/tests/control_flow_tests.cpp
index 994bc6517fc..84e7e8f6249 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,       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);
 }
diff --git a/src/freedreno/ir3/ir3_compiler_nir.c b/src/freedreno/ir3/ir3_compiler_nir.c
index fbb4b58a334..bf46dbc0b27 100644
--- a/src/freedreno/ir3/ir3_compiler_nir.c
+++ b/src/freedreno/ir3/ir3_compiler_nir.c
@@ -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)))
diff --git a/src/freedreno/ir3/ir3_nir_lower_tess.c b/src/freedreno/ir3/ir3_nir_lower_tess.c
index 905619028cf..c7e7165cc62 100644
--- a/src/freedreno/ir3/ir3_nir_lower_tess.c
+++ b/src/freedreno/ir3/ir3_nir_lower_tess.c
@@ -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);
 
diff --git a/src/gallium/auxiliary/nir/nir_to_tgsi.c b/src/gallium/auxiliary/nir/nir_to_tgsi.c
index e0030061907..0cd3fd5d50a 100644
--- a/src/gallium/auxiliary/nir/nir_to_tgsi.c
+++ b/src/gallium/auxiliary/nir/nir_to_tgsi.c
@@ -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);
             }
diff --git a/src/gallium/drivers/etnaviv/etnaviv_compiler_nir_liveness.c b/src/gallium/drivers/etnaviv/etnaviv_compiler_nir_liveness.c
index 80dc35081f4..ac9ef49a4d7 100644
--- a/src/gallium/drivers/etnaviv/etnaviv_compiler_nir_liveness.c
+++ b/src/gallium/drivers/etnaviv/etnaviv_compiler_nir_liveness.c
@@ -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);
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 6d0f27b34c1..bfec384b830 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 (!block->predecessors.entries && 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 04f8758757f..d371aae181f 100644
--- a/src/gallium/drivers/zink/zink_compiler.c
+++ b/src/gallium/drivers/zink/zink_compiler.c
@@ -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);
    }
diff --git a/src/intel/compiler/brw_nir_lower_intersection_shader.c b/src/intel/compiler/brw_nir_lower_intersection_shader.c
index bdad0f754fe..3f82f9db392 100644
--- a/src/intel/compiler/brw_nir_lower_intersection_shader.c
+++ b/src/intel/compiler/brw_nir_lower_intersection_shader.c
@@ -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));
diff --git a/src/intel/compiler/brw_nir_lower_shader_calls.c b/src/intel/compiler/brw_nir_lower_shader_calls.c
index 7399f60e16a..223caf3c35d 100644
--- a/src/intel/compiler/brw_nir_lower_shader_calls.c
+++ b/src/intel/compiler/brw_nir_lower_shader_calls.c
@@ -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;
 
diff --git a/src/intel/compiler/intel_nir_tcs_workarounds.c b/src/intel/compiler/intel_nir_tcs_workarounds.c
index e06ec236abe..cf3f5826679 100644
--- a/src/intel/compiler/intel_nir_tcs_workarounds.c
+++ b/src/intel/compiler/intel_nir_tcs_workarounds.c
@@ -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;
    }
 
diff --git a/src/nouveau/compiler/nak_nir_lower_cf.c b/src/nouveau/compiler/nak_nir_lower_cf.c
index 8df69d00f60..e8abed7ecb5 100644
--- a/src/nouveau/compiler/nak_nir_lower_cf.c
+++ b/src/nouveau/compiler/nak_nir_lower_cf.c
@@ -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 */
diff --git a/src/nouveau/compiler/nak_nir_lower_gs_intrinsics.c b/src/nouveau/compiler/nak_nir_lower_gs_intrinsics.c
index f5518fe64a2..7f43a1dac1b 100644
--- a/src/nouveau/compiler/nak_nir_lower_gs_intrinsics.c
+++ b/src/nouveau/compiler/nak_nir_lower_gs_intrinsics.c
@@ -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);