Rollup of 10 pull requests

compiler/rustc_attr_parsing/src/attributes/diagnostic/mod.rs

@@ -25,6 +25,7 @@ pub(crate) mod on_const;
 pub(crate) mod on_move;
 pub(crate) mod on_unimplemented;
 pub(crate) mod on_unknown;
+pub(crate) mod on_unmatch_args;
 
 #[derive(Copy, Clone)]
 pub(crate) enum Mode {
@@ -38,6 +39,8 @@ pub(crate) enum Mode {
     DiagnosticOnMove,
     /// `#[diagnostic::on_unknown]`
     DiagnosticOnUnknown,
+    /// `#[diagnostic::on_unmatch_args]`
+    DiagnosticOnUnmatchArgs,
 }
 
 impl Mode {
@@ -48,6 +51,7 @@ impl Mode {
             Self::DiagnosticOnConst => "diagnostic::on_const",
             Self::DiagnosticOnMove => "diagnostic::on_move",
             Self::DiagnosticOnUnknown => "diagnostic::on_unknown",
+            Self::DiagnosticOnUnmatchArgs => "diagnostic::on_unmatch_args",
         }
     }
 
@@ -62,6 +66,7 @@ impl Mode {
             Self::DiagnosticOnConst => DEFAULT,
             Self::DiagnosticOnMove => DEFAULT,
             Self::DiagnosticOnUnknown => DEFAULT,
+            Self::DiagnosticOnUnmatchArgs => DEFAULT,
         }
     }
 
@@ -75,6 +80,7 @@ impl Mode {
             Self::DiagnosticOnConst => DEFAULT,
             Self::DiagnosticOnMove => DEFAULT,
             Self::DiagnosticOnUnknown => DEFAULT,
+            Self::DiagnosticOnUnmatchArgs => DEFAULT,
         }
     }
 }
@@ -398,7 +404,9 @@ fn parse_arg(
         Position::ArgumentNamed(name) => match (mode, Symbol::intern(name)) {
             // Only `#[rustc_on_unimplemented]` can use these
             (Mode::RustcOnUnimplemented { .. }, sym::ItemContext) => FormatArg::ItemContext,
-            (Mode::RustcOnUnimplemented { .. }, sym::This) => FormatArg::This,
+            (Mode::RustcOnUnimplemented { .. } | Mode::DiagnosticOnUnmatchArgs, sym::This) => {
+                FormatArg::This
+            }
             (Mode::RustcOnUnimplemented { .. }, sym::Trait) => FormatArg::Trait,
             // Any attribute can use these
             (_, kw::SelfUpper) => FormatArg::SelfUpper,

compiler/rustc_attr_parsing/src/attributes/diagnostic/on_unmatch_args.rs

@@ -0,0 +1,58 @@
+use rustc_errors::Diagnostic;
+use rustc_hir::attrs::diagnostic::Directive;
+use rustc_session::lint::builtin::MISPLACED_DIAGNOSTIC_ATTRIBUTES;
+
+use crate::attributes::diagnostic::*;
+use crate::attributes::prelude::*;
+use crate::errors::DiagnosticOnUnmatchArgsOnlyForMacros;
+
+#[derive(Default)]
+pub(crate) struct OnUnmatchArgsParser {
+    span: Option<Span>,
+    directive: Option<(Span, Directive)>,
+}
+
+impl<S: Stage> AttributeParser<S> for OnUnmatchArgsParser {
+    const ATTRIBUTES: AcceptMapping<Self, S> = &[(
+        &[sym::diagnostic, sym::on_unmatch_args],
+        template!(List: &[r#"/*opt*/ message = "...", /*opt*/ label = "...", /*opt*/ note = "...""#]),
+        |this, cx, args| {
+            if !cx.features().diagnostic_on_unmatch_args() {
+                return;
+            }
+
+            let span = cx.attr_span;
+            this.span = Some(span);
+
+            if !matches!(cx.target, Target::MacroDef) {
+                cx.emit_dyn_lint(
+                    MISPLACED_DIAGNOSTIC_ATTRIBUTES,
+                    move |dcx, level| DiagnosticOnUnmatchArgsOnlyForMacros.into_diag(dcx, level),
+                    span,
+                );
+                return;
+            }
+
+            let mode = Mode::DiagnosticOnUnmatchArgs;
+            let Some(items) = parse_list(cx, args, mode) else { return };
+
+            let Some(directive) = parse_directive_items(cx, mode, items.mixed(), true) else {
+                return;
+            };
+            merge_directives(cx, &mut this.directive, (span, directive));
+        },
+    )];
+
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(ALL_TARGETS);
+
+    fn finalize(self, _cx: &FinalizeContext<'_, '_, S>) -> Option<AttributeKind> {
+        if let Some(span) = self.span {
+            Some(AttributeKind::OnUnmatchArgs {
+                span,
+                directive: self.directive.map(|d| Box::new(d.1)),
+            })
+        } else {
+            None
+        }
+    }
+}

compiler/rustc_attr_parsing/src/context.rs

@@ -33,6 +33,7 @@ use crate::attributes::diagnostic::on_const::*;
 use crate::attributes::diagnostic::on_move::*;
 use crate::attributes::diagnostic::on_unimplemented::*;
 use crate::attributes::diagnostic::on_unknown::*;
+use crate::attributes::diagnostic::on_unmatch_args::*;
 use crate::attributes::doc::*;
 use crate::attributes::dummy::*;
 use crate::attributes::inline::*;
@@ -159,6 +160,7 @@ attribute_parsers!(
         OnMoveParser,
         OnUnimplementedParser,
         OnUnknownParser,
+        OnUnmatchArgsParser,
         RustcAlignParser,
         RustcAlignStaticParser,
         RustcCguTestAttributeParser,

compiler/rustc_attr_parsing/src/errors.rs

@@ -315,6 +315,10 @@ pub(crate) struct DiagnosticOnUnknownOnlyForImports {
     pub target_span: Span,
 }
 
+#[derive(Diagnostic)]
+#[diag("`#[diagnostic::on_unmatch_args]` can only be applied to macro definitions")]
+pub(crate) struct DiagnosticOnUnmatchArgsOnlyForMacros;
+
 #[derive(Diagnostic)]
 #[diag("`#[diagnostic::do_not_recommend]` can only be placed on trait implementations")]
 pub(crate) struct IncorrectDoNotRecommendLocation {

compiler/rustc_codegen_llvm/src/va_arg.rs

@@ -11,7 +11,7 @@ use rustc_middle::ty::layout::{HasTyCtxt, LayoutOf, TyAndLayout};
 use rustc_target::spec::{Arch, Env, LlvmAbi, RustcAbi};
 
 use crate::builder::Builder;
-use crate::llvm::{Type, Value};
+use crate::llvm::Value;
 use crate::type_of::LayoutLlvmExt;
 
 fn round_up_to_alignment<'ll>(
@@ -27,13 +27,14 @@ fn round_pointer_up_to_alignment<'ll>(
     bx: &mut Builder<'_, 'll, '_>,
     addr: &'ll Value,
     align: Align,
-    ptr_ty: &'ll Type,
 ) -> &'ll Value {
     let ptr = bx.inbounds_ptradd(addr, bx.const_i32(align.bytes() as i32 - 1));
+    let pointer_width = bx.tcx().sess.target.pointer_width;
+    let mask = align.bytes().wrapping_neg() & (u64::MAX >> (64 - pointer_width));
     bx.call_intrinsic(
         "llvm.ptrmask",
-        &[ptr_ty, bx.type_i32()],
-        &[ptr, bx.const_int(bx.isize_ty, -(align.bytes() as isize) as i64)],
+        &[bx.type_ptr(), bx.type_isize()],
+        &[ptr, bx.const_usize(mask)],
     )
 }
 
@@ -53,7 +54,7 @@ fn emit_direct_ptr_va_arg<'ll, 'tcx>(
     let ptr = bx.load(va_list_ty, va_list_addr, ptr_align_abi);
 
     let (addr, addr_align) = if allow_higher_align && align > slot_size {
-        (round_pointer_up_to_alignment(bx, ptr, align, bx.type_ptr()), align)
+        (round_pointer_up_to_alignment(bx, ptr, align), align)
     } else {
         (ptr, slot_size)
     };
@@ -69,7 +70,8 @@ fn emit_direct_ptr_va_arg<'ll, 'tcx>(
     {
         let adjusted_size = bx.cx().const_i32((slot_size.bytes() - size.bytes()) as i32);
         let adjusted = bx.inbounds_ptradd(addr, adjusted_size);
-        (adjusted, addr_align)
+        // We're in the middle of a slot now, so use the type's alignment, not the slot's.
+        (adjusted, align)
     } else {
         (addr, addr_align)
     }
@@ -357,12 +359,8 @@ fn emit_powerpc_va_arg<'ll, 'tcx>(
 
         // Round up address of argument to alignment
         if layout.layout.align.abi > overflow_area_align {
-            overflow_area = round_pointer_up_to_alignment(
-                bx,
-                overflow_area,
-                layout.layout.align.abi,
-                bx.type_ptr(),
-            );
+            overflow_area =
+                round_pointer_up_to_alignment(bx, overflow_area, layout.layout.align.abi);
         }
 
         let mem_addr = overflow_area;
@@ -827,7 +825,7 @@ fn emit_hexagon_va_arg_musl<'ll, 'tcx>(
     } else {
         Align::from_bytes(4).unwrap()
     };
-    let aligned_current = round_pointer_up_to_alignment(bx, current_ptr, arg_align, bx.type_ptr());
+    let aligned_current = round_pointer_up_to_alignment(bx, current_ptr, arg_align);
 
     // Calculate next pointer position (following LLVM's logic)
     // Arguments <= 32 bits take 4 bytes, > 32 bits take 8 bytes
@@ -849,8 +847,7 @@ fn emit_hexagon_va_arg_musl<'ll, 'tcx>(
     bx.switch_to_block(from_overflow);
 
     // Align overflow pointer using the same alignment rules
-    let aligned_overflow =
-        round_pointer_up_to_alignment(bx, overflow_ptr, arg_align, bx.type_ptr());
+    let aligned_overflow = round_pointer_up_to_alignment(bx, overflow_ptr, arg_align);
 
     let overflow_value_addr = aligned_overflow;
     // Update overflow pointer - use the same size calculation
@@ -890,7 +887,7 @@ fn emit_hexagon_va_arg_bare_metal<'ll, 'tcx>(
     let aligned_ptr = if ty_align.bytes() > 4 {
         // Ensure alignment is a power of 2
         debug_assert!(ty_align.bytes().is_power_of_two(), "Alignment is not power of 2!");
-        round_pointer_up_to_alignment(bx, current_ptr, ty_align, bx.type_ptr())
+        round_pointer_up_to_alignment(bx, current_ptr, ty_align)
     } else {
         current_ptr
     };

compiler/rustc_expand/src/mbe/diagnostics.rs

@@ -3,6 +3,7 @@ use std::borrow::Cow;
 use rustc_ast::token::{self, Token};
 use rustc_ast::tokenstream::TokenStream;
 use rustc_errors::{Applicability, Diag, DiagCtxtHandle, DiagMessage};
+use rustc_hir::attrs::diagnostic::{CustomDiagnostic, Directive, FormatArgs};
 use rustc_macros::Subdiagnostic;
 use rustc_parse::parser::{Parser, Recovery, token_descr};
 use rustc_session::parse::ParseSess;
@@ -32,6 +33,7 @@ pub(super) fn failed_to_match_macro(
     args: FailedMacro<'_>,
     body: &TokenStream,
     rules: &[MacroRule],
+    on_unmatch_args: Option<&Directive>,
 ) -> (Span, ErrorGuaranteed) {
     debug!("failed to match macro");
     let def_head_span = if !def_span.is_dummy() && !psess.source_map().is_imported(def_span) {
@@ -72,9 +74,30 @@ pub(super) fn failed_to_match_macro(
     };
 
     let span = token.span.substitute_dummy(sp);
+    let CustomDiagnostic {
+        message: custom_message, label: custom_label, notes: custom_notes, ..
+    } = {
+        let macro_name = name.to_string();
+        on_unmatch_args
+            .map(|directive| {
+                directive.eval(
+                    None,
+                    &FormatArgs {
+                        this: macro_name.clone(),
+                        this_sugared: macro_name,
+                        item_context: "macro invocation",
+                        generic_args: Vec::new(),
+                    },
+                )
+            })
+            .unwrap_or_default()
+    };
 
-    let mut err = psess.dcx().struct_span_err(span, parse_failure_msg(&token, None));
-    err.span_label(span, label);
+    let mut err = match custom_message {
+        Some(message) => psess.dcx().struct_span_err(span, message),
+        None => psess.dcx().struct_span_err(span, parse_failure_msg(&token, None)),
+    };
+    err.span_label(span, custom_label.unwrap_or_else(|| label.to_string()));
     if !def_head_span.is_dummy() {
         err.span_label(def_head_span, "when calling this macro");
     }
@@ -86,6 +109,9 @@ pub(super) fn failed_to_match_macro(
     } else {
         err.note(format!("while trying to match {remaining_matcher}"));
     }
+    for note in custom_notes {
+        err.note(note);
+    }
 
     if let MatcherLoc::Token { token: expected_token } = &remaining_matcher
         && (matches!(expected_token.kind, token::OpenInvisible(_))