Rollup of 6 pull requests

compiler/rustc_attr_parsing/src/attributes/codegen_attrs.rs

@@ -717,3 +717,100 @@ impl<S: Stage> NoArgsAttributeParser<S> for EiiForeignItemParser {
     const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::ForeignFn)]);
     const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::EiiForeignItem;
 }
+
+pub(crate) struct PatchableFunctionEntryParser;
+
+impl<S: Stage> SingleAttributeParser<S> for PatchableFunctionEntryParser {
+    const PATH: &[Symbol] = &[sym::patchable_function_entry];
+    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
+    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepInnermost;
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::Fn)]);
+    const TEMPLATE: AttributeTemplate = template!(List: &["prefix_nops = m, entry_nops = n"]);
+
+    fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser) -> Option<AttributeKind> {
+        let Some(meta_item_list) = args.list() else {
+            cx.expected_list(cx.attr_span, args);
+            return None;
+        };
+
+        let mut prefix = None;
+        let mut entry = None;
+
+        if meta_item_list.len() == 0 {
+            cx.expected_list(meta_item_list.span, args);
+            return None;
+        }
+
+        let mut errored = false;
+
+        for item in meta_item_list.mixed() {
+            let Some(meta_item) = item.meta_item() else {
+                errored = true;
+                cx.expected_name_value(item.span(), None);
+                continue;
+            };
+
+            let Some(name_value_lit) = meta_item.args().name_value() else {
+                errored = true;
+                cx.expected_name_value(item.span(), None);
+                continue;
+            };
+
+            let attrib_to_write = match meta_item.ident().map(|ident| ident.name) {
+                Some(sym::prefix_nops) => {
+                    // Duplicate prefixes are not allowed
+                    if prefix.is_some() {
+                        errored = true;
+                        cx.duplicate_key(meta_item.path().span(), sym::prefix_nops);
+                        continue;
+                    }
+                    &mut prefix
+                }
+                Some(sym::entry_nops) => {
+                    // Duplicate entries are not allowed
+                    if entry.is_some() {
+                        errored = true;
+                        cx.duplicate_key(meta_item.path().span(), sym::entry_nops);
+                        continue;
+                    }
+                    &mut entry
+                }
+                _ => {
+                    errored = true;
+                    cx.expected_specific_argument(
+                        meta_item.path().span(),
+                        &[sym::prefix_nops, sym::entry_nops],
+                    );
+                    continue;
+                }
+            };
+
+            let rustc_ast::LitKind::Int(val, _) = name_value_lit.value_as_lit().kind else {
+                errored = true;
+                cx.expected_integer_literal(name_value_lit.value_span);
+                continue;
+            };
+
+            let Ok(val) = val.get().try_into() else {
+                errored = true;
+                cx.expected_integer_literal_in_range(
+                    name_value_lit.value_span,
+                    u8::MIN as isize,
+                    u8::MAX as isize,
+                );
+                continue;
+            };
+
+            *attrib_to_write = Some(val);
+        }
+
+        if errored {
+            None
+        } else {
+            Some(AttributeKind::PatchableFunctionEntry {
+                prefix: prefix.unwrap_or(0),
+                entry: entry.unwrap_or(0),
+            })
+        }
+    }
+}

compiler/rustc_attr_parsing/src/attributes/test_attrs.rs

@@ -91,3 +91,25 @@ impl<S: Stage> SingleAttributeParser<S> for ShouldPanicParser {
         })
     }
 }
+
+pub(crate) struct RustcVarianceParser;
+
+impl<S: Stage> NoArgsAttributeParser<S> for RustcVarianceParser {
+    const PATH: &[Symbol] = &[sym::rustc_variance];
+    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Warn;
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[
+        Allow(Target::Struct),
+        Allow(Target::Enum),
+        Allow(Target::Union),
+    ]);
+    const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::RustcVariance;
+}
+
+pub(crate) struct RustcVarianceOfOpaquesParser;
+
+impl<S: Stage> NoArgsAttributeParser<S> for RustcVarianceOfOpaquesParser {
+    const PATH: &[Symbol] = &[sym::rustc_variance_of_opaques];
+    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Warn;
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::Crate)]);
+    const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::RustcVarianceOfOpaques;
+}

compiler/rustc_attr_parsing/src/context.rs

@@ -23,8 +23,8 @@ use crate::attributes::cfi_encoding::CfiEncodingParser;
 use crate::attributes::codegen_attrs::{
     ColdParser, CoverageParser, EiiForeignItemParser, ExportNameParser, ForceTargetFeatureParser,
     NakedParser, NoMangleParser, ObjcClassParser, ObjcSelectorParser, OptimizeParser,
-    RustcPassIndirectlyInNonRusticAbisParser, SanitizeParser, TargetFeatureParser,
-    ThreadLocalParser, TrackCallerParser, UsedParser,
+    PatchableFunctionEntryParser, RustcPassIndirectlyInNonRusticAbisParser, SanitizeParser,
+    TargetFeatureParser, ThreadLocalParser, TrackCallerParser, UsedParser,
 };
 use crate::attributes::confusables::ConfusablesParser;
 use crate::attributes::crate_level::{
@@ -85,7 +85,9 @@ use crate::attributes::semantics::MayDangleParser;
 use crate::attributes::stability::{
     BodyStabilityParser, ConstStabilityIndirectParser, ConstStabilityParser, StabilityParser,
 };
-use crate::attributes::test_attrs::{IgnoreParser, ShouldPanicParser};
+use crate::attributes::test_attrs::{
+    IgnoreParser, RustcVarianceOfOpaquesParser, RustcVarianceParser, ShouldPanicParser,
+};
 use crate::attributes::traits::{
     AllowIncoherentImplParser, CoinductiveParser, DenyExplicitImplParser,
     DoNotImplementViaObjectParser, FundamentalParser, MarkerParser, ParenSugarParser,
@@ -223,6 +225,7 @@ attribute_parsers!(
         Single<ObjcClassParser>,
         Single<ObjcSelectorParser>,
         Single<OptimizeParser>,
+        Single<PatchableFunctionEntryParser>,
         Single<PathAttributeParser>,
         Single<PatternComplexityLimitParser>,
         Single<ProcMacroDeriveParser>,
@@ -300,6 +303,8 @@ attribute_parsers!(
         Single<WithoutArgs<RustcPassIndirectlyInNonRusticAbisParser>>,
         Single<WithoutArgs<RustcReallocatorParser>>,
         Single<WithoutArgs<RustcShouldNotBeCalledOnConstItems>>,
+        Single<WithoutArgs<RustcVarianceOfOpaquesParser>>,
+        Single<WithoutArgs<RustcVarianceParser>>,
         Single<WithoutArgs<SpecializationTraitParser>>,
         Single<WithoutArgs<StdInternalSymbolParser>>,
         Single<WithoutArgs<ThreadLocalParser>>,
@@ -503,6 +508,18 @@ impl<'f, 'sess: 'f, S: Stage> AcceptContext<'f, 'sess, S> {
         self.emit_parse_error(span, AttributeParseErrorReason::ExpectedIntegerLiteral)
     }
 
+    pub(crate) fn expected_integer_literal_in_range(
+        &self,
+        span: Span,
+        lower_bound: isize,
+        upper_bound: isize,
+    ) -> ErrorGuaranteed {
+        self.emit_parse_error(
+            span,
+            AttributeParseErrorReason::ExpectedIntegerLiteralInRange { lower_bound, upper_bound },
+        )
+    }
+
     pub(crate) fn expected_list(&self, span: Span, args: &ArgParser) -> ErrorGuaranteed {
         let span = match args {
             ArgParser::NoArgs => span,

compiler/rustc_attr_parsing/src/session_diagnostics.rs

@@ -525,6 +525,10 @@ pub(crate) enum AttributeParseErrorReason<'a> {
         byte_string: Option<Span>,
     },
     ExpectedIntegerLiteral,
+    ExpectedIntegerLiteralInRange {
+        lower_bound: isize,
+        upper_bound: isize,
+    },
     ExpectedAtLeastOneArgument,
     ExpectedSingleArgument,
     ExpectedList,
@@ -596,6 +600,17 @@ impl<'a, G: EmissionGuarantee> Diagnostic<'a, G> for AttributeParseError<'_> {
             AttributeParseErrorReason::ExpectedIntegerLiteral => {
                 diag.span_label(self.span, "expected an integer literal here");
             }
+            AttributeParseErrorReason::ExpectedIntegerLiteralInRange {
+                lower_bound,
+                upper_bound,
+            } => {
+                diag.span_label(
+                    self.span,
+                    format!(
+                        "expected an integer literal in the range of {lower_bound}..={upper_bound}"
+                    ),
+                );
+            }
             AttributeParseErrorReason::ExpectedSingleArgument => {
                 diag.span_label(self.span, "expected a single argument here");
                 diag.code(E0805);

compiler/rustc_codegen_cranelift/src/intrinsics/mod.rs

@@ -1506,7 +1506,7 @@ fn codegen_regular_intrinsic_call<'tcx>(
         }
 
         // FIXME implement variadics in cranelift
-        sym::va_copy | sym::va_arg | sym::va_end => {
+        sym::va_arg | sym::va_end => {
             fx.tcx.dcx().span_fatal(
                 source_info.span,
                 "Defining variadic functions is not yet supported by Cranelift",

compiler/rustc_codegen_gcc/src/intrinsic/mod.rs

@@ -391,9 +391,6 @@ impl<'a, 'gcc, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'a, 'gcc, 'tc
             sym::breakpoint => {
                 unimplemented!();
             }
-            sym::va_copy => {
-                unimplemented!();
-            }
             sym::va_arg => {
                 unimplemented!();
             }

compiler/rustc_codegen_llvm/src/context.rs

@@ -221,6 +221,12 @@ pub(crate) unsafe fn create_module<'ll>(
             target_data_layout = target_data_layout.replace("-m:e", "");
         }
     }
+    if llvm_version < (23, 0, 0) {
+        if sess.target.arch == Arch::S390x {
+            // LLVM 23 updated the s390x layout to specify the stack alignment: https://github.com/llvm/llvm-project/pull/176041
+            target_data_layout = target_data_layout.replace("-S64", "");
+        }
+    }
 
     // Ensure the data-layout values hardcoded remain the defaults.
     {

compiler/rustc_codegen_llvm/src/intrinsic.rs

@@ -269,14 +269,6 @@ impl<'ll, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'_, 'll, 'tcx> {
                 return Ok(());
             }
             sym::breakpoint => self.call_intrinsic("llvm.debugtrap", &[], &[]),
-            sym::va_copy => {
-                let dest = args[0].immediate();
-                self.call_intrinsic(
-                    "llvm.va_copy",
-                    &[self.val_ty(dest)],
-                    &[dest, args[1].immediate()],
-                )
-            }
             sym::va_arg => {
                 match result.layout.backend_repr {
                     BackendRepr::Scalar(scalar) => {

compiler/rustc_codegen_ssa/messages.ftl

@@ -48,8 +48,6 @@ codegen_ssa_error_creating_remark_dir = failed to create remark directory: {$err
 codegen_ssa_error_writing_def_file =
     error writing .DEF file: {$error}
 
-codegen_ssa_expected_name_value_pair = expected name value pair
-
 codegen_ssa_extern_funcs_not_found = some `extern` functions couldn't be found; some native libraries may need to be installed or have their path specified
 
 codegen_ssa_extract_bundled_libs_archive_member = failed to get data from archive member '{$rlib}': {$error}
@@ -90,9 +88,6 @@ codegen_ssa_incorrect_cgu_reuse_type =
 
 codegen_ssa_insufficient_vs_code_product = VS Code is a different product, and is not sufficient.
 
-codegen_ssa_invalid_literal_value = invalid literal value
-    .label = value must be an integer between `0` and `255`
-
 codegen_ssa_invalid_monomorphization_basic_float_type = invalid monomorphization of `{$name}` intrinsic: expected basic float type, found `{$ty}`
 
 codegen_ssa_invalid_monomorphization_basic_integer_or_ptr_type = invalid monomorphization of `{$name}` intrinsic: expected basic integer or pointer type, found `{$ty}`
@@ -225,9 +220,6 @@ codegen_ssa_no_natvis_directory = error enumerating natvis directory: {$error}
 
 codegen_ssa_no_saved_object_file = cached cgu {$cgu_name} should have an object file, but doesn't
 
-codegen_ssa_out_of_range_integer = integer value out of range
-    .label = value must be between `0` and `255`
-
 codegen_ssa_processing_dymutil_failed = processing debug info with `dsymutil` failed: {$status}
     .note = {$output}
 
@@ -357,9 +349,6 @@ codegen_ssa_unable_to_run_dsymutil = unable to run `dsymutil`: {$error}
 
 codegen_ssa_unable_to_write_debugger_visualizer = unable to write debugger visualizer file `{$path}`: {$error}
 
-codegen_ssa_unexpected_parameter_name = unexpected parameter name
-    .label = expected `{$prefix_nops}` or `{$entry_nops}`
-
 codegen_ssa_unknown_archive_kind =
     don't know how to build archive of type: {$kind}