attr: parse repr(simd, scalable(N))

Extend parsing of `ReprOptions` with `repr(scalable(N))` which always
accepts a single literal integral value - the base multiple of lanes
that are in a scalable vector. Can only be applied to structs and must
be used with `repr(simd)`.

Co-authored-by: Jamie Cunliffe <Jamie.Cunliffe@arm.com>

Author: davidtwco

compiler/rustc_abi/src/lib.rs

@@ -93,9 +93,11 @@ bitflags! {
         // Other flags can still inhibit reordering and thus randomization.
         // The seed stored in `ReprOptions.field_shuffle_seed`.
         const RANDOMIZE_LAYOUT   = 1 << 4;
+        const IS_SCALABLE = 1 << 5;
         // Any of these flags being set prevent field reordering optimisation.
         const FIELD_ORDER_UNOPTIMIZABLE   = ReprFlags::IS_C.bits()
                                  | ReprFlags::IS_SIMD.bits()
+                                 | ReprFlags::IS_SCALABLE.bits()
                                  | ReprFlags::IS_LINEAR.bits();
         const ABI_UNOPTIMIZABLE = ReprFlags::IS_C.bits() | ReprFlags::IS_SIMD.bits();
     }
@@ -143,6 +145,7 @@ pub struct ReprOptions {
     pub align: Option<Align>,
     pub pack: Option<Align>,
     pub flags: ReprFlags,
+    pub scalable: Option<u32>,
     /// The seed to be used for randomizing a type's layout
     ///
     /// Note: This could technically be a `u128` which would
@@ -159,6 +162,11 @@ impl ReprOptions {
         self.flags.contains(ReprFlags::IS_SIMD)
     }
 
+    #[inline]
+    pub fn scalable(&self) -> bool {
+        self.flags.contains(ReprFlags::IS_SCALABLE)
+    }
+
     #[inline]
     pub fn c(&self) -> bool {
         self.flags.contains(ReprFlags::IS_C)

compiler/rustc_attr_data_structures/src/attributes.rs

@@ -65,6 +65,7 @@ pub enum ReprAttr {
     ReprC,
     ReprPacked(Align),
     ReprSimd,
+    ReprScalable(ScalableElt),
     ReprTransparent,
     ReprAlign(Align),
     // this one is just so we can emit a lint for it
@@ -84,6 +85,13 @@ pub enum IntType {
     UnsignedInt(ast::UintTy),
 }
 
+/// The base multiple of lanes that are in a scalable vector.
+#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Encodable, Decodable, HashStable_Generic, PrintAttribute)]
+pub struct ScalableElt {
+    pub elt: u16,
+}
+
 #[derive(Copy, Debug, Encodable, Decodable, Clone, HashStable_Generic, PrintAttribute)]
 pub struct Deprecation {
     pub since: DeprecatedSince,

compiler/rustc_attr_parsing/messages.ftl

@@ -110,6 +110,10 @@ attr_parsing_rustc_allowed_unstable_pairing =
 attr_parsing_rustc_promotable_pairing =
     `rustc_promotable` attribute must be paired with either a `rustc_const_unstable` or a `rustc_const_stable` attribute
 
+attr_parsing_scalable_missing_n =
+    invalid `scalable(num)` attribute: `scalable` needs an argument
+    .suggestion = supply an argument here
+
 attr_parsing_soft_no_args =
     `soft` should not have any arguments
 

compiler/rustc_attr_parsing/src/attributes/repr.rs

@@ -1,6 +1,6 @@
 use rustc_abi::Align;
 use rustc_ast::{IntTy, LitIntType, LitKind, UintTy};
-use rustc_attr_data_structures::{AttributeKind, IntType, ReprAttr};
+use rustc_attr_data_structures::{AttributeKind, IntType, ReprAttr, ScalableElt};
 use rustc_feature::{AttributeTemplate, template};
 use rustc_span::{DUMMY_SP, Span, Symbol, sym};
 
@@ -143,6 +143,11 @@ fn parse_repr<S: Stage>(
         (Some(sym::Rust), ArgParser::NoArgs) => Some(ReprRust),
         (Some(sym::C), ArgParser::NoArgs) => Some(ReprC),
         (Some(sym::simd), ArgParser::NoArgs) => Some(ReprSimd),
+        (Some(sym::scalable), ArgParser::List(l)) => parse_repr_scalable(cx, l, param.span()),
+        (Some(sym::scalable), ArgParser::NoArgs) => {
+            cx.emit_err(session_diagnostics::ScalableAttrMissingN { span: param.span() });
+            None
+        }
         (Some(sym::transparent), ArgParser::NoArgs) => Some(ReprTransparent),
         (Some(name @ int_pat!()), ArgParser::NoArgs) => {
             // int_pat!() should make sure it always parses
@@ -321,3 +326,18 @@ impl<S: Stage> AttributeParser<S> for AlignParser {
         Some(AttributeKind::Align { align, span })
     }
 }
+
+fn parse_repr_scalable<S: Stage>(
+    cx: &AcceptContext<'_, '_, S>,
+    list: &MetaItemListParser<'_>,
+    span: Span,
+) -> Option<ReprAttr> {
+    let Some(LitKind::Int(literal, LitIntType::Unsuffixed)) =
+        list.single().and_then(|elt| elt.lit()).map(|lit| lit.kind)
+    else {
+        cx.emit_err(session_diagnostics::ScalableAttrMissingN { span });
+        return None;
+    };
+
+    literal.get().try_into().ok().map(|elt| ReprAttr::ReprScalable(ScalableElt { elt }))
+}

compiler/rustc_attr_parsing/src/session_diagnostics.rs

@@ -628,3 +628,11 @@ impl<'a, G: EmissionGuarantee> Diagnostic<'a, G> for AttributeParseError {
         diag
     }
 }
+
+#[derive(Diagnostic)]
+#[diag(attr_parsing_scalable_missing_n)]
+pub(crate) struct ScalableAttrMissingN {
+    #[primary_span]
+    #[suggestion(applicability = "has-placeholders", code = "scalable(...)")]
+    pub span: Span,
+}

compiler/rustc_middle/src/ty/mod.rs

@@ -1509,6 +1509,7 @@ impl<'tcx> TyCtxt<'tcx> {
         let mut size = None;
         let mut max_align: Option<Align> = None;
         let mut min_pack: Option<Align> = None;
+        let mut elt: Option<u32> = None;
 
         // Generate a deterministically-derived seed from the item's path hash
         // to allow for cross-crate compilation to actually work
@@ -1537,6 +1538,10 @@ impl<'tcx> TyCtxt<'tcx> {
                     }
                     attr::ReprTransparent => ReprFlags::IS_TRANSPARENT,
                     attr::ReprSimd => ReprFlags::IS_SIMD,
+                    attr::ReprScalable(e) => {
+                        elt = Some(e.elt as u32);
+                        ReprFlags::IS_SCALABLE
+                    }
                     attr::ReprInt(i) => {
                         size = Some(match i {
                             attr::IntType::SignedInt(x) => match x {
@@ -1585,7 +1590,14 @@ impl<'tcx> TyCtxt<'tcx> {
             flags.insert(ReprFlags::IS_LINEAR);
         }
 
-        ReprOptions { int: size, align: max_align, pack: min_pack, flags, field_shuffle_seed }
+        ReprOptions {
+            int: size,
+            align: max_align,
+            pack: min_pack,
+            flags,
+            field_shuffle_seed,
+            scalable: elt,
+        }
     }
 
     /// Look up the name of a definition across crates. This does not look at HIR.

compiler/rustc_middle/src/ty/sty.rs

@@ -1194,6 +1194,14 @@ impl<'tcx> Ty<'tcx> {
         }
     }
 
+    #[inline]
+    pub fn is_scalable_simd(self) -> bool {
+        match self.kind() {
+            Adt(def, _) => def.repr().simd() && def.repr().scalable(),
+            _ => false,
+        }
+    }
+
     pub fn sequence_element_type(self, tcx: TyCtxt<'tcx>) -> Ty<'tcx> {
         match self.kind() {
             Array(ty, _) | Slice(ty) => *ty,

compiler/rustc_passes/messages.ftl

@@ -601,6 +601,9 @@ passes_repr_align_should_be_align =
 passes_repr_conflicting =
     conflicting representation hints
 
+passes_repr_scalable_without_simd =
+    `scalable` representation hint without `simd` representation hint
+
 passes_rustc_allow_const_fn_unstable =
     attribute should be applied to `const fn`
     .label = not a `const fn`

compiler/rustc_passes/src/check_attr.rs

@@ -1927,6 +1927,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
         let mut is_explicit_rust = false;
         let mut is_c = false;
         let mut is_simd = false;
+        let mut is_scalable = false;
         let mut is_transparent = false;
 
         for (repr, repr_span) in reprs {
@@ -1995,6 +1996,17 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                         continue;
                     }
                 }
+                ReprAttr::ReprScalable(..) => {
+                    is_scalable = true;
+                    if target != Target::Struct {
+                        self.dcx().emit_err(errors::AttrApplication::Struct {
+                            hint_span: *repr_span,
+                            span,
+                        });
+                    } else {
+                        continue;
+                    }
+                }
                 ReprAttr::ReprTransparent => {
                     is_transparent = true;
                     match target {
@@ -2057,13 +2069,20 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                 target: target.to_string(),
             });
         }
-        if is_explicit_rust && (int_reprs > 0 || is_c || is_simd) {
+        if is_explicit_rust && (int_reprs > 0 || is_c || is_simd || is_scalable) {
             let hint_spans = hint_spans.clone().collect();
             self.dcx().emit_err(errors::ReprConflicting { hint_spans });
         }
-        // Warn on repr(u8, u16), repr(C, simd), and c-like-enum-repr(C, u8)
+        // Warn on `repr(scalable(N))` w/out `repr(simd)`
+        // i.e. only `repr(simd, scalable(N))` permitted
+        if is_scalable && !is_simd {
+            let hint_spans = hint_spans.clone().collect();
+            self.dcx().emit_err(errors::ReprScalableWithoutSimd { hint_spans });
+        }
+        // Warn on repr(u8, u16), repr(C, simd), repr(C, scalable), and c-like-enum-repr(C, u8)
         if (int_reprs > 1)
             || (is_simd && is_c)
+            || (is_scalable && is_c)
             || (int_reprs == 1
                 && is_c
                 && item.is_some_and(|item| {

compiler/rustc_passes/src/errors.rs

@@ -611,6 +611,13 @@ pub(crate) struct ReprConflicting {
     pub hint_spans: Vec<Span>,
 }
 
+#[derive(Diagnostic)]
+#[diag(passes_repr_scalable_without_simd)]
+pub(crate) struct ReprScalableWithoutSimd {
+    #[primary_span]
+    pub hint_spans: Vec<Span>,
+}
+
 #[derive(Diagnostic)]
 #[diag(passes_repr_align_greater_than_target_max, code = E0589)]
 #[note]