Rollup of 9 pull requests

.mailmap

@@ -9,7 +9,7 @@ Aaron Todd <[email protected]>
 Abhishek Chanda <[email protected]> Abhishek Chanda <[email protected]>
 Abhijeet Bhagat <[email protected]>
 Abroskin Alexander <[email protected]>
-Adolfo Ochagavía <[email protected]>
+Adolfo Ochagavía <[email protected]> <[email protected]>
 Adrian Heine né Lang <[email protected]>
 Adrien Tétar <[email protected]>
 Ahmed Charles <[email protected]> <[email protected]>
@@ -36,6 +36,7 @@ Amanda Stjerna <[email protected]> <[email protected]>
 Amanda Stjerna <[email protected]> <[email protected]>
 Amanieu d'Antras <[email protected]> <[email protected]>
 Amos Onn <[email protected]>
+Amos Wenger <[email protected]> <[email protected]>
 Ana-Maria Mihalache <[email protected]>
 Anatoly Ikorsky <[email protected]>
 Andre Bogus <[email protected]>
@@ -276,7 +277,8 @@ Irina Popa <[email protected]>
 Ivan Ivaschenko <[email protected]>
 ivan tkachenko <[email protected]>
 J. J. Weber <[email protected]>
-Jack Huey <[email protected]> <[email protected]>
+Jack Huey <[email protected]> <[email protected]>
+Jack Huey <[email protected]> <[email protected]>
 Jacob <[email protected]>
 Jacob Hoffman-Andrews <[email protected]> <[email protected]>
 Jacob Greenfield <[email protected]>
@@ -292,6 +294,8 @@ Jakub Adam Wieczorek <[email protected]>
 Jakub Adam Wieczorek <[email protected]> <[email protected]>
 Jakub Adam Wieczorek <[email protected]> <[email protected]>
 Jakub Adam Wieczorek <[email protected]> <[email protected]>
+Jakub Adam Wieczorek <[email protected]> <[email protected]>
+Jakub Adam Wieczorek <[email protected]> <[email protected]>
 Jakub Beránek <[email protected]> <[email protected]>
 James [Undefined] <[email protected]>
 James Deng <[email protected]> <[email protected]>
@@ -303,6 +307,7 @@ Jamie Hill-Daniel <[email protected]> <[email protected]>
 Jana Dönszelmann <[email protected]>
 Jana Dönszelmann <[email protected]> <[email protected]>
 Jana Dönszelmann <[email protected]> <[email protected]>
+Jane Lusby <[email protected]> <[email protected]>
 Jan-Erik Rediger <[email protected]> <[email protected]>
 Jaro Fietz <[email protected]>
 Jason Fager <[email protected]>
@@ -313,6 +318,7 @@ Jason Toffaletti <[email protected]> Jason Toffaletti <[email protected]>
 Jauhien Piatlicki <[email protected]> Jauhien Piatlicki <[email protected]>
 Jay True <[email protected]>
 Jeremy Letang <[email protected]>
+Jeremy Soller <[email protected]> <[email protected]>
 Jeremy Sorensen <[email protected]>
 Jeremy Stucki <[email protected]> <[email protected]>
 Jeremy Stucki <[email protected]> <[email protected]>
@@ -336,6 +342,7 @@ John Kåre Alsaker <[email protected]>
 John Kåre Alsaker <[email protected]> <[email protected]>
 John Talling <[email protected]>
 John Van Enk <[email protected]>
+Jon Gjengset <[email protected]> <[email protected]>
 Jonas Tepe <[email protected]>
 Jonathan Bailey <[email protected]> <[email protected]>
 Jonathan Chan Kwan Yin <[email protected]>
@@ -424,7 +431,7 @@ Malo Jaffré <[email protected]>
 Manish Goregaokar <[email protected]>
 Mara Bos <[email protected]>
 Marcell Pardavi <[email protected]>
-Marco Ieni <[email protected]>
+Marco Ieni <[email protected]> <[email protected]>
 Marcus Klaas de Vries <[email protected]>
 Margaret Meyerhofer <[email protected]> <mmeyerho@andrew>
 Marijn Schouten <[email protected]> <[email protected]>
@@ -531,6 +538,7 @@ Oliver Scherer <[email protected]> <[email protected]>
 Oliver Scherer <[email protected]> <[email protected]>
 Oliver Scherer <[email protected]> <[email protected]>
 Oliver Scherer <[email protected]>
+Onur Özkan <[email protected]> <[email protected]>
 Onur Özkan <[email protected]> <[email protected]>
 Onur Özkan <[email protected]>
 Ömer Sinan Ağacan <[email protected]>
@@ -591,6 +599,7 @@ Rusty Blitzerr <[email protected]>
 RustyYato <[email protected]>
 Ruud van Asseldonk <[email protected]> Ruud van Asseldonk <[email protected]>
 Ryan Leung <[email protected]>
+Ryan Levick <[email protected]> <[email protected]>
 Ryan Scheel <[email protected]>
 Ryan Sullivant <[email protected]>
 Ryan Wiedemann <[email protected]>
@@ -686,6 +695,8 @@ Weihang Lo <[email protected]>
 Weihang Lo <[email protected]> <[email protected]>
 Wesley Wiser <[email protected]> <[email protected]>
 whitequark <[email protected]>
+Will Crichton <[email protected]> <[email protected]>
+Will Crichton <[email protected]> <[email protected]>
 William Ting <[email protected]> <[email protected]>
 Wim Looman <[email protected]> <[email protected]>
 Wim Looman <[email protected]> <[email protected]>
@@ -695,6 +706,8 @@ Xinye Tao <[email protected]>
 Xuefeng Wu <[email protected]> Xuefeng Wu <[email protected]>
 Xuefeng Wu <[email protected]> XuefengWu <[email protected]>
 York Xiang <[email protected]>
+Yoshua Wuyts <[email protected]> <[email protected]>
+Yoshua Wuyts <[email protected]> <[email protected]>
 Yotam Ofek <[email protected]> <[email protected]>
 Youngsoo Son <[email protected]> <[email protected]>
 Youngsuk Kim <[email protected]>

compiler/rustc_builtin_macros/src/test.rs

@@ -207,30 +207,30 @@ pub(crate) fn expand_test_or_bench(
     };
 
     let test_fn = if is_bench {
-        // A simple ident for a lambda
-        let b = Ident::from_str_and_span("b", attr_sp);
-
+        // avoid name collisions by using the function name within the identifier, see bug #148275
+        let bencher_param =
+            Ident::from_str_and_span(&format!("__bench_{}", fn_.ident.name), attr_sp);
         cx.expr_call(
             sp,
             cx.expr_path(test_path("StaticBenchFn")),
             thin_vec![
                 // #[coverage(off)]
-                // |b| self::test::assert_test_result(
+                // |__bench_fn_name| self::test::assert_test_result(
                 coverage_off(cx.lambda1(
                     sp,
                     cx.expr_call(
                         sp,
                         cx.expr_path(test_path("assert_test_result")),
                         thin_vec![
-                            // super::$test_fn(b)
+                            // super::$test_fn(__bench_fn_name)
                             cx.expr_call(
                                 ret_ty_sp,
                                 cx.expr_path(cx.path(sp, vec![fn_.ident])),
-                                thin_vec![cx.expr_ident(sp, b)],
+                                thin_vec![cx.expr_ident(sp, bencher_param)],
                             ),
                         ],
                     ),
-                    b,
+                    bencher_param,
                 )), // )
             ],
         )

compiler/rustc_const_eval/src/util/alignment.rs

@@ -1,24 +1,24 @@
 use rustc_abi::Align;
 use rustc_middle::mir::*;
-use rustc_middle::ty::{self, TyCtxt};
+use rustc_middle::ty::{self, AdtDef, TyCtxt};
 use tracing::debug;
 
-/// Returns `true` if this place is allowed to be less aligned
-/// than its containing struct (because it is within a packed
-/// struct).
-pub fn is_disaligned<'tcx, L>(
+/// If the place may be less aligned than its type requires
+/// (because it is in a packed type), returns the AdtDef
+/// and packed alignment of its most-unaligned projection.
+pub fn place_unalignment<'tcx, L>(
     tcx: TyCtxt<'tcx>,
     local_decls: &L,
     typing_env: ty::TypingEnv<'tcx>,
     place: Place<'tcx>,
-) -> bool
+) -> Option<(AdtDef<'tcx>, Align)>
 where
     L: HasLocalDecls<'tcx>,
 {
-    debug!("is_disaligned({:?})", place);
-    let Some(pack) = is_within_packed(tcx, local_decls, place) else {
-        debug!("is_disaligned({:?}) - not within packed", place);
-        return false;
+    debug!("unalignment({:?})", place);
+    let Some((descr, pack)) = most_packed_projection(tcx, local_decls, place) else {
+        debug!("unalignment({:?}) - not within packed", place);
+        return None;
     };
 
     let ty = place.ty(local_decls, tcx).ty;
@@ -30,31 +30,34 @@ where
                     || matches!(unsized_tail().kind(), ty::Slice(..) | ty::Str)) =>
         {
             // If the packed alignment is greater or equal to the field alignment, the type won't be
-            // further disaligned.
+            // further unaligned.
             // However we need to ensure the field is sized; for unsized fields, `layout.align` is
             // just an approximation -- except when the unsized tail is a slice, where the alignment
             // is fully determined by the type.
             debug!(
-                "is_disaligned({:?}) - align = {}, packed = {}; not disaligned",
+                "unalignment({:?}) - align = {}, packed = {}; not unaligned",
                 place,
                 layout.align.bytes(),
                 pack.bytes()
             );
-            false
+            None
         }
         _ => {
-            // We cannot figure out the layout. Conservatively assume that this is disaligned.
-            debug!("is_disaligned({:?}) - true", place);
-            true
+            // We cannot figure out the layout. Conservatively assume that this is unaligned.
+            debug!("unalignment({:?}) - unaligned", place);
+            Some((descr, pack))
         }
     }
 }
 
-pub fn is_within_packed<'tcx, L>(
+/// If the place includes a projection from a packed struct,
+/// returns the AdtDef and packed alignment of the projection
+/// with the lowest pack
+pub fn most_packed_projection<'tcx, L>(
     tcx: TyCtxt<'tcx>,
     local_decls: &L,
     place: Place<'tcx>,
-) -> Option<Align>
+) -> Option<(AdtDef<'tcx>, Align)>
 where
     L: HasLocalDecls<'tcx>,
 {
@@ -65,9 +68,11 @@ where
         .take_while(|(_base, elem)| !matches!(elem, ProjectionElem::Deref))
         // Consider the packed alignments at play here...
         .filter_map(|(base, _elem)| {
-            base.ty(local_decls, tcx).ty.ty_adt_def().and_then(|adt| adt.repr().pack)
+            let adt = base.ty(local_decls, tcx).ty.ty_adt_def()?;
+            let pack = adt.repr().pack?;
+            Some((adt, pack))
         })
         // ... and compute their minimum.
         // The overall smallest alignment is what matters.
-        .min()
+        .min_by_key(|(_, align)| *align)
 }

compiler/rustc_const_eval/src/util/mod.rs

@@ -6,7 +6,7 @@ mod check_validity_requirement;
 mod compare_types;
 mod type_name;
 
-pub use self::alignment::{is_disaligned, is_within_packed};
+pub use self::alignment::{most_packed_projection, place_unalignment};
 pub use self::check_validity_requirement::check_validity_requirement;
 pub(crate) use self::check_validity_requirement::validate_scalar_in_layout;
 pub use self::compare_types::{relate_types, sub_types};

compiler/rustc_lint/src/types.rs

@@ -1022,7 +1022,8 @@ declare_lint! {
     ///
     /// - Passing `Ordering::Release` or `Ordering::AcqRel` as the failure
     ///   ordering for any of `AtomicType::compare_exchange`,
-    ///   `AtomicType::compare_exchange_weak`, or `AtomicType::fetch_update`.
+    ///   `AtomicType::compare_exchange_weak`, `AtomicType::update`, or
+    ///   `AtomicType::try_update`.
     INVALID_ATOMIC_ORDERING,
     Deny,
     "usage of invalid atomic ordering in atomic operations and memory fences"
@@ -1118,13 +1119,19 @@ impl InvalidAtomicOrdering {
         let Some((method, args)) = Self::inherent_atomic_method_call(
             cx,
             expr,
-            &[sym::fetch_update, sym::compare_exchange, sym::compare_exchange_weak],
+            &[
+                sym::update,
+                sym::try_update,
+                sym::fetch_update,
+                sym::compare_exchange,
+                sym::compare_exchange_weak,
+            ],
         ) else {
             return;
         };
 
         let fail_order_arg = match method {
-            sym::fetch_update => &args[1],
+            sym::update | sym::try_update | sym::fetch_update => &args[1],
             sym::compare_exchange | sym::compare_exchange_weak => &args[3],
             _ => return,
         };

compiler/rustc_mir_transform/messages.ftl

@@ -69,8 +69,11 @@ mir_transform_tail_expr_local = {$is_generated_name ->
         *[false] `{$name}` calls a custom destructor
     }
 
-mir_transform_unaligned_packed_ref = reference to packed field is unaligned
-    .note = packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
+mir_transform_unaligned_packed_ref = reference to field of packed {$ty_descr} is unaligned
+    .note = this {$ty_descr} is {$align ->
+        [one] {""}
+        *[other] {"at most "}
+    }{$align}-byte aligned, but the type of this field may require higher alignment
     .note_ub = creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
     .help = copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
 

compiler/rustc_mir_transform/src/add_moves_for_packed_drops.rs

@@ -51,7 +51,7 @@ impl<'tcx> crate::MirPass<'tcx> for AddMovesForPackedDrops {
 
             match terminator.kind {
                 TerminatorKind::Drop { place, .. }
-                    if util::is_disaligned(tcx, body, typing_env, place) =>
+                    if util::place_unalignment(tcx, body, typing_env, place).is_some() =>
                 {
                     add_move_for_packed_drop(
                         tcx,

compiler/rustc_mir_transform/src/check_packed_ref.rs

@@ -37,7 +37,9 @@ impl<'tcx> Visitor<'tcx> for PackedRefChecker<'_, 'tcx> {
     }
 
     fn visit_place(&mut self, place: &Place<'tcx>, context: PlaceContext, _location: Location) {
-        if context.is_borrow() && util::is_disaligned(self.tcx, self.body, self.typing_env, *place)
+        if context.is_borrow()
+            && let Some((adt, pack)) =
+                util::place_unalignment(self.tcx, self.body, self.typing_env, *place)
         {
             let def_id = self.body.source.instance.def_id();
             if let Some(impl_def_id) = self.tcx.trait_impl_of_assoc(def_id)
@@ -48,7 +50,11 @@ impl<'tcx> Visitor<'tcx> for PackedRefChecker<'_, 'tcx> {
                 // shouldn't do.
                 span_bug!(self.source_info.span, "builtin derive created an unaligned reference");
             } else {
-                self.tcx.dcx().emit_err(errors::UnalignedPackedRef { span: self.source_info.span });
+                self.tcx.dcx().emit_err(errors::UnalignedPackedRef {
+                    span: self.source_info.span,
+                    ty_descr: adt.descr(),
+                    align: pack.bytes(),
+                });
             }
         }
     }

compiler/rustc_mir_transform/src/dead_store_elimination.rs

@@ -23,7 +23,7 @@ use rustc_mir_dataflow::impls::{
 };
 
 use crate::simplify::UsedInStmtLocals;
-use crate::util::is_within_packed;
+use crate::util::most_packed_projection;
 
 /// Performs the optimization on the body
 ///
@@ -65,7 +65,7 @@ fn eliminate<'tcx>(tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) -> bool {
                     // the move may be codegened as a pointer to that field.
                     // Using that disaligned pointer may trigger UB in the callee,
                     // so do nothing.
-                    && is_within_packed(tcx, body, place).is_none()
+                    && most_packed_projection(tcx, body, place).is_none()
                 {
                     call_operands_to_move.push((bb, index));
                 }

compiler/rustc_mir_transform/src/errors.rs

@@ -99,6 +99,8 @@ pub(crate) enum ConstMutate {
 pub(crate) struct UnalignedPackedRef {
     #[primary_span]
     pub span: Span,
+    pub ty_descr: &'static str,
+    pub align: u64,
 }
 
 #[derive(Diagnostic)]

compiler/rustc_mir_transform/src/validate.rs

@@ -20,7 +20,7 @@ use rustc_middle::{bug, span_bug};
 use rustc_mir_dataflow::debuginfo::debuginfo_locals;
 use rustc_trait_selection::traits::ObligationCtxt;
 
-use crate::util::{self, is_within_packed};
+use crate::util::{self, most_packed_projection};
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
 enum EdgeKind {
@@ -409,7 +409,9 @@ impl<'a, 'tcx> Visitor<'tcx> for CfgChecker<'a, 'tcx> {
 
                     // The call destination place and Operand::Move place used as an argument might
                     // be passed by a reference to the callee. Consequently they cannot be packed.
-                    if is_within_packed(self.tcx, &self.body.local_decls, destination).is_some() {
+                    if most_packed_projection(self.tcx, &self.body.local_decls, destination)
+                        .is_some()
+                    {
                         // This is bad! The callee will expect the memory to be aligned.
                         self.fail(
                             location,
@@ -423,7 +425,9 @@ impl<'a, 'tcx> Visitor<'tcx> for CfgChecker<'a, 'tcx> {
 
                 for arg in args {
                     if let Operand::Move(place) = &arg.node {
-                        if is_within_packed(self.tcx, &self.body.local_decls, *place).is_some() {
+                        if most_packed_projection(self.tcx, &self.body.local_decls, *place)
+                            .is_some()
+                        {
                             // This is bad! The callee will expect the memory to be aligned.
                             self.fail(
                                 location,