Rollup of 8 pull requests

compiler/rustc_codegen_ssa/src/back/link.rs

@@ -44,7 +44,7 @@ use rustc_span::{Symbol, bug};
 use rustc_structures::{CrateType, NativeLibKind};
 use rustc_target::spec::crt_objects::CrtObjects;
 use rustc_target::spec::{
-    Arch, BinaryFormat, Cc, CfgAbi, Env, LinkOutputKind, LinkSelfContainedComponents,
+    BinaryFormat, Cc, CfgAbi, Env, LinkOutputKind, LinkSelfContainedComponents,
     LinkSelfContainedDefault, LinkerFeatures, LinkerFlavor, LinkerFlavorCli, Lld, Os, RelocModel,
     RelroLevel, SanitizerSet, SplitDebuginfo,
 };
@@ -58,7 +58,7 @@ use super::linker::{self, Linker};
 use super::metadata::{MetadataPosition, create_wrapper_file};
 use super::rmeta_link::RmetaLinkCache;
 use super::rpath::{self, RPathConfig};
-use super::{apple, rmeta_link, versioned_llvm_target};
+use super::{apple, rmeta_link, symbol_export, versioned_llvm_target};
 use crate::base::needs_allocator_shim_for_linking;
 use crate::{
     CodegenLintLevelSpecs, CompiledModule, CompiledModules, CrateInfo, NativeLib, SymbolExport,
@@ -2759,10 +2759,6 @@ fn add_rpath_args(
     }
 }
 
-fn strip_numeric_suffix<'a>(base: &'a str, suffix: impl AsRef<str>, fallback: &'a str) -> &'a str {
-    if suffix.as_ref().parse::<u32>().is_ok() { base } else { fallback }
-}
-
 fn undecorate_c_symbol<'a>(
     name: &'a str,
     sess: &Session,
@@ -2775,47 +2771,11 @@ fn undecorate_c_symbol<'a>(
             name.strip_prefix('_')
         }
         BinaryFormat::Coff => {
-            // MSVC C++ mangled names start with '?' and use a completely different
-            // decorating scheme that includes '@@' as structural delimiters.
-            // They must not be subjected to C calling-convention undecoration.
-            if name.starts_with('?') {
-                return Some(name);
+            // COFF undecoration is shared with `symbol_edit`'s binary-level matching.
+            match symbol_export::coff_machine_for_arch(&sess.target.arch) {
+                Some(machine) => Some(symbol_export::undecorate_coff_symbol(name, machine, kind)),
+                None => Some(name),
             }
-            Some(match sess.target.arch {
-                Arch::X86 => {
-                    // COFF 32-bit: strip calling-convention decorations.
-                    if let Some(rest) = name.strip_prefix('@') {
-                        // fastcall: @foo@N -> foo
-                        rest.rsplit_once('@')
-                            .map(|(base, suffix)| strip_numeric_suffix(base, suffix, name))
-                            .unwrap_or(name)
-                    } else if let Some(stripped) = name.strip_prefix('_') {
-                        if let Some((base, suffix)) = stripped.rsplit_once('@') {
-                            // stdcall: _foo@N -> foo
-                            strip_numeric_suffix(base, suffix, stripped)
-                        } else {
-                            // cdecl: _foo -> foo
-                            stripped
-                        }
-                    } else {
-                        // vectorcall: foo@@N -> foo
-                        name.rsplit_once("@@")
-                            .map(|(base, suffix)| strip_numeric_suffix(base, suffix, name))
-                            .unwrap_or(name)
-                    }
-                }
-                Arch::X86_64 => {
-                    // COFF 64-bit: vectorcall mangling (foo@@N -> foo) also applies on x86_64.
-                    name.rsplit_once("@@")
-                        .map(|(base, suffix)| strip_numeric_suffix(base, suffix, name))
-                        .unwrap_or(name)
-                }
-                Arch::Arm64EC if kind == SymbolExportKind::Text => {
-                    // Arm64EC: `#` prefix distinguishes ARM64EC text symbols from x64 thunks.
-                    name.strip_prefix('#').unwrap_or(name)
-                }
-                _ => name,
-            })
         }
         // ELF: no decoration
         _ => Some(name),

compiler/rustc_codegen_ssa/src/back/symbol_edit.rs

@@ -12,6 +12,9 @@ use object::read::elf::{SectionHeader as _, Sym as _};
 use object::read::macho::Nlist;
 use object::{Endianness, elf, macho, pe};
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
+use rustc_middle::middle::exported_symbols::SymbolExportKind;
+
+use super::symbol_export::undecorate_coff_symbol;
 
 struct Patch {
     offset: usize,
@@ -58,20 +61,8 @@ pub(super) fn apply_edits<'a>(
             rename,
             mem::offset_of!(macho::Nlist32<Endianness>, n_type),
         ),
-        Some(object::File::Coff(f)) => coff_edit_impl(
-            data,
-            f.coff_header(),
-            hide,
-            rename,
-            coff_strip_underscore(f.coff_header()),
-        ),
-        Some(object::File::CoffBig(f)) => coff_edit_impl(
-            data,
-            f.coff_header(),
-            hide,
-            rename,
-            coff_strip_underscore(f.coff_header()),
-        ),
+        Some(object::File::Coff(f)) => coff_edit_impl(data, f.coff_header(), hide, rename),
+        Some(object::File::CoffBig(f)) => coff_edit_impl(data, f.coff_header(), hide, rename),
         _ => None,
     };
     match result {
@@ -99,28 +90,20 @@ pub(super) fn collect_internal_names(
         object::File::MachO32(_) => {
             macho_collect_impl::<macho::MachHeader32<Endianness>>(data, exported, out)
         }
-        object::File::Coff(f) => coff_collect_impl(
-            data,
-            f.coff_header(),
-            exported,
-            out,
-            coff_strip_underscore(f.coff_header()),
-        ),
-        object::File::CoffBig(f) => coff_collect_impl(
-            data,
-            f.coff_header(),
-            exported,
-            out,
-            coff_strip_underscore(f.coff_header()),
-        ),
+        object::File::Coff(f) => coff_collect_impl(data, f.coff_header(), exported, out),
+        object::File::CoffBig(f) => coff_collect_impl(data, f.coff_header(), exported, out),
         _ => {}
     }
 }
 
-/// Whether this machine's COFF ABI decorates external symbols with a leading `_`
-/// (i686 only).
-fn coff_strip_underscore(header: &impl CoffHeader) -> bool {
-    header.machine() == pe::IMAGE_FILE_MACHINE_I386
+/// The `SymbolExportKind` of a COFF symbol, so `#`-prefixed `Arm64EC` text symbols are told
+/// apart from data symbols during undecoration.
+fn coff_symbol_kind(sym: &impl object::read::coff::ImageSymbol) -> SymbolExportKind {
+    if sym.derived_type() == pe::IMAGE_SYM_DTYPE_FUNCTION {
+        SymbolExportKind::Text
+    } else {
+        SymbolExportKind::Data
+    }
 }
 
 fn elf_collect_impl<Elf: object::read::elf::FileHeader<Endian = Endianness>>(
@@ -485,10 +468,10 @@ fn coff_collect_impl<'data, Coff: CoffHeader>(
     header: &'data Coff,
     exported: &FxHashSet<String>,
     out: &mut FxHashSet<String>,
-    strip_underscore: bool,
 ) {
     let Ok(symbols) = header.symbols(data) else { return };
     let strings = symbols.strings();
+    let machine = header.machine();
 
     for (_index, sym) in symbols.iter() {
         let sclass = sym.storage_class();
@@ -499,15 +482,10 @@ fn coff_collect_impl<'data, Coff: CoffHeader>(
             continue;
         }
         let Ok(name_bytes) = sym.name(strings) else { continue };
-        let Ok(mut name) = str::from_utf8(name_bytes).map(String::from) else { continue };
-        if strip_underscore {
-            name = name.strip_prefix('_').unwrap_or(&name).to_string();
-        }
-        let is_exported = exported.contains(&name)
-            || (header.machine() == pe::IMAGE_FILE_MACHINE_ARM64EC
-                && name.strip_prefix('#').is_some_and(|name| exported.contains(name)));
-        if !is_exported {
-            out.insert(name);
+        let Ok(name) = str::from_utf8(name_bytes) else { continue };
+        let name = undecorate_coff_symbol(name, machine, coff_symbol_kind(sym));
+        if !exported.contains(name) {
+            out.insert(name.to_string());
         }
     }
 }
@@ -517,7 +495,6 @@ fn coff_edit_impl<'data, Coff: CoffHeader>(
     header: &'data Coff,
     hide: bool,
     rename: Option<&(FxHashSet<String>, &str)>,
-    strip_underscore: bool,
 ) -> Option<Vec<u8>> {
     // COFF has no visibility concept, so hiding is unsupported; the caller
     // has already warned and does not request it.
@@ -545,6 +522,7 @@ fn coff_edit_impl<'data, Coff: CoffHeader>(
 
     let Ok(symbols) = header.symbols(data) else { return None };
     let strings = symbols.strings();
+    let machine = header.machine();
 
     let mut renames = Vec::new();
     for (index, sym) in symbols.iter() {
@@ -554,8 +532,7 @@ fn coff_edit_impl<'data, Coff: CoffHeader>(
         }
         let Ok(name_bytes) = sym.name(strings) else { continue };
         let Ok(name) = str::from_utf8(name_bytes) else { continue };
-        let check_name =
-            if strip_underscore { name.strip_prefix('_').unwrap_or(name) } else { name };
+        let check_name = undecorate_coff_symbol(name, machine, coff_symbol_kind(sym));
         if rename.is_some_and(|(rename_set, _)| rename_set.contains(check_name)) {
             renames.push(RenameEntry {
                 name_field_offset: symbol_bytes_offset + index.0 * sym_size,

compiler/rustc_codegen_ssa/src/back/symbol_export.rs

@@ -1,5 +1,6 @@
 use std::collections::hash_map::Entry::*;
 
+use object::pe;
 use rustc_abi::{CanonAbi, X86Call};
 use rustc_ast::expand::allocator::{AllocatorKind, NO_ALLOC_SHIM_IS_UNSTABLE, global_fn_name};
 use rustc_crate_store::CrateDepKind;
@@ -813,6 +814,68 @@ pub(crate) fn exporting_symbol_name_for_instance_in_crate<'tcx>(
     maybe_emutls_symbol_name(tcx, symbol, &undecorated).unwrap_or(undecorated)
 }
 
+fn strip_numeric_suffix<'a>(base: &'a str, suffix: impl AsRef<str>, fallback: &'a str) -> &'a str {
+    if suffix.as_ref().parse::<u32>().is_ok() { base } else { fallback }
+}
+
+/// COFF `IMAGE_FILE_MACHINE_*` for an arch with decorated symbols, or `None`.
+pub(super) fn coff_machine_for_arch(arch: &Arch) -> Option<u16> {
+    match *arch {
+        Arch::X86 => Some(pe::IMAGE_FILE_MACHINE_I386),
+        Arch::X86_64 => Some(pe::IMAGE_FILE_MACHINE_AMD64),
+        Arch::Arm64EC => Some(pe::IMAGE_FILE_MACHINE_ARM64EC),
+        _ => None,
+    }
+}
+
+/// Undecorated counterpart of [`linking_symbol_name_for_instance_in_crate`].
+pub(super) fn undecorate_coff_symbol<'a>(
+    name: &'a str,
+    machine: u16,
+    kind: SymbolExportKind,
+) -> &'a str {
+    // MSVC C++ mangled names start with '?' and use a completely different
+    // decorating scheme that includes '@@' as structural delimiters.
+    // They must not be subjected to C calling-convention undecoration.
+    if name.starts_with('?') {
+        return name;
+    }
+    match machine {
+        pe::IMAGE_FILE_MACHINE_I386 => {
+            if let Some(rest) = name.strip_prefix('@') {
+                // fastcall: @foo@N -> foo
+                rest.rsplit_once('@')
+                    .map(|(base, suffix)| strip_numeric_suffix(base, suffix, name))
+                    .unwrap_or(name)
+            } else if let Some(stripped) = name.strip_prefix('_') {
+                if let Some((base, suffix)) = stripped.rsplit_once('@') {
+                    // stdcall: _foo@N -> foo
+                    strip_numeric_suffix(base, suffix, stripped)
+                } else {
+                    // cdecl: _foo -> foo
+                    stripped
+                }
+            } else {
+                // vectorcall: foo@@N -> foo
+                name.rsplit_once("@@")
+                    .map(|(base, suffix)| strip_numeric_suffix(base, suffix, name))
+                    .unwrap_or(name)
+            }
+        }
+        pe::IMAGE_FILE_MACHINE_AMD64 => {
+            // vectorcall: foo@@N -> foo
+            name.rsplit_once("@@")
+                .map(|(base, suffix)| strip_numeric_suffix(base, suffix, name))
+                .unwrap_or(name)
+        }
+        pe::IMAGE_FILE_MACHINE_ARM64EC if kind == SymbolExportKind::Text => {
+            // `#` prefix distinguishes ARM64EC text symbols from x64 thunks.
+            name.strip_prefix('#').unwrap_or(name)
+        }
+        _ => name,
+    }
+}
+
 /// On amdhsa, `gpu-kernel` functions have an associated metadata object with a `.kd` suffix.
 /// Add it to the symbols list for all kernel functions, so that it is exported in the linked
 /// object.

compiler/rustc_const_eval/src/const_eval/eval_queries.rs

@@ -519,6 +519,9 @@ fn report_eval_error<'tcx>(
                 where_ = if num_frames == 0 { "here" } else { "inside this call" },
             ),
         );
+        for span in crate::util::context_spans(*ecx.tcx, span, cid.instance.def_id()) {
+            diag.span_context(span);
+        }
         for frame in frames {
             diag.subdiagnostic(frame);
         }

compiler/rustc_const_eval/src/diagnostics.rs

@@ -310,6 +310,7 @@ pub(crate) struct NonConstImplNote {
 #[derive(Clone)]
 pub(crate) struct FrameNote {
     pub span: Span,
+    pub span_context: Vec<Span>,
     pub times: i32,
     pub where_: &'static str,
     pub instance: String,
@@ -322,6 +323,9 @@ impl Subdiagnostic for FrameNote {
         if self.has_label && !self.span.is_dummy() {
             span.push_span_label(self.span, msg!("the failure occurred here"));
         }
+        for sp in &self.span_context {
+            span.push_span_context(*sp);
+        }
         let msg = msg!(
             r#"{$times ->
                 [0] inside {$where_ ->

compiler/rustc_const_eval/src/interpret/stack.rs

@@ -230,18 +230,21 @@ impl<'tcx> FrameInfo<'tcx> {
             diagnostics::FrameNote {
                 where_: "closure",
                 span,
+                span_context: vec![],
                 instance: String::new(),
                 times: 0,
                 has_label: false,
             }
         } else {
             let instance = format!("{}", self.instance);
+            let span_context = crate::util::context_spans(tcx, span, self.instance.def_id());
             // Note: this triggers a `must_produce_diag` state, which means that if we ever get
             // here we must emit a diagnostic. We should never display a `FrameInfo` unless we
             // actually want to emit a warning or error to the user.
             diagnostics::FrameNote {
                 where_: "instance",
                 span,
+                span_context,
                 instance,
                 times: 0,
                 has_label: false,