Rollup of 10 pull requests

Cargo.lock

@@ -5055,6 +5055,7 @@ dependencies = [
  "expect-test",
  "indexmap",
  "itertools",
+ "libc",
  "minifier",
  "proc-macro2",
  "pulldown-cmark-escape",

compiler/rustc_abi/src/callconv/reg.rs

@@ -47,6 +47,7 @@ impl Reg {
     reg_ctor!(i64, Integer, 64);
     reg_ctor!(i128, Integer, 128);
 
+    reg_ctor!(f16, Float, 16);
     reg_ctor!(f32, Float, 32);
     reg_ctor!(f64, Float, 64);
     reg_ctor!(f128, Float, 128);

compiler/rustc_abi/src/layout/ty.rs

@@ -156,26 +156,6 @@ impl<'a, Ty> TyAndLayout<'a, Ty> {
         Ty::ty_and_layout_pointee_info_at(self, cx, offset)
     }
 
-    pub fn is_single_fp_element<C>(self, cx: &C) -> bool
-    where
-        Ty: TyAbiInterface<'a, C>,
-        C: HasDataLayout,
-    {
-        match self.backend_repr {
-            BackendRepr::Scalar(scalar) => {
-                matches!(scalar.primitive(), Primitive::Float(Float::F32 | Float::F64))
-            }
-            BackendRepr::Memory { .. } => {
-                if self.fields.count() == 1 && self.fields.offset(0).bytes() == 0 {
-                    self.field(cx, 0).is_single_fp_element(cx)
-                } else {
-                    false
-                }
-            }
-            _ => false,
-        }
-    }
-
     pub fn is_single_vector_element<C>(self, cx: &C, expected_size: Size) -> bool
     where
         Ty: TyAbiInterface<'a, C>,
@@ -309,6 +289,29 @@ impl<'a, Ty> TyAndLayout<'a, Ty> {
         found
     }
 
+    /// Finds the one field that is not a ZST.
+    /// Returns `None` if there are multiple non-ZST fields or only ZST-fields.
+    ///
+    /// Note that this function checks for ZSTs, not just 1-ZSTs.
+    pub fn non_zst_field_ignore_alignment<C>(&self, cx: &C) -> Option<(FieldIdx, Self)>
+    where
+        Ty: TyAbiInterface<'a, C> + Copy,
+    {
+        let mut found = None;
+        for field_idx in 0..self.fields.count() {
+            let field = self.field(cx, field_idx);
+            if field.is_zst() {
+                continue;
+            }
+            if found.is_some() {
+                // More than one non-ZST field.
+                return None;
+            }
+            found = Some((FieldIdx::from_usize(field_idx), field));
+        }
+        found
+    }
+
     /// If this type should match the ABI of the C `_Complex` type, returns the primitive that is
     /// used for its components.
     ///
@@ -339,7 +342,7 @@ impl<'a, Ty> TyAndLayout<'a, Ty> {
             Primitive::Float(float @ (Float::F16 | Float::F32 | Float::F64 | Float::F128)) => {
                 Some(Numeric::Float(float))
             }
-            Primitive::Pointer(..) => None,
+            Primitive::Pointer(..) | Primitive::Float(Float::F16B) => None,
         }
     }
 

compiler/rustc_abi/src/lib.rs

@@ -1420,6 +1420,10 @@ impl Integer {
 #[cfg_attr(feature = "nightly", derive(StableHash))]
 pub enum Float {
     F16,
+    /// `f16b`. 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.
+    F16B,
     F32,
     F64,
     F128,
@@ -1431,6 +1435,7 @@ impl Float {
 
         match self {
             F16 => Size::from_bits(16),
+            F16B => Size::from_bits(16),
             F32 => Size::from_bits(32),
             F64 => Size::from_bits(64),
             F128 => Size::from_bits(128),
@@ -1442,7 +1447,7 @@ impl Float {
         let dl = cx.data_layout();
 
         AbiAlign::new(match self {
-            F16 => dl.f16_align,
+            F16 | F16B => dl.f16_align,
             F32 => dl.f32_align,
             F64 => dl.f64_align,
             F128 => dl.f128_align,
@@ -1454,6 +1459,7 @@ impl Float {
 
         match self {
             F16 => "f16",
+            F16B => "f16b",
             F32 => "f32",
             F64 => "f64",
             F128 => "f128",

compiler/rustc_attr_ir/src/lang_items.rs

@@ -281,6 +281,7 @@ language_item_table! {
     PartialEq,               sym::eq,                  eq_trait,                   Target::Trait,          GenericRequirement::Exact(1);
     PartialOrd,              sym::partial_ord,         partial_ord_trait,          Target::Trait,          GenericRequirement::Exact(1);
     CVoid,                   sym::c_void,              c_void,                     Target::Enum,           GenericRequirement::None;
+    F16B,                    sym::f16b,                f16b,                       Target::Struct,         GenericRequirement::Exact(0);
 
     Type,                    sym::type_info,           type_struct,                Target::Struct,         GenericRequirement::None;
     TypeGeneric,             sym::type_info_generic,   type_generic,               Target::Enum,         GenericRequirement::None;

compiler/rustc_attr_parsing/src/attributes/cfi_encoding.rs

@@ -4,7 +4,7 @@ use super::prelude::*;
 pub(crate) struct CfiEncodingParser;
 impl SingleAttributeParser for CfiEncodingParser {
     const PATH: &[Symbol] = &[sym::cfi_encoding];
-    const ALLOWED_TARGETS: AllowedTargets<'_> = AllowedTargets::AllowListWarnRest(&[
+    const ALLOWED_TARGETS: AllowedTargets<'_> = AllowedTargets::AllowList(&[
         Allow(Target::Struct),
         Allow(Target::ForeignTy),
         Allow(Target::Enum),

compiler/rustc_borrowck/src/diagnostics/mod.rs

@@ -74,20 +74,6 @@ pub(super) struct DescribePlaceOpt {
 
 pub(super) struct IncludingTupleField(pub(super) bool);
 
-pub(crate) enum BufferedDiag<'diag> {
-    Error(Diag<'diag>),
-    NonError(Diag<'diag, ()>),
-}
-
-impl<'diag> BufferedDiag<'diag> {
-    fn sort_span(&self) -> Span {
-        match self {
-            BufferedDiag::Error(diag) => diag.sort_span,
-            BufferedDiag::NonError(diag) => diag.sort_span,
-        }
-    }
-}
-
 #[derive(Default)]
 pub(crate) struct BorrowckDiagnosticsBuffer<'diag, 'tcx> {
     /// This field keeps track of move errors that are to be reported for given move indices.
@@ -108,16 +94,13 @@ pub(crate) struct BorrowckDiagnosticsBuffer<'diag, 'tcx> {
 
     buffered_mut_errors: FxIndexMap<Span, (Diag<'diag>, usize)>,
 
-    /// Buffer of diagnostics to be reported. A mixture of error and non-error diagnostics.
-    buffered_diags: Vec<BufferedDiag<'diag>>,
+    /// Buffer of diagnostics to be reported.
+    buffered_diags: Vec<Diag<'diag>>,
 }
 
 impl<'diag, 'tcx> BorrowckDiagnosticsBuffer<'diag, 'tcx> {
-    pub(crate) fn buffer_non_error(&mut self, diag: Diag<'diag, ()>) {
-        self.buffered_diags.push(BufferedDiag::NonError(diag));
-    }
     pub(crate) fn buffer_error(&mut self, diag: Diag<'diag>) {
-        self.buffered_diags.push(BufferedDiag::Error(diag));
+        self.buffered_diags.push(diag);
     }
 
     pub(crate) fn emit_errors(&mut self) {
@@ -134,14 +117,9 @@ impl<'diag, 'tcx> BorrowckDiagnosticsBuffer<'diag, 'tcx> {
         }
 
         if !self.buffered_diags.is_empty() {
-            self.buffered_diags.sort_by_key(|buffered_diag| buffered_diag.sort_span());
-            for buffered_diag in self.buffered_diags.drain(..) {
-                match buffered_diag {
-                    BufferedDiag::Error(diag) => {
-                        diag.emit();
-                    }
-                    BufferedDiag::NonError(diag) => diag.emit(),
-                }
+            self.buffered_diags.sort_by_key(|diag| diag.sort_span);
+            for diag in self.buffered_diags.drain(..) {
+                diag.emit();
             }
         }
     }
@@ -152,10 +130,6 @@ impl<'diag, 'tcx> MirBorrowckCtxt<'_, 'diag, 'tcx> {
         self.diags_buffer.buffer_error(diag.with_dcx(self.dcx()));
     }
 
-    pub(crate) fn buffer_non_error(&mut self, diag: Diag<'_, ()>) {
-        self.diags_buffer.buffer_non_error(diag.with_dcx(self.dcx()));
-    }
-
     pub(crate) fn buffer_move_error(
         &mut self,
         move_out_indices: Vec<MoveOutIndex>,

compiler/rustc_borrowck/src/diagnostics/outlives_suggestion.rs

@@ -14,9 +14,6 @@ use crate::MirBorrowckCtxt;
 
 /// The different things we could suggest.
 enum SuggestedConstraint {
-    /// Outlives(a, [b, c, d, ...]) => 'a: 'b + 'c + 'd + ...
-    Outlives(RegionName, SmallVec<[RegionName; 2]>),
-
     /// 'a = 'b
     Equal(RegionName, RegionName),
 
@@ -106,11 +103,10 @@ impl OutlivesSuggestionBuilder {
                 continue;
             }
 
-            // There are three types of suggestions we can make:
-            // 1) Suggest a bound: 'a: 'b
-            // 2) Suggest replacing 'a with 'static. If any of `outlived` is `'static`, then we
+            // There are two types of suggestions we can make:
+            // 1) Suggest replacing 'a with 'static. If any of `outlived` is `'static`, then we
             //    should just replace 'a with 'static.
-            // 3) Suggest unifying 'a with 'b if we have both 'a: 'b and 'b: 'a
+            // 2) Suggest unifying 'a with 'b if we have both 'a: 'b and 'b: 'a
 
             if outlived
                 .iter()
@@ -121,7 +117,7 @@ impl OutlivesSuggestionBuilder {
                 // We want to isolate out all lifetimes that should be unified and print out
                 // separate messages for them.
 
-                let (unified, other): (Vec<_>, Vec<_>) = outlived.into_iter().partition(
+                let unified = outlived.into_iter().filter(
                     // Do we have both 'fr: 'r and 'r: 'fr?
                     |(r, _)| {
                         self.constraints_to_add
@@ -130,17 +126,12 @@ impl OutlivesSuggestionBuilder {
                     },
                 );
 
-                for (r, bound) in unified.into_iter() {
+                for (r, bound) in unified {
                     if !unified_already.contains(fr) {
                         suggested.push(SuggestedConstraint::Equal(fr_name, bound));
                         unified_already.insert(r);
                     }
                 }
-
-                if !other.is_empty() {
-                    let other = other.iter().map(|(_, rname)| *rname).collect::<SmallVec<_>>();
-                    suggested.push(SuggestedConstraint::Outlives(fr_name, other))
-                }
             }
         }
 
@@ -202,54 +193,36 @@ impl OutlivesSuggestionBuilder {
             return;
         }
 
-        // If there is exactly one suggestable constraints, then just suggest it. Otherwise, emit a
-        // list of diagnostics.
-        let mut diag = if let [constraint] = suggested.as_slice() {
-            mbcx.dcx().struct_help(match constraint {
-                SuggestedConstraint::Outlives(a, bs) => {
-                    let bs: SmallVec<[String; 2]> = bs.iter().map(|r| r.to_string()).collect();
-                    format!("add bound `{a}: {}`", bs.join(" + "))
-                }
-
+        // Emit an error with a list of one or more help suggestions. This is a weird error because
+        // it's just there to provide somewhere to put the help suggestions that describe how to
+        // fix the one or more borrow errors already reported within the item.
+        let tcx = mbcx.infcx.tcx;
+        let def_id = mbcx.mir_def_id();
+        let span = tcx.def_ident_span(def_id).unwrap_or_else(|| tcx.def_span(def_id));
+        let mut diag = tcx
+            .dcx()
+            .struct_err("one or more lifetime errors were found in this item")
+            .with_span(span);
+
+        // Add suggestions.
+        for constraint in suggested {
+            match constraint {
                 SuggestedConstraint::Equal(a, b) => {
-                    format!("`{a}` and `{b}` must be the same: replace one with the other")
+                    diag.help(format!(
+                        "`{a}` and `{b}` must be the same: replace one with the other",
+                    ));
                 }
-                SuggestedConstraint::Static(a) => format!("replace `{a}` with `'static`"),
-            })
-        } else {
-            // Create a new diagnostic.
-            let mut diag = mbcx
-                .infcx
-                .tcx
-                .dcx()
-                .struct_help("the following changes may resolve your lifetime errors");
-
-            // Add suggestions.
-            for constraint in suggested {
-                match constraint {
-                    SuggestedConstraint::Outlives(a, bs) => {
-                        let bs: SmallVec<[String; 2]> = bs.iter().map(|r| r.to_string()).collect();
-                        diag.help(format!("add bound `{a}: {}`", bs.join(" + ")));
-                    }
-                    SuggestedConstraint::Equal(a, b) => {
-                        diag.help(format!(
-                            "`{a}` and `{b}` must be the same: replace one with the other",
-                        ));
-                    }
-                    SuggestedConstraint::Static(a) => {
-                        diag.help(format!("replace `{a}` with `'static`"));
-                    }
+                SuggestedConstraint::Static(a) => {
+                    diag.help(format!("replace `{a}` with `'static`"));
                 }
             }
-
-            diag
-        };
+        }
 
         // We want this message to appear after other messages on the mir def.
         let mir_span = mbcx.body.span;
         diag.sort_span = mir_span.shrink_to_hi();
 
         // Buffer the diagnostic
-        mbcx.buffer_non_error(diag);
+        mbcx.buffer_error(diag);
     }
 }

compiler/rustc_codegen_cranelift/src/common.rs

@@ -35,6 +35,7 @@ pub(crate) fn scalar_to_clif_type(tcx: TyCtxt<'_>, scalar: Scalar) -> Type {
         },
         Primitive::Float(float) => match float {
             Float::F16 => types::F16,
+            Float::F16B => bug!("f16b is not supported by the Cranelift codegen backend"),
             Float::F32 => types::F32,
             Float::F64 => types::F64,
             Float::F128 => types::F128,

compiler/rustc_codegen_cranelift/src/lib.rs

@@ -196,6 +196,7 @@ impl CodegenBackend for CraneliftCodegenBackend {
             // available in Cranelift.
             has_reliable_f16: has_reliable_f16_f128,
             has_reliable_f16_math: has_reliable_f16_f128,
+            has_reliable_f16b: false,
             has_reliable_f128: has_reliable_f16_f128,
             has_reliable_f128_math,
         }

compiler/rustc_codegen_gcc/src/base.rs

@@ -214,6 +214,7 @@ pub fn compile_codegen_unit(
             // -fsyntax-only), forbid the compilation when get_target_info() is called on a
             // context.
             let f16_type_supported = target_info.supports_target_dependent_type(CType::Float16);
+            let f16b_type_supported = target_info.supports_target_dependent_type(CType::BFloat16);
             let f32_type_supported = target_info.supports_target_dependent_type(CType::Float32);
             let f64_type_supported = target_info.supports_target_dependent_type(CType::Float64);
             let f128_type_supported = target_info.supports_target_dependent_type(CType::Float128);
@@ -225,6 +226,7 @@ pub fn compile_codegen_unit(
                 tcx,
                 u128_type_supported,
                 f16_type_supported,
+                f16b_type_supported,
                 f32_type_supported,
                 f64_type_supported,
                 f128_type_supported,

compiler/rustc_codegen_gcc/src/context.rs

@@ -72,6 +72,7 @@ pub struct CodegenCx<'gcc, 'tcx> {
 
     pub supports_128bit_integers: bool,
     pub supports_f16_type: bool,
+    pub supports_f16b_type: bool,
     pub supports_f32_type: bool,
     pub supports_f64_type: bool,
     pub supports_f128_type: bool,
@@ -140,6 +141,7 @@ impl<'gcc, 'tcx> CodegenCx<'gcc, 'tcx> {
         tcx: TyCtxt<'tcx>,
         supports_128bit_integers: bool,
         supports_f16_type: bool,
+        supports_f16b_type: bool,
         supports_f32_type: bool,
         supports_f64_type: bool,
         supports_f128_type: bool,
@@ -276,6 +278,7 @@ impl<'gcc, 'tcx> CodegenCx<'gcc, 'tcx> {
 
             supports_128bit_integers,
             supports_f16_type,
+            supports_f16b_type,
             supports_f32_type,
             supports_f64_type,
             supports_f128_type,