Rollup of 10 pull requests

Cargo.lock

@@ -5056,6 +5056,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.
     ///

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_llvm/src/context.rs

@@ -584,6 +584,15 @@ pub(crate) unsafe fn create_module<'ll>(
         );
     }
 
+    if llvm_version >= (24, 0, 0) && sess.target.singlethread(&sess.internal_target_features) {
+        llvm::add_module_flag_str(
+            llmod,
+            llvm::ModuleFlagMergeBehavior::Error,
+            "thread-model",
+            "single",
+        );
+    }
+
     // Add module flags specified via -Z llvm_module_flag
     for (key, value, merge_behavior) in &sess.opts.unstable_opts.llvm_module_flag {
         let merge_behavior = match merge_behavior.as_str() {

compiler/rustc_codegen_llvm/src/va_arg.rs

@@ -474,7 +474,19 @@ fn emit_s390x_va_arg<'ll, 'tcx>(
     let padded_size = 8;
     let padding = padded_size - unpadded_size;
 
-    let gpr_type = indirect || !layout.is_single_fp_element(bx.cx);
+    // NOTE: if we ever allow aggregate types, this should handle structs with a single fp element.
+    let is_single_fp_element = |layout: TyAndLayout<'_>| -> bool {
+        match layout.layout.backend_repr() {
+            BackendRepr::Scalar(scalar) => match scalar.primitive() {
+                Primitive::Float(Float::F16 | Float::F32 | Float::F64) => true,
+                Primitive::Float(Float::F128) => false,
+                Primitive::Int(_, _) | Primitive::Pointer(_) => false,
+            },
+            _ => false,
+        }
+    };
+
+    let gpr_type = indirect || !is_single_fp_element(layout);
     let (max_regs, reg_count, reg_save_index, reg_padding) =
         if gpr_type { (5, gpr, 2, padding) } else { (4, fpr, 16, 0) };
 

compiler/rustc_data_structures/src/flock.rs

@@ -21,7 +21,7 @@ pub enum Lock {
 }
 
 impl Lock {
-    pub fn new(p: &Path, wait: bool, create: bool, exclusive: bool) -> io::Result<Lock> {
+    pub fn try_lock(p: &Path, create: bool, exclusive: bool) -> io::Result<Lock> {
         let mut open_options = OpenOptions::new();
         open_options.read(true).write(true).create(create);
         #[cfg(unix)]
@@ -32,17 +32,16 @@ impl Lock {
 
         let file = open_options.open(p)?;
 
-        let res = match (wait, exclusive) {
-            (true, true) => file.lock(),
-            (true, false) => file.lock_shared(),
-            (false, true) => file.try_lock().map_err(io::Error::from),
-            (false, false) => file.try_lock_shared().map_err(io::Error::from),
+        let res = if exclusive {
+            file.try_lock().map_err(io::Error::from)
+        } else {
+            file.try_lock_shared().map_err(io::Error::from)
         };
 
         match res {
             Ok(()) => Ok(Lock::FdLocked { _file: file }),
             Err(err) if matches!(err.kind(), io::ErrorKind::Unsupported) => {
-                Ok(Lock::Fallback(fallback::Lock::new(p, wait, create, exclusive)?))
+                Ok(Lock::Fallback(fallback::Lock::try_lock(p, file, exclusive)?))
             }
             Err(err) => Err(err),
         }