Rollup of 24 pull requests

compiler/rustc_abi/src/callconv/reg.rs

@@ -27,9 +27,9 @@ impl RegKind {
         match primitive {
             Primitive::Int(..) | Primitive::Pointer(_) => RegKind::Integer,
             Primitive::Float(Float::PpcF128) => RegKind::PpcF128,
-            Primitive::Float(Float::F16 | Float::F16B | Float::F32 | Float::F64 | Float::F128) => {
-                RegKind::Float
-            }
+            Primitive::Float(
+                Float::F16 | Float::F16B | Float::F32 | Float::F64 | Float::X87F80 | Float::F128,
+            ) => RegKind::Float,
         }
     }
 }
@@ -60,6 +60,7 @@ impl Reg {
     reg_ctor!(f16, Float, 16);
     reg_ctor!(f32, Float, 32);
     reg_ctor!(f64, Float, 64);
+    reg_ctor!(x87_f80, Float, 80);
     reg_ctor!(f128, Float, 128);
 
     /// A vector of the given size with an unknown (and irrelevant) element type.
@@ -70,7 +71,8 @@ impl Reg {
 }
 
 impl Reg {
-    pub fn align<C: HasDataLayout>(&self, cx: &C) -> Align {
+    /// Alignment used for the scratch space when this type is part of a `PassMode::Cast`.
+    pub fn scratch_align<C: HasDataLayout>(&self, cx: &C) -> Align {
         let dl = cx.data_layout();
         match self.kind {
             RegKind::Integer => match self.size.bits() {
@@ -86,6 +88,10 @@ impl Reg {
                 16 => dl.f16_align,
                 32 => dl.f32_align,
                 64 => dl.f64_align,
+                // This alignment is not a multiple of 80 bits, but the alignment
+                // here is only used to align the alloca of a cast, and there the
+                // full alignment of x87_f80 should be used.
+                80 => dl.x87_f80_align,
                 128 => dl.f128_align,
                 _ => panic!("unsupported float: {self:?}"),
             },

compiler/rustc_abi/src/layout/ty.rs

@@ -122,6 +122,7 @@ pub trait TyAbiInterface<'a, C>: Sized + std::fmt::Debug + std::fmt::Display {
     fn is_unit(this: TyAndLayout<'a, Self>) -> bool;
     fn is_transparent(this: TyAndLayout<'a, Self>) -> bool;
     fn is_complex_number_lang_item(this: TyAndLayout<'a, Self>, cx: &C) -> bool;
+    fn is_x87_f80_lang_item(this: TyAndLayout<'a, Self>, cx: &C) -> bool;
     fn is_scalable_vector(this: TyAndLayout<'a, Self>) -> bool;
     /// See [`TyAndLayout::pass_indirectly_in_non_rustic_abis`] for details.
     fn is_pass_indirectly_in_non_rustic_abis_flag_set(this: TyAndLayout<'a, Self>) -> bool;
@@ -232,6 +233,17 @@ impl<'a, Ty> TyAndLayout<'a, Ty> {
         Ty::is_scalable_vector(self)
     }
 
+    /// Returns `true` if this type is the `x87_f80` lang item.
+    ///
+    /// Note that this function returns `false` for the `x87_f80_raw` lang item.
+    pub fn is_x87_f80<C>(self, cx: &C) -> bool
+    where
+        Ty: TyAbiInterface<'a, C> + Copy,
+    {
+        // A 1-ZST is never x87_f80.
+        Ty::is_x87_f80_lang_item(self.peel_transparent_wrappers_from_non_1zst(cx), cx)
+    }
+
     /// If this method returns `true`, then this type should always have a `PassMode` of
     /// `Indirect { mode: IndirectMode::Pointer, .. }` when being used as the argument type of a
     /// function with a non-Rustic ABI (this is true for structs annotated with the
@@ -339,6 +351,10 @@ impl<'a, Ty> TyAndLayout<'a, Ty> {
 
         let component = complex.field(cx, 0).peel_transparent_wrappers_from_non_1zst(cx);
 
+        if component.is_x87_f80(cx) {
+            return Some(Numeric::Float(Float::X87F80));
+        }
+
         let BackendRepr::Scalar(scalar) = component.backend_repr else {
             return None;
         };
@@ -353,6 +369,7 @@ impl<'a, Ty> TyAndLayout<'a, Ty> {
             Primitive::Float(
                 float @ (Float::F16 | Float::F32 | Float::F64 | Float::F128 | Float::PpcF128),
             ) => Some(Numeric::Float(float)),
+            Primitive::Float(Float::X87F80) => None, // x87_f80_raw has incorrect alignment.
             Primitive::Pointer(..) | Primitive::Float(Float::F16B) => None,
         }
     }

compiler/rustc_abi/src/lib.rs

@@ -327,6 +327,7 @@ pub struct TargetDataLayout {
     pub f16_align: Align,
     pub f32_align: Align,
     pub f64_align: Align,
+    pub x87_f80_align: Align,
     pub f128_align: Align,
     pub aggregate_align: Align,
 
@@ -367,6 +368,7 @@ impl Default for TargetDataLayout {
             f16_align: align(16),
             f32_align: align(32),
             f64_align: align(64),
+            x87_f80_align: align(128),
             f128_align: align(128),
             aggregate_align: align(8),
             vector_align: vec![
@@ -510,6 +512,7 @@ impl TargetDataLayout {
                 ["f16", a @ ..] => dl.f16_align = parse_align_seq(a, "f16")?,
                 ["f32", a @ ..] => dl.f32_align = parse_align_seq(a, "f32")?,
                 ["f64", a @ ..] => dl.f64_align = parse_align_seq(a, "f64")?,
+                ["f80", a @ ..] => dl.x87_f80_align = parse_align_seq(a, "f80")?,
                 ["f128", a @ ..] => dl.f128_align = parse_align_seq(a, "f128")?,
                 [p, s, a @ ..] if p.starts_with("p") => {
                     let mut p = p.strip_prefix('p').unwrap();
@@ -1387,10 +1390,22 @@ pub enum Float {
     F16B,
     F32,
     F64,
+    /// `x87_f80`. This is not a builtin type in Rust (it is exposed as a lang item),
+    /// but it is a builtin type in LLVM so needs to be explicitly represented
+    /// in the backend.
+    ///
+    /// Here we define the 80-bit scalar value that corresponds to the `x87_f80_raw` lang item.
+    /// In `core::arch::{x86, x86_64}` this type is wrapped by the `x87_f80` lang item that adds
+    /// the proper alignment and bumps the size to either 12 or 16 bytes depending on the target.
+    ///
+    /// Only used on x86 and x86_64 targets.
+    X87F80,
     F128,
     /// `ppcf128`. This is not a builtin type in Rust (it is exposed as a lang item),
     /// but it is a builtin type in LLVM so needs to be explicitly represented
     /// in the backend.
+    ///
+    /// Only used on powerpc and powerpc64 targets.
     PpcF128,
 }
 
@@ -1403,6 +1418,7 @@ impl Float {
             F16B => Size::from_bits(16),
             F32 => Size::from_bits(32),
             F64 => Size::from_bits(64),
+            X87F80 => Size::from_bits(80),
             F128 => Size::from_bits(128),
             PpcF128 => Size::from_bits(128),
         }
@@ -1416,6 +1432,9 @@ impl Float {
             F16 | F16B => dl.f16_align,
             F32 => dl.f32_align,
             F64 => dl.f64_align,
+            // Use an alignment of 1 for x87_f80_raw,
+            // so that its size really is 80 bits in memory.
+            X87F80 => Align::ONE,
             F128 => dl.f128_align,
             PpcF128 => dl.f128_align,
         }
@@ -1429,6 +1448,7 @@ impl Float {
             F16B => "f16b",
             F32 => "f32",
             F64 => "f64",
+            X87F80 => "x87_f80",
             F128 => "f128",
             PpcF128 => "ppcf128",
         }
@@ -1439,7 +1459,7 @@ impl Float {
 
         match self {
             F16 | F32 | F64 | F128 => true,
-            F16B | PpcF128 => false,
+            F16B | X87F80 | PpcF128 => false,
         }
     }
 }
@@ -1465,9 +1485,9 @@ impl Numeric {
         match self {
             Numeric::Int(_, _) => RegKind::Integer,
             Numeric::Float(Float::PpcF128) => RegKind::PpcF128,
-            Numeric::Float(Float::F16 | Float::F16B | Float::F32 | Float::F64 | Float::F128) => {
-                RegKind::Float
-            }
+            Numeric::Float(
+                Float::F16 | Float::F16B | Float::F32 | Float::F64 | Float::X87F80 | Float::F128,
+            ) => RegKind::Float,
         }
     }
 }
@@ -1778,12 +1798,12 @@ impl NumScalableVectors {
         NumScalableVectors(1)
     }
 
-    // Returns `NumScalableVectors` for values of two through eight, which are a valid number of
-    // fields for a tuple of scalable vectors to have. `1` is a valid value of `NumScalableVectors`
-    // but not for a tuple which would have a field count.
+    /// Returns `NumScalableVectors` for values of two through eight, which are a valid number of
+    /// fields for a tuple of scalable vectors to have. `1` is a valid value of `NumScalableVectors`
+    /// but not for a tuple which would have a field count.
     pub fn from_field_count(count: usize) -> Option<Self> {
         match count {
-            2..8 => Some(NumScalableVectors(count as u8)),
+            2..=8 => Some(NumScalableVectors(count as u8)),
             _ => None,
         }
     }

compiler/rustc_ast/src/ast.rs

@@ -3489,6 +3489,7 @@ pub enum GeneratedAttr {
     DocHidden,
     CoverageOff,
     RustcTestMarker(Symbol),
+    RustcTrivialFieldReads,
 }
 
 impl GeneratedAttr {
@@ -3504,6 +3505,7 @@ impl GeneratedAttr {
             GeneratedAttr::RustcTestMarker(test_path) => {
                 format!("#[rustc_test_marker = \"{test_path}\"]")
             }
+            GeneratedAttr::RustcTrivialFieldReads => "#[rustc_trivial_field_reads]".into(),
         }
     }
     pub fn value_span(&self) -> Option<Span> {
@@ -3514,6 +3516,7 @@ impl GeneratedAttr {
             GeneratedAttr::DocHidden => None,
             GeneratedAttr::CoverageOff => None,
             GeneratedAttr::RustcTestMarker(_) => None,
+            GeneratedAttr::RustcTrivialFieldReads => None,
         }
     }
 
@@ -3525,6 +3528,7 @@ impl GeneratedAttr {
             GeneratedAttr::DocHidden => false,
             GeneratedAttr::CoverageOff => false,
             GeneratedAttr::RustcTestMarker(_) => false,
+            GeneratedAttr::RustcTrivialFieldReads => false,
         }
     }
 
@@ -3536,6 +3540,7 @@ impl GeneratedAttr {
             GeneratedAttr::DocHidden => &[sym::doc],
             GeneratedAttr::CoverageOff => &[sym::coverage],
             GeneratedAttr::RustcTestMarker(_) => &[sym::rustc_test_marker],
+            GeneratedAttr::RustcTrivialFieldReads => &[sym::rustc_trivial_field_reads],
         }
     }
 
@@ -3547,6 +3552,7 @@ impl GeneratedAttr {
             GeneratedAttr::DocHidden => None,
             GeneratedAttr::CoverageOff => None,
             GeneratedAttr::RustcTestMarker(_) => None,
+            GeneratedAttr::RustcTrivialFieldReads => None,
         }
     }
 
@@ -3558,6 +3564,7 @@ impl GeneratedAttr {
             GeneratedAttr::DocHidden => false,
             GeneratedAttr::CoverageOff => false,
             GeneratedAttr::RustcTestMarker(_) => false,
+            GeneratedAttr::RustcTrivialFieldReads => false,
         }
     }
     pub fn value_str(&self) -> Option<Symbol> {
@@ -3568,6 +3575,7 @@ impl GeneratedAttr {
             GeneratedAttr::DocHidden => None,
             GeneratedAttr::CoverageOff => None,
             GeneratedAttr::RustcTestMarker(test_path) => Some(*test_path),
+            GeneratedAttr::RustcTrivialFieldReads => None,
         }
     }
 
@@ -3579,6 +3587,7 @@ impl GeneratedAttr {
             GeneratedAttr::DocHidden => None,
             GeneratedAttr::CoverageOff => None,
             GeneratedAttr::RustcTestMarker(_) => None,
+            GeneratedAttr::RustcTrivialFieldReads => None,
         }
     }
 

compiler/rustc_ast_lowering/src/item.rs

@@ -452,13 +452,21 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 let constness = self.lower_constness(attrs, *constness);
                 let impl_restriction = self.lower_impl_restriction(impl_restriction, hir_id);
                 let ident = self.lower_ident(*ident);
+                // FIXME(move_trait): We likely want to not add an implicit `Move` super trait
+                // at which point we shouldn't allow relaxed bounds here. Even if we do, we should
+                // make sure to only allow `?Move`.
+                let policy = if self.tcx.features().move_trait() {
+                    RelaxedBoundPolicy::Allowed(&mut Default::default())
+                } else {
+                    RelaxedBoundPolicy::Forbidden(RelaxedBoundForbiddenReason::SuperTrait)
+                };
                 let (generics, (safety, items, bounds)) = self.lower_generics(
                     generics,
                     ImplTraitContext::Disallowed(ImplTraitPosition::Generic),
                     |this| {
                         let bounds = this.lower_param_bounds(
                             bounds,
-                            RelaxedBoundPolicy::Forbidden(RelaxedBoundForbiddenReason::SuperTrait),
+                            policy,
                             ImplTraitContext::Disallowed(ImplTraitPosition::Bound),
                         );
                         let items = this.arena.alloc_from_iter(

compiler/rustc_ast_passes/src/ast_validation.rs

@@ -25,7 +25,6 @@ use rustc_abi::{CVariadicStatus, CanonAbi, ExternAbi, InterruptKind};
 use rustc_ast::visit::{AssocCtxt, BoundKind, FnCtxt, FnKind, Visitor, walk_list};
 use rustc_ast::*;
 use rustc_ast_pretty::pprust::{self, State};
-use rustc_attr_parsing::validate_attr;
 use rustc_data_structures::fx::FxIndexMap;
 use rustc_errors::{DiagCtxtHandle, Diagnostic, LintBuffer};
 use rustc_feature::Features;
@@ -1402,10 +1401,6 @@ fn validate_generic_param_order(dcx: DiagCtxtHandle<'_>, generics: &[GenericPara
 }
 
 impl Visitor<'_> for AstValidator<'_> {
-    fn visit_attribute(&mut self, attr: &Attribute) {
-        validate_attr::check_attr(&self.sess.psess, attr);
-    }
-
     fn visit_ty(&mut self, ty: &Ty) {
         self.visit_ty_common(ty);
         self.walk_ty(ty)

compiler/rustc_attr_ir/src/data_structures.rs

@@ -1497,7 +1497,7 @@ pub enum AttributeKind {
     RustcThenThisWouldNeed(ThinVec<Ident>),
 
     /// Represents `#[rustc_trivial_field_reads]`
-    RustcTrivialFieldReads,
+    RustcTrivialFieldReads(Span),
 
     /// Represents `#[sanitize]`
     ///

compiler/rustc_attr_ir/src/encode_cross_crate.rs

@@ -198,7 +198,7 @@ impl AttributeKind {
             RustcStrictCoherence(..) => Yes,
             RustcTestMarker(..) => No,
             RustcThenThisWouldNeed(..) => No,
-            RustcTrivialFieldReads => Yes,
+            RustcTrivialFieldReads(..) => No,
             Sanitize { .. } => No,
             ShouldPanic { .. } => No,
             Splat(..) => Yes,
@@ -417,7 +417,7 @@ impl AttributeKind {
             RustcStrictCoherence(..) => false,
             RustcTestMarker(..) => false,
             RustcThenThisWouldNeed(..) => false,
-            RustcTrivialFieldReads => false,
+            RustcTrivialFieldReads(..) => false,
             Sanitize { .. } => false,
             ShouldPanic { .. } => false,
             Splat(..) => false,

compiler/rustc_attr_ir/src/lang_items.rs

@@ -240,6 +240,8 @@ language_item_table! {
 
     Complex,                 sym::complex,             complex,                    Target::Struct,         GenericRequirement::Exact(1);
     PpcF128,                 sym::ppcf128,             ppcf128,                    Target::Struct,         GenericRequirement::None;
+    X87F80,                  sym::x87_f80,             x87_f80,                    Target::Struct,         GenericRequirement::None;
+    X87F80Raw,               sym::x87_f80_raw,         x87_f80_raw,                Target::Struct,         GenericRequirement::None;
 
     Deref,                   kw::Deref,                deref_trait,                Target::Trait,          GenericRequirement::Exact(0);
     DerefMut,                sym::deref_mut,           deref_mut_trait,            Target::Trait,          GenericRequirement::Exact(0);
@@ -280,6 +282,8 @@ language_item_table! {
     Unpin,                   sym::unpin,               unpin_trait,                Target::Trait,          GenericRequirement::None;
     Pin,                     kw::Pin,                  pin_type,                   Target::Struct,         GenericRequirement::None;
 
+    Move,                    sym::move_trait,          move_trait,                 Target::Trait,          GenericRequirement::None;
+
     OrderingEnum,            sym::Ordering,            ordering_enum,              Target::Enum,           GenericRequirement::Exact(0);
     PartialEq,               sym::eq,                  eq_trait,                   Target::Trait,          GenericRequirement::Exact(1);
     PartialOrd,              sym::partial_ord,         partial_ord_trait,          Target::Trait,          GenericRequirement::Exact(1);

compiler/rustc_attr_parsing/src/attributes/rustc_internal.rs

@@ -420,9 +420,13 @@ pub(crate) struct RustcTrivialFieldReadsParser;
 
 impl NoArgsAttributeParser for RustcTrivialFieldReadsParser {
     const PATH: &[Symbol] = &[sym::rustc_trivial_field_reads];
-    const ALLOWED_TARGETS: AllowedTargets<'_> = AllowedTargets::AllowList(&[Allow(Target::Trait)]);
+    const ALLOWED_TARGETS: AllowedTargets<'_> = AllowedTargets::AllowList(&[
+        Allow(Target::Method(MethodKind::TraitImpl)),
+        Allow(Target::Method(MethodKind::Inherent)),
+        Allow(Target::Fn),
+    ]);
     const STABILITY: AttributeStability = unstable!(rustc_attrs);
-    const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::RustcTrivialFieldReads;
+    const CREATE: fn(Span) -> AttributeKind = AttributeKind::RustcTrivialFieldReads;
 }
 
 pub(crate) struct RustcNoMirInlineParser;

compiler/rustc_attr_parsing/src/generated.rs

@@ -42,6 +42,7 @@ impl GeneratedAttrState {
             GeneratedAttr::RustcTestMarker(test_marker) => {
                 AttributeKind::RustcTestMarker(test_marker)
             }
+            GeneratedAttr::RustcTrivialFieldReads => AttributeKind::RustcTrivialFieldReads(span),
         };
         self.state.push(attr);
     }