nir: use intrinsic builders

Signed-off-by: Rhys Perry <pendingchaos02@gmail.com>
Reviewed-by: Jason Ekstrand <jason@jlekstrand.net>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/6587>

src/compiler/nir/nir_inline_functions.c

@@ -36,9 +36,7 @@ void nir_inline_function_impl(struct nir_builder *b,
    /* Insert a nop at the cursor so we can keep track of where things are as
     * we add/remove stuff from the CFG.
     */
-   nir_intrinsic_instr *nop =
+   nir_intrinsic_instr *nop = nir_nop(b);
-      nir_intrinsic_instr_create(b->shader, nir_intrinsic_nop);
-   nir_builder_instr_insert(b, &nop->instr);
 
    exec_list_append(&b->impl->locals, &copy->locals);
    exec_list_append(&b->impl->registers, &copy->registers);

src/compiler/nir/nir_lower_bitmap.c

@@ -77,7 +77,6 @@ lower_bitmap(nir_shader *shader, nir_builder *b,
    nir_ssa_def *texcoord;
    nir_tex_instr *tex;
    nir_ssa_def *cond;
-   nir_intrinsic_instr *discard;
 
    texcoord = nir_load_var(b, get_texcoord(shader));
 
@@ -113,9 +112,7 @@ lower_bitmap(nir_shader *shader, nir_builder *b,
    cond = nir_f2b(b, nir_channel(b, &tex->dest.ssa,
                   options->swizzle_xxxx ? 0 : 3));
 
-   discard = nir_intrinsic_instr_create(shader, nir_intrinsic_discard_if);
+   nir_discard_if(b, cond);
-   discard->src[0] = nir_src_for_ssa(cond);
-   nir_builder_instr_insert(b, &discard->instr);
 
    shader->info.fs.uses_discard = true;
 }

src/compiler/nir/nir_lower_gs_intrinsics.c

@@ -102,13 +102,7 @@ rewrite_emit_vertex(nir_intrinsic_instr *intrin, struct state *state)
     */
    nir_push_if(b, nir_ilt(b, count, max_vertices));
 
-   nir_intrinsic_instr *lowered =
+   nir_emit_vertex_with_counter(b, count, count_per_primitive, stream);
-      nir_intrinsic_instr_create(b->shader,
-                                 nir_intrinsic_emit_vertex_with_counter);
-   nir_intrinsic_set_stream_id(lowered, stream);
-   lowered->src[0] = nir_src_for_ssa(count);
-   lowered->src[1] = nir_src_for_ssa(count_per_primitive);
-   nir_builder_instr_insert(b, &lowered->instr);
 
    /* Increment the vertex count by 1 */
    nir_store_var(b, state->vertex_count_vars[stream],
@@ -217,13 +211,7 @@ rewrite_end_primitive(nir_intrinsic_instr *intrin, struct state *state)
    else
       count_per_primitive = nir_ssa_undef(b, count->num_components, count->bit_size);
 
-   nir_intrinsic_instr *lowered =
+   nir_end_primitive_with_counter(b, count, count_per_primitive, stream);
-      nir_intrinsic_instr_create(b->shader,
-                                 nir_intrinsic_end_primitive_with_counter);
-   nir_intrinsic_set_stream_id(lowered, stream);
-   lowered->src[0] = nir_src_for_ssa(count);
-   lowered->src[1] = nir_src_for_ssa(count_per_primitive);
-   nir_builder_instr_insert(b, &lowered->instr);
 
    if (state->count_prims) {
       /* Increment the primitive count by 1 */
@@ -313,14 +301,7 @@ append_set_vertex_and_primitive_count(nir_block *end_block, struct state *state)
                        : nir_ssa_undef(b, 1, 32);
          }
 
-         nir_intrinsic_instr *set_cnt_intrin =
+         nir_set_vertex_and_primitive_count(b, vtx_cnt, prim_cnt, stream);
-            nir_intrinsic_instr_create(shader,
-               nir_intrinsic_set_vertex_and_primitive_count);
-
-         nir_intrinsic_set_stream_id(set_cnt_intrin, stream);
-         set_cnt_intrin->src[0] = nir_src_for_ssa(vtx_cnt);
-         set_cnt_intrin->src[1] = nir_src_for_ssa(prim_cnt);
-         nir_builder_instr_insert(b, &set_cnt_intrin->instr);
       }
    }
 }

src/compiler/nir/nir_lower_io.c

@@ -1992,14 +1992,8 @@ lower_explicit_io_array_length(nir_builder *b, nir_intrinsic_instr *intrin,
    nir_ssa_def *index = addr_to_index(b, addr, addr_format);
    nir_ssa_def *offset = addr_to_offset(b, addr, addr_format);
 
-   nir_intrinsic_instr *bsize =
-      nir_intrinsic_instr_create(b->shader, nir_intrinsic_get_ssbo_size);
-   bsize->src[0] = nir_src_for_ssa(index);
-   nir_ssa_dest_init(&bsize->instr, &bsize->dest, 1, 32, NULL);
-   nir_builder_instr_insert(b, &bsize->instr);
-
    nir_ssa_def *arr_size =
-      nir_idiv(b, nir_isub(b, &bsize->dest.ssa, offset),
+      nir_idiv(b, nir_isub(b, nir_get_ssbo_size(b, index), offset),
                   nir_imm_int(b, stride));
 
    nir_ssa_def_rewrite_uses(&intrin->dest.ssa, nir_src_for_ssa(arr_size));

src/compiler/nir/nir_lower_scratch.c

@@ -52,18 +52,9 @@ lower_load_store(nir_builder *b,
    size_align(deref->type, &size, &align);
 
    if (intrin->intrinsic == nir_intrinsic_load_deref) {
-      nir_intrinsic_instr *load =
-         nir_intrinsic_instr_create(b->shader, nir_intrinsic_load_scratch);
-      load->num_components = intrin->num_components;
-      load->src[0] = nir_src_for_ssa(offset);
-      nir_intrinsic_set_align(load, align, 0);
       unsigned bit_size = intrin->dest.ssa.bit_size;
-      nir_ssa_dest_init(&load->instr, &load->dest,
+      nir_ssa_def *value = nir_load_scratch(
-                        intrin->dest.ssa.num_components,
+         b, intrin->num_components, bit_size == 1 ? 32 : bit_size, offset, .align_mul=align);
-                        bit_size == 1 ? 32 : bit_size, NULL);
-      nir_builder_instr_insert(b, &load->instr);
-
-      nir_ssa_def *value = &load->dest.ssa;
       if (bit_size == 1)
          value = nir_b2b1(b, value);
 
@@ -77,14 +68,8 @@ lower_load_store(nir_builder *b,
       if (value->bit_size == 1)
          value = nir_b2b32(b, value);
 
-      nir_intrinsic_instr *store =
+      nir_store_scratch(b, value, offset, .align_mul=align,
-         nir_intrinsic_instr_create(b->shader, nir_intrinsic_store_scratch);
+                           .write_mask=nir_intrinsic_write_mask(intrin));
-      store->num_components = intrin->num_components;
-      store->src[0] = nir_src_for_ssa(value);
-      store->src[1] = nir_src_for_ssa(offset);
-      nir_intrinsic_set_write_mask(store, nir_intrinsic_write_mask(intrin));
-      nir_intrinsic_set_align(store, align, 0);
-      nir_builder_instr_insert(b, &store->instr);
    }
 
    nir_instr_remove(&intrin->instr);

src/compiler/nir/nir_lower_subgroups.c

@@ -187,20 +187,13 @@ lower_vote_eq_to_ballot(nir_builder *b, nir_intrinsic_instr *intrin,
    /* We have to implicitly lower to scalar */
    nir_ssa_def *all_eq = NULL;
    for (unsigned i = 0; i < intrin->num_components; i++) {
-      nir_intrinsic_instr *rfi =
+      nir_ssa_def *rfi = nir_read_first_invocation(b, nir_channel(b, value, i));
-         nir_intrinsic_instr_create(b->shader,
-                                    nir_intrinsic_read_first_invocation);
-      nir_ssa_dest_init(&rfi->instr, &rfi->dest,
-                        1, value->bit_size, NULL);
-      rfi->num_components = 1;
-      rfi->src[0] = nir_src_for_ssa(nir_channel(b, value, i));
-      nir_builder_instr_insert(b, &rfi->instr);
 
       nir_ssa_def *is_eq;
       if (intrin->intrinsic == nir_intrinsic_vote_feq) {
-         is_eq = nir_feq(b, &rfi->dest.ssa, nir_channel(b, value, i));
+         is_eq = nir_feq(b, rfi, nir_channel(b, value, i));
       } else {
-         is_eq = nir_ieq(b, &rfi->dest.ssa, nir_channel(b, value, i));
+         is_eq = nir_ieq(b, rfi, nir_channel(b, value, i));
       }
 
       if (all_eq == NULL) {
@@ -210,16 +203,8 @@ lower_vote_eq_to_ballot(nir_builder *b, nir_intrinsic_instr *intrin,
       }
    }
 
-   nir_intrinsic_instr *ballot =
+   nir_ssa_def *ballot = nir_ballot(b, 1, options->ballot_bit_size, nir_inot(b, all_eq));
-      nir_intrinsic_instr_create(b->shader, nir_intrinsic_ballot);
+   return nir_ieq(b, ballot, nir_imm_intN_t(b, 0, options->ballot_bit_size));
-   nir_ssa_dest_init(&ballot->instr, &ballot->dest,
-                     1, options->ballot_bit_size, NULL);
-   ballot->num_components = 1;
-   ballot->src[0] = nir_src_for_ssa(nir_inot(b, all_eq));
-   nir_builder_instr_insert(b, &ballot->instr);
-
-   return nir_ieq(b, &ballot->dest.ssa,
-                  nir_imm_intN_t(b, 0, options->ballot_bit_size));
 }
 
 static nir_ssa_def *
@@ -468,15 +453,9 @@ lower_subgroups_instr(nir_builder *b, nir_instr *instr, void *_options)
           intrin->dest.ssa.bit_size == options->ballot_bit_size)
          return NULL;
 
-      nir_intrinsic_instr *ballot =
+      nir_ssa_def *ballot = nir_ballot(b, 1, options->ballot_bit_size, intrin->src[0].ssa);
-         nir_intrinsic_instr_create(b->shader, nir_intrinsic_ballot);
-      ballot->num_components = 1;
-      nir_ssa_dest_init(&ballot->instr, &ballot->dest,
-                        1, options->ballot_bit_size, NULL);
-      nir_src_copy(&ballot->src[0], &intrin->src[0], ballot);
-      nir_builder_instr_insert(b, &ballot->instr);
 
-      return uint_to_ballot_type(b, &ballot->dest.ssa,
+      return uint_to_ballot_type(b, ballot,
                                  intrin->dest.ssa.num_components,
                                  intrin->dest.ssa.bit_size);
    }
@@ -553,13 +532,7 @@ lower_subgroups_instr(nir_builder *b, nir_instr *instr, void *_options)
       if (!options->lower_elect)
          return NULL;
 
-      nir_intrinsic_instr *first =
+      return nir_ieq(b, nir_load_subgroup_invocation(b), nir_first_invocation(b));
-         nir_intrinsic_instr_create(b->shader,
-                                    nir_intrinsic_first_invocation);
-      nir_ssa_dest_init(&first->instr, &first->dest, 1, 32, NULL);
-      nir_builder_instr_insert(b, &first->instr);
-
-      return nir_ieq(b, nir_load_subgroup_invocation(b), &first->dest.ssa);
    }
 
    case nir_intrinsic_shuffle:

src/compiler/nir/nir_opt_uniform_atomics.c

@@ -153,53 +153,20 @@ is_atomic_already_optimized(nir_shader *shader, nir_intrinsic_instr *instr)
    return (dims & dims_needed) == dims_needed || dims & 0x8;
 }
 
-static nir_ssa_def *
-emit_scalar_intrinsic(nir_builder *b, nir_intrinsic_op op, unsigned bit_size)
-{
-   nir_intrinsic_instr *intrin = nir_intrinsic_instr_create(b->shader, op);
-   nir_ssa_dest_init(&intrin->instr, &intrin->dest, 1, bit_size, NULL);
-   nir_builder_instr_insert(b, &intrin->instr);
-   return &intrin->dest.ssa;
-}
-
-static nir_ssa_def *
-emit_read_invocation(nir_builder *b, nir_ssa_def *data, nir_ssa_def *lane)
-{
-   nir_intrinsic_instr *ri = nir_intrinsic_instr_create(
-         b->shader, lane ? nir_intrinsic_read_invocation : nir_intrinsic_read_first_invocation);
-   nir_ssa_dest_init(&ri->instr, &ri->dest, 1, data->bit_size, NULL);
-   ri->num_components = 1;
-   ri->src[0] = nir_src_for_ssa(data);
-   if (lane)
-      ri->src[1] = nir_src_for_ssa(lane);
-   nir_builder_instr_insert(b, &ri->instr);
-   return &ri->dest.ssa;
-}
-
 /* Perform a reduction and/or exclusive scan. */
 static void
 reduce_data(nir_builder *b, nir_op op, nir_ssa_def *data,
             nir_ssa_def **reduce, nir_ssa_def **scan)
 {
-   nir_intrinsic_op intrin_op = scan ? nir_intrinsic_exclusive_scan : nir_intrinsic_reduce;
+   if (scan) {
-   nir_intrinsic_instr *intrin =
+      *scan = nir_exclusive_scan(b, data, .reduction_op=op);
-      nir_intrinsic_instr_create(b->shader, intrin_op);
+      if (reduce) {
-   intrin->num_components = 1;
+         nir_ssa_def *last_lane = nir_last_invocation(b);
-   intrin->src[0] = nir_src_for_ssa(data);
-   nir_intrinsic_set_reduction_op(intrin, op);
-   nir_ssa_dest_init(&intrin->instr, &intrin->dest, 1, data->bit_size, NULL);
-   nir_builder_instr_insert(b, &intrin->instr);
-
-   if (scan)
-      *scan = &intrin->dest.ssa;
-
-   if (scan && reduce) {
-      *scan = &intrin->dest.ssa;
-      nir_ssa_def *last_lane = emit_scalar_intrinsic(b, nir_intrinsic_last_invocation, 32);
          nir_ssa_def *res = nir_build_alu(b, op, *scan, data, NULL, NULL);
-      *reduce = emit_read_invocation(b, res, last_lane);
+         *reduce = nir_read_invocation(b, res, last_lane);
-   } else if (reduce) {
+      }
-      *reduce = &intrin->dest.ssa;
+   } else {
+      *reduce = nir_reduce(b, data, .reduction_op=op);
    }
 }
 
@@ -218,7 +185,7 @@ optimize_atomic(nir_builder *b, nir_intrinsic_instr *intrin, bool return_prev)
    nir_instr_rewrite_src(&intrin->instr, &intrin->src[data_src], nir_src_for_ssa(reduce));
    nir_update_instr_divergence(b->shader, &intrin->instr);
 
-   nir_ssa_def *cond = emit_scalar_intrinsic(b, nir_intrinsic_elect, 1);
+   nir_ssa_def *cond = nir_elect(b, 1);
 
    nir_if *nif = nir_push_if(b, cond);
 
@@ -232,7 +199,7 @@ optimize_atomic(nir_builder *b, nir_intrinsic_instr *intrin, bool return_prev)
 
       nir_pop_if(b, nif);
       nir_ssa_def *result = nir_if_phi(b, &intrin->dest.ssa, undef);
-      result = emit_read_invocation(b, result, NULL);
+      result = nir_read_first_invocation(b, result);
 
       if (!combined_scan_reduce)
          reduce_data(b, op, data, NULL, &scan);
@@ -249,7 +216,7 @@ optimize_and_rewrite_atomic(nir_builder *b, nir_intrinsic_instr *intrin)
 {
    nir_if *helper_nif = NULL;
    if (b->shader->info.stage == MESA_SHADER_FRAGMENT) {
-      nir_ssa_def *helper = emit_scalar_intrinsic(b, nir_intrinsic_is_helper_invocation, 1);
+      nir_ssa_def *helper = nir_is_helper_invocation(b, 1);
       helper_nif = nir_push_if(b, nir_inot(b, helper));
    }
 

src/compiler/nir/tests/load_store_vectorizer_tests.cpp

@@ -837,7 +837,7 @@ TEST_F(nir_load_store_vectorize_test, ssbo_load_adjacent_memory_barrier)
 TEST_F(nir_load_store_vectorize_test, ssbo_load_adjacent_barrier)
 {
    create_load(nir_var_mem_ssbo, 0, 0, 0x1);
-   nir_builder_instr_insert(b, &nir_intrinsic_instr_create(b->shader, nir_intrinsic_control_barrier)->instr);
+   nir_control_barrier(b);
    create_load(nir_var_mem_ssbo, 0, 4, 0x2);
 
    nir_validate_shader(b->shader, NULL);