treewide: use nir_mov_scalar

Via Coccinelle patch:

    @@
    expression builder, scalar;
    @@

    -nir_channel(builder, scalar.def, scalar.comp)
    +nir_mov_scalar(builder, scalar)

Signed-off-by: Alyssa Rosenzweig <alyssa@rosenzweig.io>
Reviewed-by: Georg Lehmann <dadschoorse@gmail.com>
Reviewed-by: Eric Engestrom <eric@igalia.com>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/36142>

src/amd/common/nir/ac_nir_lower_global_access.c

@@ -41,7 +41,7 @@ try_extract_additions(nir_builder *b, nir_scalar scalar, uint64_t *out_const,
          nir_scalar offset_scalar = nir_scalar_chase_alu_src(src, 0);
          if (offset_scalar.def->bit_size != 32)
             continue;
-         *out_offset = nir_channel(b, offset_scalar.def, offset_scalar.comp);
+         *out_offset = nir_mov_scalar(b, offset_scalar);
       } else {
          continue;
       }
@@ -56,8 +56,8 @@ try_extract_additions(nir_builder *b, nir_scalar scalar, uint64_t *out_const,
    if (!replace_src0 && !replace_src1)
       return NULL;
 
-   replace_src0 = replace_src0 ? replace_src0 : nir_channel(b, src0.def, src0.comp);
-   replace_src1 = replace_src1 ? replace_src1 : nir_channel(b, src1.def, src1.comp);
+   replace_src0 = replace_src0 ? replace_src0 : nir_mov_scalar(b, src0);
+   replace_src1 = replace_src1 ? replace_src1 : nir_mov_scalar(b, src1);
    return nir_iadd(b, replace_src0, replace_src1);
 }
 

src/amd/common/nir/ac_nir_lower_ngg.c

@@ -409,7 +409,7 @@ replace_scalar_component_uses(nir_builder *b, nir_scalar old, nir_scalar rep)
    for (unsigned dst_comp = 0; dst_comp < old.def->num_components; ++dst_comp) {
       nir_scalar old_dst = nir_get_scalar(old.def, dst_comp);
       nir_scalar new_dst = dst_comp == old.comp ? rep : old_dst;
-      dst[dst_comp] = nir_channel(b, new_dst.def, new_dst.comp);
+      dst[dst_comp] = nir_mov_scalar(b, new_dst);
    }
 
    nir_def *replacement = nir_vec(b, dst, old.def->num_components);

src/asahi/compiler/agx_compile.c

@@ -3012,8 +3012,8 @@ optimize_bounds(nir_builder *b, nir_intrinsic_instr *intr, void *data)
 
    /* Now start rewriting. Grab some common variables */
    b->cursor = nir_before_instr(&intr->instr);
-   nir_def *offset = nir_channel(b, srcs[0].def, srcs[0].comp);
-   nir_def *bounds = nir_channel(b, srcs[1].def, srcs[1].comp);
+   nir_def *offset = nir_mov_scalar(b, srcs[0]);
+   nir_def *bounds = nir_mov_scalar(b, srcs[1]);
 
    nir_def *in_bounds = nir_uge(b, bounds, offset);
    nir_def *zero = nir_imm_int(b, 0);

src/asahi/vulkan/hk_shader.c

@@ -285,7 +285,7 @@ check_in_bounds(nir_builder *b, nir_intrinsic_instr *intr)
       if (nir_scalar_is_const(srcs[1 - i]) &&
           nir_scalar_as_uint(srcs[1 - i]) == load_size) {
 
-         nir_def *index = nir_channel(b, srcs[i].def, srcs[i].comp);
+         nir_def *index = nir_mov_scalar(b, srcs[i]);
          return nir_ult(b, index, nir_udiv_imm(b, bound, load_size));
       }
    }
@@ -309,8 +309,8 @@ bound_offset(nir_builder *b, nir_def *valid, nir_scalar offset)
          nir_scalar_chase_alu_src(offset, 1),
       };
       unsigned i = nir_scalar_is_const(srcs[0]) ? 1 : 0;
-      nir_def *x = nir_channel(b, srcs[i].def, srcs[i].comp);
-      nir_def *y = nir_channel(b, srcs[1 - i].def, srcs[1 - i].comp);
+      nir_def *x = nir_mov_scalar(b, srcs[i]);
+      nir_def *y = nir_mov_scalar(b, srcs[1 - i]);
 
       return nir_amul(b, nir_bcsel(b, valid, x, nir_imm_int(b, 0)), y);
    }
@@ -326,7 +326,7 @@ bound_offset(nir_builder *b, nir_def *valid, nir_scalar offset)
       }
    }
 
-   nir_def *def = nir_channel(b, offset.def, offset.comp);
+   nir_def *def = nir_mov_scalar(b, offset);
 
    /* If the offset fits within the zero page, clamping is pointless */
    if (nir_scalar_is_const(offset) &&

src/compiler/nir/nir_lower_mediump.c

@@ -566,7 +566,7 @@ opt_16bit_src(nir_builder *b, nir_instr *instr, nir_src *src, nir_alu_type src_t
          if (new_comps[i].def->bit_size != 16) {
             assert(new_comps[i].def->bit_size == 32);
 
-            nir_def *extract = nir_channel(b, new_comps[i].def, new_comps[i].comp);
+            nir_def *extract = nir_mov_scalar(b, new_comps[i]);
             switch (nir_scalar_alu_op(comp)) {
             case nir_op_unpack_half_2x16_split_x:
                extract = nir_unpack_32_2x16_split_x(b, extract);

src/compiler/nir/nir_opt_generate_bfi.c

@@ -134,15 +134,15 @@ nir_opt_generate_bfi_instr(nir_builder *b,
    if (b->shader->options->has_bfi) {
       bfi = nir_bfi(b,
                     nir_imm_int(b, mask),
-                    nir_channel(b, insert.def, insert.comp),
-                    nir_channel(b, base.def, base.comp));
+                    nir_mov_scalar(b, insert),
+                    nir_mov_scalar(b, base));
    } else {
       assert(b->shader->options->has_bitfield_select);
 
       bfi = nir_bitfield_select(b,
                                 nir_imm_int(b, mask),
-                                nir_channel(b, insert.def, insert.comp),
-                                nir_channel(b, base.def, base.comp));
+                                nir_mov_scalar(b, insert),
+                                nir_mov_scalar(b, base));
    }
 
    nir_def_replace(&alu->def, bfi);

src/compiler/nir/nir_opt_if.c

@@ -1030,7 +1030,7 @@ rewrite_comp_uses_within_if(nir_builder *b, nir_if *nif, bool invert,
 
       if (!new_ssa) {
          b->cursor = nir_before_cf_node(&nif->cf_node);
-         new_ssa = nir_channel(b, new_scalar.def, new_scalar.comp);
+         new_ssa = nir_mov_scalar(b, new_scalar);
          if (scalar.def->num_components > 1) {
             nir_def *vec = nir_undef(b, scalar.def->num_components, scalar.def->bit_size);
             new_ssa = nir_vector_insert_imm(b, vec, new_ssa, scalar.comp);

src/compiler/nir/nir_opt_mqsad.c

@@ -93,7 +93,7 @@ parse_msad(nir_alu_instr *msad, struct mqsad *mqsad)
 static void
 create_msad(nir_builder *b, struct mqsad *mqsad)
 {
-   nir_def *mqsad_def = nir_mqsad_4x8(b, nir_channel(b, mqsad->ref.def, mqsad->ref.comp),
+   nir_def *mqsad_def = nir_mqsad_4x8(b, nir_mov_scalar(b, mqsad->ref),
                                       nir_vec_scalars(b, mqsad->src, 2),
                                       nir_vec_scalars(b, mqsad->accum, 4));
 

src/compiler/nir/nir_opt_offsets.c

@@ -93,9 +93,8 @@ try_extract_const_addition(nir_builder *b, nir_scalar val, opt_offsets_state *st
       return val;
 
    b->cursor = nir_before_instr(&alu->instr);
-   nir_def *r =
-      nir_iadd(b, nir_channel(b, src[0].def, src[0].comp),
-               nir_channel(b, src[1].def, src[1].comp));
+   nir_def *r = nir_iadd(b, nir_mov_scalar(b, src[0]),
+                         nir_mov_scalar(b, src[1]));
    return nir_get_scalar(r, 0);
 }
 
@@ -130,7 +129,7 @@ try_fold_load_store(nir_builder *b,
          return false;
       off_const += add_offset;
       b->cursor = nir_before_instr(&intrin->instr);
-      replace_src = nir_channel(b, val.def, val.comp);
+      replace_src = nir_mov_scalar(b, val);
    } else if (nir_src_as_uint(*off_src) && nir_src_as_uint(*off_src) <= max - off_const) {
       off_const += nir_src_as_uint(*off_src);
       b->cursor = nir_before_instr(&intrin->instr);

src/freedreno/vulkan/tu_shader.cc

@@ -319,7 +319,7 @@ lower_ssbo_ubo_intrinsic(struct tu_device *dev,
       return true;
    }
 
-   nir_def *base_idx = nir_channel(b, scalar_idx.def, scalar_idx.comp);
+   nir_def *base_idx = nir_mov_scalar(b, scalar_idx);
    for (unsigned i = 0; i < dev->physical_device->info->a6xx.max_sets; i++) {
       /* if (base_idx == i) { ... */
       nir_if *nif = nir_push_if(b, nir_ieq_imm(b, base_idx, i));