nir: rework nir_alu_src_is_trivial_ssa to take an alu src

Reviewed-by: Daniel Schürmann <daniel@schuermann.dev>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/40399>

src/compiler/nir/nir.c

@@ -658,16 +658,22 @@ nir_alu_src_copy(nir_alu_src *dest, const nir_alu_src *src)
 }
 
 bool
-nir_alu_src_is_trivial_ssa(const nir_alu_instr *alu, unsigned srcn)
+nir_alu_src_is_trivial_ssa(const nir_alu_src *src, unsigned num_components)
 {
    static uint8_t trivial_swizzle[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };
    STATIC_ASSERT(ARRAY_SIZE(trivial_swizzle) == NIR_MAX_VEC_COMPONENTS);
 
+   return (src->src.ssa->num_components == num_components) &&
+          (memcmp(src->swizzle, trivial_swizzle, num_components) == 0);
+}
+
+bool
+nir_alu_has_trivial_src(const nir_alu_instr *alu, unsigned srcn)
+{
    const nir_alu_src *src = &alu->src[srcn];
    unsigned num_components = nir_ssa_alu_instr_src_components(alu, srcn);
 
-   return (src->src.ssa->num_components == num_components) &&
-          (memcmp(src->swizzle, trivial_swizzle, num_components) == 0);
+   return nir_alu_src_is_trivial_ssa(src, num_components);
 }
 
 static void

src/compiler/nir/nir.h

@@ -1648,7 +1648,9 @@ bool nir_alu_srcs_negative_equal(const nir_alu_instr *alu1,
                                  const nir_alu_instr *alu2,
                                  unsigned src1, unsigned src2);
 
-bool nir_alu_src_is_trivial_ssa(const nir_alu_instr *alu, unsigned srcn);
+bool nir_alu_src_is_trivial_ssa(const nir_alu_src *src, unsigned num_components);
+
+bool nir_alu_has_trivial_src(const nir_alu_instr *alu, unsigned srcn);
 
 typedef enum {
    nir_deref_type_var,

src/compiler/nir/nir_builder.c

@@ -414,7 +414,7 @@ nir_vec_scalars(nir_builder *build, nir_scalar *comp, unsigned num_components)
 nir_def *
 nir_ssa_for_alu_src(nir_builder *build, nir_alu_instr *instr, unsigned srcn)
 {
-   if (nir_alu_src_is_trivial_ssa(instr, srcn))
+   if (nir_alu_has_trivial_src(instr, srcn))
       return instr->src[srcn].src.ssa;
 
    nir_alu_src *src = &instr->src[srcn];

src/compiler/nir/nir_opt_if.c

@@ -284,7 +284,7 @@ is_trivial_bcsel(const nir_instr *instr, bool allow_non_phi_src)
       return false;
 
    for (unsigned i = 0; i < 3; i++) {
-      if (!nir_alu_src_is_trivial_ssa(bcsel, i) ||
+      if (!nir_alu_has_trivial_src(bcsel, i) ||
           nir_def_block(bcsel->src[i].src.ssa) != instr->block)
          return false;
 

src/compiler/nir/nir_opt_intrinsics.c

@@ -66,17 +66,17 @@ try_opt_bcsel_of_shuffle(nir_builder *b, nir_alu_instr *alu,
    if (block_has_discard)
       return NULL;
 
-   if (!nir_alu_src_is_trivial_ssa(alu, 0))
+   if (!nir_alu_has_trivial_src(alu, 0))
       return NULL;
 
    nir_def *data1, *index1;
-   if (!nir_alu_src_is_trivial_ssa(alu, 1) ||
+   if (!nir_alu_has_trivial_src(alu, 1) ||
        nir_def_block(alu->src[1].src.ssa) != alu->instr.block ||
        !src_is_single_use_shuffle(alu->src[1].src, &data1, &index1))
       return NULL;
 
    nir_def *data2, *index2;
-   if (!nir_alu_src_is_trivial_ssa(alu, 2) ||
+   if (!nir_alu_has_trivial_src(alu, 2) ||
        nir_def_block(alu->src[2].src.ssa) != alu->instr.block ||
        !src_is_single_use_shuffle(alu->src[2].src, &data2, &index2))
       return NULL;
@@ -136,7 +136,7 @@ src_is_alu(nir_op op, nir_src src, nir_src srcs[2])
    if (alu == NULL || alu->op != op)
       return false;
 
-   if (!nir_alu_src_is_trivial_ssa(alu, 0) || !nir_alu_src_is_trivial_ssa(alu, 1))
+   if (!nir_alu_has_trivial_src(alu, 0) || !nir_alu_has_trivial_src(alu, 1))
       return false;
 
    srcs[0] = alu->src[0].src;
@@ -151,7 +151,7 @@ try_opt_quad_vote(nir_builder *b, nir_alu_instr *alu, bool block_has_discard)
    if (block_has_discard)
       return NULL;
 
-   if (!nir_alu_src_is_trivial_ssa(alu, 0) || !nir_alu_src_is_trivial_ssa(alu, 1))
+   if (!nir_alu_has_trivial_src(alu, 0) || !nir_alu_has_trivial_src(alu, 1))
       return NULL;
 
    nir_intrinsic_instr *quad_broadcasts[4];

src/compiler/nir/nir_opt_shrink_vectors.c

@@ -523,7 +523,7 @@ opt_shrink_vectors_phi(nir_builder *b, nir_phi_instr *instr)
          if (src_idx != alu->src[src_idx].swizzle[0]) {
             mask |= src_read_mask;
          }
-      } else if (!nir_alu_src_is_trivial_ssa(alu, src_idx)) {
+      } else if (!nir_alu_has_trivial_src(alu, src_idx)) {
          mask |= src_read_mask;
       }
    }

src/kosmickrisp/compiler/nir_to_msl.c

@@ -185,7 +185,7 @@ alu_src_to_msl(struct nir_to_msl_ctx *ctx, nir_alu_instr *instr, int srcn)
 {
    nir_alu_src *src = &instr->src[srcn];
    src_to_msl(ctx, &src->src);
-   if (!nir_alu_src_is_trivial_ssa(instr, srcn) &&
+   if (!nir_alu_has_trivial_src(instr, srcn) &&
        src->src.ssa->num_components > 1) {
       int num_components = nir_src_num_components(src->src);
       assert(num_components <= 4);