builtin_macros/trait_sel: Copy/Clone derives

As scalable vectors are ultimately just registers, they should be able
to implement `Copy` and `Clone`, which require some small special-casing
in the compiler to ignore the field within the scalable vector types.

Author: davidtwco

compiler/rustc_builtin_macros/src/deriving/clone.rs

@@ -33,37 +33,48 @@ pub(crate) fn expand_deriving_clone(
     let substructure;
     let is_simple;
     match item {
-        Annotatable::Item(annitem) => match &annitem.kind {
-            ItemKind::Struct(_, Generics { params, .. }, _)
-            | ItemKind::Enum(_, Generics { params, .. }, _) => {
-                let container_id = cx.current_expansion.id.expn_data().parent.expect_local();
-                let has_derive_copy = cx.resolver.has_derive_copy(container_id);
-                if has_derive_copy
-                    && !params
-                        .iter()
-                        .any(|param| matches!(param.kind, ast::GenericParamKind::Type { .. }))
-                {
-                    bounds = vec![];
+        Annotatable::Item(annitem) => {
+            let has_repr_scalable = annitem.attrs.iter().any(|attr| {
+                attr.has_name(sym::repr)
+                    && attr
+                        .meta_item_list()
+                        .map(|list| list.iter().any(|inner| inner.has_name(sym::scalable)))
+                        .unwrap_or(false)
+            });
+
+            match &annitem.kind {
+                ItemKind::Struct(_, Generics { params, .. }, _)
+                | ItemKind::Enum(_, Generics { params, .. }, _) => {
+                    let container_id = cx.current_expansion.id.expn_data().parent.expect_local();
+                    let has_derive_copy = cx.resolver.has_derive_copy(container_id);
+                    if has_derive_copy
+                        && !params
+                            .iter()
+                            .any(|param| matches!(param.kind, ast::GenericParamKind::Type { .. }))
+                    {
+                        bounds = vec![];
+                        is_simple = true;
+                        substructure = combine_substructure(Box::new(move |c, s, sub| {
+                            cs_clone_simple("Clone", c, s, sub, false, has_repr_scalable)
+                        }));
+                    } else {
+                        bounds = vec![];
+                        is_simple = false;
+                        substructure = combine_substructure(Box::new(|c, s, sub| {
+                            cs_clone("Clone", c, s, sub)
+                        }));
+                    }
+                }
+                ItemKind::Union(..) => {
+                    bounds = vec![Path(path_std!(marker::Copy))];
                     is_simple = true;
-                    substructure = combine_substructure(Box::new(|c, s, sub| {
-                        cs_clone_simple("Clone", c, s, sub, false)
+                    substructure = combine_substructure(Box::new(move |c, s, sub| {
+                        cs_clone_simple("Clone", c, s, sub, true, has_repr_scalable)
                     }));
-                } else {
-                    bounds = vec![];
-                    is_simple = false;
-                    substructure =
-                        combine_substructure(Box::new(|c, s, sub| cs_clone("Clone", c, s, sub)));
                 }
+                _ => cx.dcx().span_bug(span, "`#[derive(Clone)]` on wrong item kind"),
             }
-            ItemKind::Union(..) => {
-                bounds = vec![Path(path_std!(marker::Copy))];
-                is_simple = true;
-                substructure = combine_substructure(Box::new(|c, s, sub| {
-                    cs_clone_simple("Clone", c, s, sub, true)
-                }));
-            }
-            _ => cx.dcx().span_bug(span, "`#[derive(Clone)]` on wrong item kind"),
-        },
+        }
 
         _ => cx.dcx().span_bug(span, "`#[derive(Clone)]` on trait item or impl item"),
     }
@@ -98,6 +109,7 @@ fn cs_clone_simple(
     trait_span: Span,
     substr: &Substructure<'_>,
     is_union: bool,
+    has_repr_scalable: bool,
 ) -> BlockOrExpr {
     let mut stmts = ThinVec::new();
     let mut seen_type_names = FxHashSet::default();
@@ -112,6 +124,9 @@ fn cs_clone_simple(
                 // Already produced an assertion for this type.
                 // Anonymous structs or unions must be eliminated as they cannot be
                 // type parameters.
+            } else if has_repr_scalable {
+                // Fields of scalable vector types are just markers for codegen, don't assert they
+                // implement `Clone`
             } else {
                 // let _: AssertParamIsClone<FieldTy>;
                 super::assert_ty_bounds(

compiler/rustc_trait_selection/src/traits/misc.rs

@@ -66,6 +66,13 @@ pub fn type_allowed_to_implement_copy<'tcx>(
         _ => return Err(CopyImplementationError::NotAnAdt),
     };
 
+    // Scalable vectors have an unsized field that would normally disallow a `Copy` impl on the
+    // type, but that type doesn't actually exist, it's just a marker to know the element type of
+    // the vector. After codegen, scalable vectors are just a register that can be trivially copied.
+    if adt.repr().scalable() {
+        return Ok(());
+    }
+
     all_fields_implement_trait(
         tcx,
         param_env,

tests/codegen/simd/scalable.rs

@@ -0,0 +1,53 @@
+//@ compile-flags: -C opt-level=2
+//@ edition: 2021
+//@ only-aarch64
+
+#![crate_type = "lib"]
+#![allow(incomplete_features, internal_features)]
+#![feature(repr_simd, repr_scalable, simd_ffi, link_llvm_intrinsics)]
+
+#[derive(Copy, Clone)]
+#[repr(simd, scalable(4))]
+#[allow(non_camel_case_types)]
+pub struct svint32_t {
+    _ty: [i32],
+}
+
+#[inline(never)]
+#[target_feature(enable = "sve")]
+pub unsafe fn svdup_n_s32(op: i32) -> svint32_t {
+    extern "C" {
+        #[cfg_attr(target_arch = "aarch64", link_name = "llvm.aarch64.sve.dup.x.nxv4i32")]
+        fn _svdup_n_s32(op: i32) -> svint32_t;
+    }
+    unsafe { _svdup_n_s32(op) }
+}
+
+#[inline]
+#[target_feature(enable = "sve,sve2")]
+pub unsafe fn svxar_n_s32<const IMM3: i32>(op1: svint32_t, op2: svint32_t) -> svint32_t {
+    extern "C" {
+        #[cfg_attr(target_arch = "aarch64", link_name = "llvm.aarch64.sve.xar.nxv4i32")]
+        fn _svxar_n_s32(op1: svint32_t, op2: svint32_t, imm3: i32) -> svint32_t;
+    }
+    unsafe { _svxar_n_s32(op1, op2, IMM3) }
+}
+
+#[inline(never)]
+#[no_mangle]
+#[target_feature(enable = "sve,sve2")]
+// CHECK: define <vscale x 4 x i32> @pass_as_ref(ptr noalias nocapture noundef readonly align 4 dereferenceable(4) %a, <vscale x 4 x i32> %b)
+pub unsafe fn pass_as_ref(a: &svint32_t, b: svint32_t) -> svint32_t {
+    // CHECK: load <vscale x 4 x i32>, ptr %a, align 4
+    svxar_n_s32::<1>(*a, b)
+}
+
+#[no_mangle]
+#[target_feature(enable = "sve,sve2")]
+// CHECK: define <vscale x 4 x i32> @test()
+pub unsafe fn test() -> svint32_t {
+    let a = svdup_n_s32(1);
+    let b = svdup_n_s32(2);
+    // CHECK: call <vscale x 4 x i32> @pass_as_ref(ptr noalias noundef nonnull readonly align 4 dereferenceable(4) %a, <vscale x 4 x i32> %b)
+    pass_as_ref(&a, b)
+}

tests/ui/simd/scalable/copy-clone.rs

@@ -0,0 +1,31 @@
+//@ build-pass
+#![feature(link_llvm_intrinsics, repr_simd, repr_scalable, simd_ffi)]
+
+#[derive(Copy, Clone)]
+#[repr(simd, scalable(4))]
+#[allow(non_camel_case_types)]
+pub struct svint32_t {
+    _ty: [i32],
+}
+
+#[target_feature(enable = "sve")]
+pub unsafe fn svdup_n_s32(op: i32) -> svint32_t {
+    extern "C" {
+        #[cfg_attr(target_arch = "aarch64", link_name = "llvm.aarch64.sve.dup.x.nxv4i32")]
+        fn _svdup_n_s32(op: i32) -> svint32_t;
+    }
+    unsafe { _svdup_n_s32(op) }
+}
+
+#[target_feature(enable = "sve")]
+fn require_copy<T: Copy>(t: T) {}
+
+#[target_feature(enable = "sve")]
+fn test() {
+    unsafe {
+        let a = svdup_n_s32(1);
+        require_copy(a);
+    }
+}
+
+fn main() {}