Rollup of 19 pull requests

compiler/rustc_abi/src/layout.rs

@@ -198,6 +198,7 @@ impl<Cx: HasDataLayout> LayoutCalculator<Cx> {
             size,
             max_repr_align: None,
             unadjusted_abi_align: element.align.abi,
+            repr_c: element.repr_c,
             randomization_seed: element.randomization_seed.wrapping_add(Hash64::new(count)),
         })
     }
@@ -501,6 +502,10 @@ impl<Cx: HasDataLayout> LayoutCalculator<Cx> {
             return Err(LayoutCalculatorError::EmptyUnion);
         };
 
+        // We also need to check for a `repr(transparent)` wrapper around `repr(C)`
+        let repr_c =
+            repr.c() || (repr.transparent() && only_variant.iter().any(|field| field.repr_c));
+
         let combined_seed = only_variant
             .iter()
             .map(|v| v.randomization_seed)
@@ -516,6 +521,7 @@ impl<Cx: HasDataLayout> LayoutCalculator<Cx> {
             size: size.align_to(align),
             max_repr_align,
             unadjusted_abi_align,
+            repr_c,
             randomization_seed: combined_seed,
         })
     }
@@ -747,6 +753,7 @@ impl<Cx: HasDataLayout> LayoutCalculator<Cx> {
                 align: AbiAlign::new(align),
                 max_repr_align,
                 unadjusted_abi_align,
+                repr_c: repr.c(),
                 randomization_seed: combined_seed,
             };
 
@@ -1055,6 +1062,7 @@ impl<Cx: HasDataLayout> LayoutCalculator<Cx> {
             size,
             max_repr_align,
             unadjusted_abi_align,
+            repr_c: repr.c(),
             randomization_seed: combined_seed,
         };
 
@@ -1409,6 +1417,9 @@ impl<Cx: HasDataLayout> LayoutCalculator<Cx> {
             unadjusted_abi_align
         };
 
+        // We also need to check for a `repr(transparent)` wrapper around `repr(C)`
+        let repr_c = repr.c() || (repr.transparent() && fields.iter().any(|field| field.repr_c));
+
         let seed = field_seed.wrapping_add(repr.field_shuffle_seed);
 
         Ok(LayoutData {
@@ -1421,6 +1432,7 @@ impl<Cx: HasDataLayout> LayoutCalculator<Cx> {
             size,
             max_repr_align,
             unadjusted_abi_align,
+            repr_c,
             randomization_seed: seed,
         })
     }
@@ -1519,6 +1531,7 @@ where
         align: AbiAlign::new(align),
         max_repr_align: None,
         unadjusted_abi_align: elt.align.abi,
+        repr_c: false,
         randomization_seed: elt.randomization_seed.wrapping_add(Hash64::new(count.as_u64())),
     })
 }

compiler/rustc_abi/src/layout/coroutine.rs

@@ -313,6 +313,7 @@ where
         align,
         max_repr_align: None,
         unadjusted_abi_align: align.abi,
+        repr_c: false,
         randomization_seed: Default::default(),
     })
 }

compiler/rustc_abi/src/layout/simple.rs

@@ -25,6 +25,7 @@ impl<FieldIdx: Idx, VariantIdx: Idx> LayoutData<FieldIdx, VariantIdx> {
             size: Size::ZERO,
             max_repr_align: None,
             unadjusted_abi_align: dl.i8_align,
+            repr_c: false,
             randomization_seed: Hash64::new(0),
         }
     }
@@ -42,6 +43,7 @@ impl<FieldIdx: Idx, VariantIdx: Idx> LayoutData<FieldIdx, VariantIdx> {
             size: Size::ZERO,
             max_repr_align: None,
             unadjusted_abi_align: dl.i8_align,
+            repr_c: false,
             randomization_seed: Hash64::ZERO,
         }
     }
@@ -84,6 +86,7 @@ impl<FieldIdx: Idx, VariantIdx: Idx> LayoutData<FieldIdx, VariantIdx> {
             align,
             max_repr_align: None,
             unadjusted_abi_align: align.abi,
+            repr_c: false,
             randomization_seed: Hash64::new(randomization_seed),
         }
     }
@@ -117,6 +120,7 @@ impl<FieldIdx: Idx, VariantIdx: Idx> LayoutData<FieldIdx, VariantIdx> {
             size,
             max_repr_align: None,
             unadjusted_abi_align: align,
+            repr_c: false,
             randomization_seed: Hash64::new(combined_seed),
         }
     }
@@ -143,6 +147,7 @@ impl<FieldIdx: Idx, VariantIdx: Idx> LayoutData<FieldIdx, VariantIdx> {
             size: Size::ZERO,
             max_repr_align: None,
             unadjusted_abi_align: dl.i8_align,
+            repr_c: false,
             // Variant layouts never flow back into actual layout computations,
             // so dummy values are fine here.
             randomization_seed: Hash64::ZERO,
@@ -169,6 +174,7 @@ impl<FieldIdx: Idx, VariantIdx: Idx> LayoutData<FieldIdx, VariantIdx> {
             align: parent.align,
             max_repr_align: parent.max_repr_align,
             unadjusted_abi_align: parent.unadjusted_abi_align,
+            repr_c: parent.repr_c,
             // Variant layouts never flow back into actual layout computations,
             // so dummy values are fine here.
             randomization_seed: Hash64::ZERO,

compiler/rustc_abi/src/lib.rs

@@ -2264,6 +2264,13 @@ pub struct LayoutData<FieldIdx: Idx, VariantIdx: Idx> {
     /// alignment in some cases.
     pub unadjusted_abi_align: Align,
 
+    /// Whether this type is `repr(C)`, or a `repr(transparent)` wrapper around such,
+    /// or an array of such.
+    /// This matters because we must follow the C ABI for these types.
+    /// Some C ABIs pass `repr(C)` ZSTs by pointer, but `repr(Rust)` ZSTs should always
+    /// be ignored.
+    pub repr_c: bool,
+
     /// The randomization seed based on this type's own repr and its fields.
     ///
     /// Since randomization is toggled on a per-crate basis even crates that do not have randomization
@@ -2303,6 +2310,12 @@ impl<FieldIdx: Idx, VariantIdx: Idx> LayoutData<FieldIdx, VariantIdx> {
             }
         }
     }
+
+    /// Returns `true` if this is a `repr(C)` type,
+    /// or an array of such, or a `repr(transparent)` wrapper around such
+    pub fn is_repr_c(&self) -> bool {
+        self.repr_c
+    }
 }
 
 impl<FieldIdx: Idx, VariantIdx: Idx> fmt::Debug for LayoutData<FieldIdx, VariantIdx>
@@ -2324,6 +2337,7 @@ where
             variants,
             max_repr_align,
             unadjusted_abi_align,
+            repr_c,
             randomization_seed,
         } = self;
         f.debug_struct("Layout")
@@ -2336,6 +2350,7 @@ where
             .field("variants", variants)
             .field("max_repr_align", max_repr_align)
             .field("unadjusted_abi_align", unadjusted_abi_align)
+            .field("repr_c", repr_c)
             .field("randomization_seed", randomization_seed)
             .finish()
     }

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,