Merge pull request #800 from rust-lang/sync_from_rust_2025_11_13

Sync from rust 2025/11/13

Author: antoyo

.github/workflows/release.yml

@@ -72,6 +72,9 @@ jobs:
         git config --global user.name "User"
         ./y.sh prepare
 
+    - name: Add more failing tests (some panic and debuginfo tests fail)
+      run: cat tests/failing-lto-tests.txt >> tests/failing-ui-tests.txt
+
     - name: Run tests
       run: |
         # FIXME(antoyo): we cannot enable LTO for stdarch tests currently because of some failing LTO tests using proc-macros.

build_system/src/test.rs

@@ -1065,6 +1065,7 @@ where
         &test_dir,
         &"--compiletest-rustc-args",
         &rustc_args,
+        &"--bypass-ignore-backends",
     ];
 
     if run_ignored_tests {

rust-toolchain

@@ -1,3 +1,3 @@
 [toolchain]
-channel = "nightly-2025-11-04"
+channel = "nightly-2025-11-13"
 components = ["rust-src", "rustc-dev", "llvm-tools-preview"]

src/abi.rs

@@ -12,6 +12,8 @@ use rustc_middle::ty::layout::LayoutOf;
 #[cfg(feature = "master")]
 use rustc_session::config;
 use rustc_target::callconv::{ArgAttributes, CastTarget, FnAbi, PassMode};
+#[cfg(feature = "master")]
+use rustc_target::spec::Arch;
 
 use crate::builder::Builder;
 use crate::context::CodegenCx;
@@ -238,7 +240,7 @@ impl<'gcc, 'tcx> FnAbiGccExt<'gcc, 'tcx> for FnAbi<'tcx, Ty<'tcx>> {
 }
 
 #[cfg(feature = "master")]
-pub fn conv_to_fn_attribute<'gcc>(conv: CanonAbi, arch: &str) -> Option<FnAttribute<'gcc>> {
+pub fn conv_to_fn_attribute<'gcc>(conv: CanonAbi, arch: &Arch) -> Option<FnAttribute<'gcc>> {
     let attribute = match conv {
         CanonAbi::C | CanonAbi::Rust => return None,
         CanonAbi::RustCold => FnAttribute::Cold,
@@ -251,15 +253,11 @@ pub fn conv_to_fn_attribute<'gcc>(conv: CanonAbi, arch: &str) -> Option<FnAttrib
             ArmCall::CCmseNonSecureEntry => FnAttribute::ArmCmseNonsecureEntry,
             ArmCall::Aapcs => FnAttribute::ArmPcs("aapcs"),
         },
-        CanonAbi::GpuKernel => {
-            if arch == "amdgpu" {
-                FnAttribute::GcnAmdGpuHsaKernel
-            } else if arch == "nvptx64" {
-                FnAttribute::NvptxKernel
-            } else {
-                panic!("Architecture {} does not support GpuKernel calling convention", arch);
-            }
-        }
+        CanonAbi::GpuKernel => match arch {
+            &Arch::AmdGpu => FnAttribute::GcnAmdGpuHsaKernel,
+            &Arch::Nvptx64 => FnAttribute::NvptxKernel,
+            arch => panic!("Arch {arch} does not support GpuKernel calling convention"),
+        },
         // TODO(antoyo): check if those AVR attributes are mapped correctly.
         CanonAbi::Interrupt(interrupt_kind) => match interrupt_kind {
             InterruptKind::Avr => FnAttribute::AvrSignal,

src/attributes.rs

@@ -9,6 +9,8 @@ use rustc_middle::middle::codegen_fn_attrs::CodegenFnAttrFlags;
 #[cfg(feature = "master")]
 use rustc_middle::mir::TerminatorKind;
 use rustc_middle::ty;
+#[cfg(feature = "master")]
+use rustc_target::spec::Arch;
 
 use crate::context::CodegenCx;
 use crate::gcc_util::to_gcc_features;
@@ -70,7 +72,7 @@ fn inline_attr<'gcc, 'tcx>(
         InlineAttr::Hint => Some(FnAttribute::Inline),
         InlineAttr::Force { .. } => Some(FnAttribute::AlwaysInline),
         InlineAttr::Never => {
-            if cx.sess().target.arch != "amdgpu" {
+            if cx.sess().target.arch != Arch::AmdGpu {
                 Some(FnAttribute::NoInline)
             } else {
                 None
@@ -153,8 +155,8 @@ pub fn from_fn_attrs<'gcc, 'tcx>(
         .join(",");
     if !target_features.is_empty() {
         #[cfg(feature = "master")]
-        match cx.sess().target.arch.as_ref() {
-            "x86" | "x86_64" | "powerpc" => {
+        match cx.sess().target.arch {
+            Arch::X86 | Arch::X86_64 | Arch::PowerPC => {
                 func.add_attribute(FnAttribute::Target(&target_features))
             }
             // The target attribute is not supported on other targets in GCC.

src/base.rs

@@ -15,9 +15,9 @@ use rustc_middle::mir::mono::Visibility;
 use rustc_middle::ty::TyCtxt;
 use rustc_session::config::DebugInfo;
 use rustc_span::Symbol;
-use rustc_target::spec::RelocModel;
 #[cfg(feature = "master")]
 use rustc_target::spec::SymbolVisibility;
+use rustc_target::spec::{Arch, RelocModel};
 
 use crate::builder::Builder;
 use crate::context::CodegenCx;
@@ -117,7 +117,7 @@ pub fn compile_codegen_unit(
             .map(|string| &string[1..])
             .collect();
 
-        if !disabled_features.contains("avx") && tcx.sess.target.arch == "x86_64" {
+        if !disabled_features.contains("avx") && tcx.sess.target.arch == Arch::X86_64 {
             // NOTE: we always enable AVX because the equivalent of llvm.x86.sse2.cmp.pd in GCC for
             // SSE2 is multiple builtins, so we use the AVX __builtin_ia32_cmppd instead.
             // FIXME(antoyo): use the proper builtins for llvm.x86.sse2.cmp.pd and similar.

src/builder.rs

@@ -1079,7 +1079,7 @@ impl<'a, 'gcc, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'gcc, 'tcx> {
             OperandValue::Ref(place.val)
         };
 
-        OperandRef { val, layout: place.layout }
+        OperandRef { val, layout: place.layout, move_annotation: None }
     }
 
     fn write_operand_repeatedly(

src/debuginfo.rs

@@ -19,7 +19,7 @@ use crate::context::CodegenCx;
 pub(super) const UNKNOWN_LINE_NUMBER: u32 = 0;
 pub(super) const UNKNOWN_COLUMN_NUMBER: u32 = 0;
 
-impl<'a, 'gcc, 'tcx> DebugInfoBuilderMethods for Builder<'a, 'gcc, 'tcx> {
+impl<'a, 'gcc, 'tcx> DebugInfoBuilderMethods<'tcx> for Builder<'a, 'gcc, 'tcx> {
     // FIXME(eddyb) find a common convention for all of the debuginfo-related
     // names (choose between `dbg`, `debug`, `debuginfo`, `debug_info` etc.).
     fn dbg_var_addr(

src/gcc_util.rs

@@ -3,6 +3,7 @@ use gccjit::Context;
 use rustc_codegen_ssa::target_features;
 use rustc_data_structures::smallvec::{SmallVec, smallvec};
 use rustc_session::Session;
+use rustc_target::spec::Arch;
 
 fn gcc_features_by_flags(sess: &Session, features: &mut Vec<String>) {
     target_features::retpoline_features_by_flags(sess, features);
@@ -11,7 +12,7 @@ fn gcc_features_by_flags(sess: &Session, features: &mut Vec<String>) {
 
 /// The list of GCC features computed from CLI flags (`-Ctarget-cpu`, `-Ctarget-feature`,
 /// `--target` and similar).
-pub(crate) fn global_gcc_features(sess: &Session, diagnostics: bool) -> Vec<String> {
+pub(crate) fn global_gcc_features(sess: &Session) -> Vec<String> {
     // Features that come earlier are overridden by conflicting features later in the string.
     // Typically we'll want more explicit settings to override the implicit ones, so:
     //
@@ -36,27 +37,18 @@ pub(crate) fn global_gcc_features(sess: &Session, diagnostics: bool) -> Vec<Stri
     features.extend(sess.target.features.split(',').filter(|v| !v.is_empty()).map(String::from));
 
     // -Ctarget-features
-    target_features::flag_to_backend_features(
-        sess,
-        diagnostics,
-        |feature| to_gcc_features(sess, feature),
-        |feature, enable| {
-            // We run through `to_gcc_features` when
-            // passing requests down to GCC. This means that all in-language
-            // features also work on the command line instead of having two
-            // different names when the GCC name and the Rust name differ.
-            features.extend(
-                to_gcc_features(sess, feature)
-                    .iter()
-                    .flat_map(|feat| to_gcc_features(sess, feat).into_iter())
-                    .map(
-                        |feature| {
-                            if !enable { format!("-{}", feature) } else { feature.to_string() }
-                        },
-                    ),
-            );
-        },
-    );
+    target_features::flag_to_backend_features(sess, |feature, enable| {
+        // We run through `to_gcc_features` when
+        // passing requests down to GCC. This means that all in-language
+        // features also work on the command line instead of having two
+        // different names when the GCC name and the Rust name differ.
+        features.extend(
+            to_gcc_features(sess, feature)
+                .iter()
+                .flat_map(|feat| to_gcc_features(sess, feat).into_iter())
+                .map(|feature| if !enable { format!("-{}", feature) } else { feature.to_string() }),
+        );
+    });
 
     gcc_features_by_flags(sess, &mut features);
 
@@ -65,44 +57,47 @@ pub(crate) fn global_gcc_features(sess: &Session, diagnostics: bool) -> Vec<Stri
 
 // To find a list of GCC's names, check https://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html
 pub fn to_gcc_features<'a>(sess: &Session, s: &'a str) -> SmallVec<[&'a str; 2]> {
-    let arch = if sess.target.arch == "x86_64" { "x86" } else { &*sess.target.arch };
     // cSpell:disable
-    match (arch, s) {
+    match (&sess.target.arch, s) {
         // FIXME: seems like x87 does not exist?
-        ("x86", "x87") => smallvec![],
-        ("x86", "sse4.2") => smallvec!["sse4.2", "crc32"],
-        ("x86", "pclmulqdq") => smallvec!["pclmul"],
-        ("x86", "rdrand") => smallvec!["rdrnd"],
-        ("x86", "bmi1") => smallvec!["bmi"],
-        ("x86", "cmpxchg16b") => smallvec!["cx16"],
-        ("x86", "avx512vaes") => smallvec!["vaes"],
-        ("x86", "avx512gfni") => smallvec!["gfni"],
-        ("x86", "avx512vpclmulqdq") => smallvec!["vpclmulqdq"],
+        (&Arch::X86 | &Arch::X86_64, "x87") => smallvec![],
+        (&Arch::X86 | &Arch::X86_64, "sse4.2") => smallvec!["sse4.2", "crc32"],
+        (&Arch::X86 | &Arch::X86_64, "pclmulqdq") => smallvec!["pclmul"],
+        (&Arch::X86 | &Arch::X86_64, "rdrand") => smallvec!["rdrnd"],
+        (&Arch::X86 | &Arch::X86_64, "bmi1") => smallvec!["bmi"],
+        (&Arch::X86 | &Arch::X86_64, "cmpxchg16b") => smallvec!["cx16"],
+        (&Arch::X86 | &Arch::X86_64, "avx512vaes") => smallvec!["vaes"],
+        (&Arch::X86 | &Arch::X86_64, "avx512gfni") => smallvec!["gfni"],
+        (&Arch::X86 | &Arch::X86_64, "avx512vpclmulqdq") => smallvec!["vpclmulqdq"],
         // NOTE: seems like GCC requires 'avx512bw' for 'avx512vbmi2'.
-        ("x86", "avx512vbmi2") => smallvec!["avx512vbmi2", "avx512bw"],
+        (&Arch::X86 | &Arch::X86_64, "avx512vbmi2") => {
+            smallvec!["avx512vbmi2", "avx512bw"]
+        }
         // NOTE: seems like GCC requires 'avx512bw' for 'avx512bitalg'.
-        ("x86", "avx512bitalg") => smallvec!["avx512bitalg", "avx512bw"],
-        ("aarch64", "rcpc2") => smallvec!["rcpc-immo"],
-        ("aarch64", "dpb") => smallvec!["ccpp"],
-        ("aarch64", "dpb2") => smallvec!["ccdp"],
-        ("aarch64", "frintts") => smallvec!["fptoint"],
-        ("aarch64", "fcma") => smallvec!["complxnum"],
-        ("aarch64", "pmuv3") => smallvec!["perfmon"],
-        ("aarch64", "paca") => smallvec!["pauth"],
-        ("aarch64", "pacg") => smallvec!["pauth"],
+        (&Arch::X86 | &Arch::X86_64, "avx512bitalg") => {
+            smallvec!["avx512bitalg", "avx512bw"]
+        }
+        (&Arch::AArch64, "rcpc2") => smallvec!["rcpc-immo"],
+        (&Arch::AArch64, "dpb") => smallvec!["ccpp"],
+        (&Arch::AArch64, "dpb2") => smallvec!["ccdp"],
+        (&Arch::AArch64, "frintts") => smallvec!["fptoint"],
+        (&Arch::AArch64, "fcma") => smallvec!["complxnum"],
+        (&Arch::AArch64, "pmuv3") => smallvec!["perfmon"],
+        (&Arch::AArch64, "paca") => smallvec!["pauth"],
+        (&Arch::AArch64, "pacg") => smallvec!["pauth"],
         // Rust ties fp and neon together. In GCC neon implicitly enables fp,
         // but we manually enable neon when a feature only implicitly enables fp
-        ("aarch64", "f32mm") => smallvec!["f32mm", "neon"],
-        ("aarch64", "f64mm") => smallvec!["f64mm", "neon"],
-        ("aarch64", "fhm") => smallvec!["fp16fml", "neon"],
-        ("aarch64", "fp16") => smallvec!["fullfp16", "neon"],
-        ("aarch64", "jsconv") => smallvec!["jsconv", "neon"],
-        ("aarch64", "sve") => smallvec!["sve", "neon"],
-        ("aarch64", "sve2") => smallvec!["sve2", "neon"],
-        ("aarch64", "sve2-aes") => smallvec!["sve2-aes", "neon"],
-        ("aarch64", "sve2-sm4") => smallvec!["sve2-sm4", "neon"],
-        ("aarch64", "sve2-sha3") => smallvec!["sve2-sha3", "neon"],
-        ("aarch64", "sve2-bitperm") => smallvec!["sve2-bitperm", "neon"],
+        (&Arch::AArch64, "f32mm") => smallvec!["f32mm", "neon"],
+        (&Arch::AArch64, "f64mm") => smallvec!["f64mm", "neon"],
+        (&Arch::AArch64, "fhm") => smallvec!["fp16fml", "neon"],
+        (&Arch::AArch64, "fp16") => smallvec!["fullfp16", "neon"],
+        (&Arch::AArch64, "jsconv") => smallvec!["jsconv", "neon"],
+        (&Arch::AArch64, "sve") => smallvec!["sve", "neon"],
+        (&Arch::AArch64, "sve2") => smallvec!["sve2", "neon"],
+        (&Arch::AArch64, "sve2-aes") => smallvec!["sve2-aes", "neon"],
+        (&Arch::AArch64, "sve2-sm4") => smallvec!["sve2-sm4", "neon"],
+        (&Arch::AArch64, "sve2-sha3") => smallvec!["sve2-sha3", "neon"],
+        (&Arch::AArch64, "sve2-bitperm") => smallvec!["sve2-bitperm", "neon"],
         (_, s) => smallvec![s],
     }
     // cSpell:enable

src/lib.rs

@@ -13,9 +13,6 @@
  * TODO(antoyo): remove the patches.
  */
 
-#![expect(internal_features)]
-#![doc(rust_logo)]
-#![feature(rustdoc_internals)]
 #![feature(rustc_private)]
 #![recursion_limit = "256"]
 #![warn(rust_2018_idioms)]
@@ -100,11 +97,11 @@ use rustc_middle::util::Providers;
 use rustc_session::Session;
 use rustc_session::config::{OptLevel, OutputFilenames};
 use rustc_span::Symbol;
-use rustc_target::spec::RelocModel;
+use rustc_target::spec::{Arch, RelocModel};
 use tempfile::TempDir;
 
 use crate::back::lto::ModuleBuffer;
-use crate::gcc_util::target_cpu;
+use crate::gcc_util::{target_cpu, to_gcc_features};
 
 rustc_fluent_macro::fluent_messages! { "../messages.ftl" }
 
@@ -226,7 +223,7 @@ impl CodegenBackend for GccCodegenBackend {
     }
 
     fn provide(&self, providers: &mut Providers) {
-        providers.global_backend_features = |tcx, ()| gcc_util::global_gcc_features(tcx.sess, true)
+        providers.global_backend_features = |tcx, ()| gcc_util::global_gcc_features(tcx.sess)
     }
 
     fn codegen_crate(&self, tcx: TyCtxt<'_>) -> Box<dyn Any> {
@@ -255,7 +252,7 @@ impl CodegenBackend for GccCodegenBackend {
 
 fn new_context<'gcc, 'tcx>(tcx: TyCtxt<'tcx>) -> Context<'gcc> {
     let context = Context::default();
-    if tcx.sess.target.arch == "x86" || tcx.sess.target.arch == "x86_64" {
+    if matches!(tcx.sess.target.arch, Arch::X86 | Arch::X86_64) {
         context.add_command_line_option("-masm=intel");
     }
     #[cfg(feature = "master")]
@@ -470,21 +467,25 @@ fn to_gcc_opt_level(optlevel: Option<OptLevel>) -> OptimizationLevel {
 
 /// Returns the features that should be set in `cfg(target_feature)`.
 fn target_config(sess: &Session, target_info: &LockedTargetInfo) -> TargetConfig {
-    let (unstable_target_features, target_features) = cfg_target_feature(sess, |feature| {
-        // TODO: we disable Neon for now since we don't support the LLVM intrinsics for it.
-        if feature == "neon" {
-            return false;
-        }
-        target_info.cpu_supports(feature)
-        // cSpell:disable
-        /*
-          adx, aes, avx, avx2, avx512bf16, avx512bitalg, avx512bw, avx512cd, avx512dq, avx512er, avx512f, avx512fp16, avx512ifma,
-          avx512pf, avx512vbmi, avx512vbmi2, avx512vl, avx512vnni, avx512vp2intersect, avx512vpopcntdq,
-          bmi1, bmi2, cmpxchg16b, ermsb, f16c, fma, fxsr, gfni, lzcnt, movbe, pclmulqdq, popcnt, rdrand, rdseed, rtm,
-          sha, sse, sse2, sse3, sse4.1, sse4.2, sse4a, ssse3, tbm, vaes, vpclmulqdq, xsave, xsavec, xsaveopt, xsaves
-        */
-        // cSpell:enable
-    });
+    let (unstable_target_features, target_features) = cfg_target_feature(
+        sess,
+        |feature| to_gcc_features(sess, feature),
+        |feature| {
+            // TODO: we disable Neon for now since we don't support the LLVM intrinsics for it.
+            if feature == "neon" {
+                return false;
+            }
+            target_info.cpu_supports(feature)
+            // cSpell:disable
+            /*
+              adx, aes, avx, avx2, avx512bf16, avx512bitalg, avx512bw, avx512cd, avx512dq, avx512er, avx512f, avx512fp16, avx512ifma,
+              avx512pf, avx512vbmi, avx512vbmi2, avx512vl, avx512vnni, avx512vp2intersect, avx512vpopcntdq,
+              bmi1, bmi2, cmpxchg16b, ermsb, f16c, fma, fxsr, gfni, lzcnt, movbe, pclmulqdq, popcnt, rdrand, rdseed, rtm,
+              sha, sse, sse2, sse3, sse4.1, sse4.2, sse4a, ssse3, tbm, vaes, vpclmulqdq, xsave, xsavec, xsaveopt, xsaves
+            */
+            // cSpell:enable
+        },
+    );
 
     let has_reliable_f16 = target_info.supports_target_dependent_type(CType::Float16);
     let has_reliable_f128 = target_info.supports_target_dependent_type(CType::Float128);