Auto merge of #157981 - JonathanBrouwer:rollup-NojNbtG, r=<try>

Rollup of 12 pull requests


try-job: dist-various-1
try-job: test-various
try-job: x86_64-gnu-aux
try-job: x86_64-gnu-llvm-21-3
try-job: x86_64-msvc-1
try-job: aarch64-apple
try-job: x86_64-mingw-1
try-job: i686-msvc-2

Author: bors

compiler/rustc_builtin_macros/src/deriving/cmp/partial_eq.rs

@@ -22,7 +22,10 @@ pub(crate) fn expand_deriving_partial_eq(
         path: path_std!(marker::StructuralPartialEq),
         skip_path_as_bound: true, // crucial!
         needs_copy_as_bound_if_packed: false,
-        additional_bounds: Vec::new(),
+        // The `StructuralPartialEq` impl must have the *same* bounds as the `PartialEq` impl,
+        // or it will apply in situations where it should not, such as in the bug
+        // <https://github.com/rust-lang/rust/issues/147714>.
+        additional_bounds: vec![ty::Ty::Path(path_std!(cmp::PartialEq))],
         // We really don't support unions, but that's already checked by the impl generated below;
         // a second check here would lead to redundant error messages.
         supports_unions: true,

compiler/rustc_codegen_ssa/src/back/archive.rs

@@ -1,3 +1,4 @@
+use std::borrow::Cow;
 use std::env;
 use std::error::Error;
 use std::ffi::OsString;
@@ -22,7 +23,7 @@ use tracing::trace;
 
 use super::metadata::{create_compressed_metadata_file, search_for_section};
 use super::rmeta_link;
-use super::symbol_edit::apply_hide;
+use super::symbol_edit::{apply_edits, collect_internal_names};
 use crate::common;
 // Public for ArchiveBuilderBuilder::extract_bundled_libs
 pub use crate::errors::ExtractBundledLibsError;
@@ -314,12 +315,18 @@ pub enum AddArchiveKind<'a> {
     Other,
 }
 
+pub struct ArchiveSymbols {
+    pub exported: FxHashSet<String>,
+    pub rename_suffix: Option<String>,
+    pub hide: bool,
+}
+
 pub trait ArchiveBuilder {
     fn add_file(&mut self, path: &Path, kind: ArchiveEntryKind);
 
     fn add_archive(&mut self, archive: &Path, kind: AddArchiveKind<'_>) -> io::Result<()>;
 
-    fn build(self: Box<Self>, output: &Path, exported_symbols: Option<FxHashSet<String>>) -> bool;
+    fn build(self: Box<Self>, output: &Path, symbols: Option<ArchiveSymbols>) -> bool;
 }
 
 fn target_archive_format_to_object_kind(format: &str) -> Option<ObjectArchiveKind> {
@@ -534,9 +541,9 @@ impl<'a> ArchiveBuilder for ArArchiveBuilder<'a> {
 
     /// Combine the provided files, rlibs, and native libraries into a single
     /// `Archive`.
-    fn build(self: Box<Self>, output: &Path, exported_symbols: Option<FxHashSet<String>>) -> bool {
+    fn build(self: Box<Self>, output: &Path, symbols: Option<ArchiveSymbols>) -> bool {
         let sess = self.sess;
-        match self.build_inner(output, exported_symbols) {
+        match self.build_inner(output, symbols) {
             Ok(any_members) => any_members,
             Err(error) => {
                 sess.dcx().emit_fatal(ArchiveBuildFailure { path: output.to_owned(), error })
@@ -546,11 +553,7 @@ impl<'a> ArchiveBuilder for ArArchiveBuilder<'a> {
 }
 
 impl<'a> ArArchiveBuilder<'a> {
-    fn build_inner(
-        self,
-        output: &Path,
-        exported_symbols: Option<FxHashSet<String>>,
-    ) -> io::Result<bool> {
+    fn build_inner(self, output: &Path, symbols: Option<ArchiveSymbols>) -> io::Result<bool> {
         let archive_kind = match &*self.sess.target.archive_format {
             "gnu" => ArchiveKind::Gnu,
             "bsd" => ArchiveKind::Bsd,
@@ -562,6 +565,39 @@ impl<'a> ArArchiveBuilder<'a> {
             }
         };
 
+        // Collect all internally-defined symbol names across every Rust object file.
+        // This set is needed because rename must also apply to *undefined* references
+        // (cross-object calls within the staticlib), but we cannot use `!exported.contains(name)`
+        // alone — that would also match external C symbols like `malloc` which must not be renamed.
+        let rename = if let Some(sym) = &symbols
+            && let Some(rename_suffix) = sym.rename_suffix.as_deref()
+        {
+            let mut names = FxHashSet::default();
+            for (_, entry) in &self.entries {
+                if entry.kind != ArchiveEntryKind::RustObj {
+                    continue;
+                }
+                match &entry.source {
+                    ArchiveEntrySource::Archive { archive_index, file_range } => {
+                        let src_archive = &self.src_archives[*archive_index];
+                        let start = file_range.0 as usize;
+                        let end = start + file_range.1 as usize;
+                        if let Some(data) = src_archive.1.get(start..end) {
+                            collect_internal_names(data, &sym.exported, &mut names);
+                        }
+                    }
+                    ArchiveEntrySource::File(file) => {
+                        if let Ok(data) = fs::read(file) {
+                            collect_internal_names(&data, &sym.exported, &mut names);
+                        }
+                    }
+                }
+            }
+            Some((names, rename_suffix))
+        } else {
+            None
+        };
+
         let mut entries = Vec::new();
 
         for (entry_name, entry) in self.entries {
@@ -588,9 +624,9 @@ impl<'a> ArArchiveBuilder<'a> {
                     };
 
                     if entry.kind == ArchiveEntryKind::RustObj
-                        && let Some(exported) = &exported_symbols
+                        && let Some(sym) = &symbols
                     {
-                        Box::new(apply_hide(data, exported))
+                        Box::new(apply_edits(data, &sym.exported, sym.hide, rename.as_ref()))
                     } else {
                         Box::new(data)
                     }
@@ -602,9 +638,13 @@ impl<'a> ArArchiveBuilder<'a> {
                     )
                     .map_err(|err| io_error_context("failed to map object file", err))?;
                     if entry.kind == ArchiveEntryKind::RustObj
-                        && let Some(exported) = &exported_symbols
+                        && let Some(sym) = &symbols
                     {
-                        Box::new(apply_hide(&mmap, exported))
+                        let edited = apply_edits(&mmap, &sym.exported, sym.hide, rename.as_ref());
+                        match edited {
+                            Cow::Borrowed(_) => Box::new(mmap) as Box<dyn AsRef<[u8]>>,
+                            Cow::Owned(v) => Box::new(v),
+                        }
                     } else {
                         Box::new(mmap) as Box<dyn AsRef<[u8]>>
                     }

compiler/rustc_codegen_ssa/src/back/link.rs

@@ -47,13 +47,15 @@ use rustc_session::{Session, filesearch};
 use rustc_span::Symbol;
 use rustc_target::spec::crt_objects::CrtObjects;
 use rustc_target::spec::{
-    BinaryFormat, Cc, CfgAbi, Env, LinkOutputKind, LinkSelfContainedComponents,
+    Arch, BinaryFormat, Cc, CfgAbi, Env, LinkOutputKind, LinkSelfContainedComponents,
     LinkSelfContainedDefault, LinkerFeatures, LinkerFlavor, LinkerFlavorCli, Lld, Os, RelocModel,
     RelroLevel, SanitizerSet, SplitDebuginfo,
 };
 use tracing::{debug, info, warn};
 
-use super::archive::{AddArchiveKind, ArchiveBuilder, ArchiveBuilderBuilder, ArchiveEntryKind};
+use super::archive::{
+    AddArchiveKind, ArchiveBuilder, ArchiveBuilderBuilder, ArchiveEntryKind, ArchiveSymbols,
+};
 use super::command::Command;
 use super::linker::{self, Linker};
 use super::metadata::{MetadataPosition, create_wrapper_file};
@@ -566,11 +568,21 @@ fn link_staticlib(
         sess.dcx().emit_fatal(e);
     }
 
-    let exported_symbols = if sess.opts.unstable_opts.staticlib_hide_internal_symbols {
+    let hide = sess.opts.unstable_opts.staticlib_hide_internal_symbols;
+    let rename = sess.opts.unstable_opts.staticlib_rename_internal_symbols;
+
+    let exported_symbols = if hide || rename {
         if !matches!(sess.target.binary_format, BinaryFormat::Elf | BinaryFormat::MachO) {
-            sess.dcx().emit_warn(errors::StaticlibHideInternalSymbolsUnsupported {
-                binary_format: sess.target.archive_format.to_string(),
-            });
+            if hide {
+                sess.dcx().emit_warn(errors::StaticlibHideInternalSymbolsUnsupported {
+                    binary_format: sess.target.archive_format.to_string(),
+                });
+            }
+            if rename {
+                sess.dcx().emit_warn(errors::StaticlibRenameInternalSymbolsUnsupported {
+                    binary_format: sess.target.archive_format.to_string(),
+                });
+            }
             None
         } else {
             crate_info
@@ -581,7 +593,14 @@ fn link_staticlib(
     } else {
         None
     };
-    ab.build(out_filename, exported_symbols);
+
+    let symbols = exported_symbols.map(|exported| ArchiveSymbols {
+        exported,
+        rename_suffix: rename.then(|| crate_info.symbol_rename_suffix.clone()),
+        hide,
+    });
+
+    ab.build(out_filename, symbols);
 
     let crates = crate_info.used_crates.iter();
 
@@ -2394,6 +2413,69 @@ 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,
+    kind: SymbolExportKind,
+) -> Option<&'a str> {
+    match sess.target.binary_format {
+        BinaryFormat::MachO => {
+            // Mach-O: strip the leading underscore that all external symbols have.
+            // The Darwin linker's export_symbols will add it back.
+            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);
+            }
+            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),
+    }
+}
+
 fn add_c_staticlib_symbols(
     sess: &Session,
     lib: &NativeLib,
@@ -2435,7 +2517,14 @@ fn add_c_staticlib_symbols(
         }
 
         for symbol in object.symbols() {
-            if symbol.scope() != object::SymbolScope::Dynamic {
+            // The `object` crate returns `Dynamic` for ELF/Mach-O global symbols,
+            // but always returns `Linkage` for COFF external symbols.
+            // Accept both for COFF (Windows and UEFI).
+            let scope = symbol.scope();
+            if scope != object::SymbolScope::Dynamic
+                && !(sess.target.binary_format == BinaryFormat::Coff
+                    && scope == object::SymbolScope::Linkage)
+            {
                 continue;
             }
 
@@ -2450,9 +2539,10 @@ fn add_c_staticlib_symbols(
                 _ => continue,
             };
 
-            // FIXME:The symbol mangle rules are slightly different in Windows(32-bit) and Apple.
-            // Need to be resolved.
-            out.push((name.to_string(), export_kind));
+            let Some(undecorated) = undecorate_c_symbol(name, sess, export_kind) else {
+                continue;
+            };
+            out.push((undecorated.to_string(), export_kind));
         }
     }