add -Zstaticlib-rename-internal-symbols

Author: cezarbbb

compiler/rustc_codegen_ssa/src/back/archive.rs

@@ -1,18 +1,16 @@
+use std::env;
 use std::error::Error;
 use std::ffi::OsString;
 use std::fs::{self, File};
 use std::io::{self, BufWriter, Write};
 use std::path::{Path, PathBuf};
-use std::{env, mem};
 
 use ar_archive_writer::{
     ArchiveKind, COFFShortExport, MachineTypes, NewArchiveMember, write_archive_to_stream,
 };
 pub use ar_archive_writer::{DEFAULT_OBJECT_READER, ObjectReader};
 use object::read::archive::{ArchiveFile, ArchiveKind as ObjectArchiveKind};
-use object::read::elf::Sym as _;
-use object::read::macho::{FatArch, Nlist};
-use object::{Endianness, elf, macho};
+use object::read::macho::FatArch;
 use rustc_data_structures::fx::{FxHashSet, FxIndexSet};
 use rustc_data_structures::memmap::Mmap;
 use rustc_fs_util::TempDirBuilder;
@@ -24,6 +22,7 @@ use tracing::trace;
 
 use super::metadata::{create_compressed_metadata_file, search_for_section};
 use super::rmeta_link;
+use super::symbol_edit::{apply_hide, collect_internal_set, rename_impl};
 use crate::common;
 // Public for ArchiveBuilderBuilder::extract_bundled_libs
 pub use crate::errors::ExtractBundledLibsError;
@@ -320,7 +319,13 @@ pub trait ArchiveBuilder {
 
     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,
+        exported_symbols: Option<FxHashSet<String>>,
+        rename_suffix: Option<String>,
+        hide: bool,
+    ) -> bool;
 }
 
 fn target_archive_format_to_object_kind(format: &str) -> Option<ObjectArchiveKind> {
@@ -535,9 +540,15 @@ 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,
+        exported_symbols: Option<FxHashSet<String>>,
+        rename_suffix: Option<String>,
+        hide: bool,
+    ) -> bool {
         let sess = self.sess;
-        match self.build_inner(output, exported_symbols) {
+        match self.build_inner(output, exported_symbols, rename_suffix, hide) {
             Ok(any_members) => any_members,
             Err(error) => {
                 sess.dcx().emit_fatal(ArchiveBuildFailure { path: output.to_owned(), error })
@@ -551,6 +562,8 @@ impl<'a> ArArchiveBuilder<'a> {
         self,
         output: &Path,
         exported_symbols: Option<FxHashSet<String>>,
+        rename_suffix: Option<String>,
+        hide: bool,
     ) -> io::Result<bool> {
         let archive_kind = match &*self.sess.target.archive_format {
             "gnu" => ArchiveKind::Gnu,
@@ -563,6 +576,37 @@ impl<'a> ArArchiveBuilder<'a> {
             }
         };
 
+        // Rename requires a two-pass approach: first collect all internal symbols
+        // across all .o files to ensure consistent renaming, then apply.
+        let global_rename_set = if let Some(suffix) = &rename_suffix
+            && let Some(exported) = &exported_symbols
+        {
+            let mut all_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_set(data, exported, &mut all_names);
+                        }
+                    }
+                    ArchiveEntrySource::File(file) => {
+                        if let Ok(data) = std::fs::read(file) {
+                            collect_internal_set(&data, exported, &mut all_names);
+                        }
+                    }
+                }
+            }
+            Some((all_names, suffix.as_str()))
+        } else {
+            None
+        };
+
         let mut entries = Vec::new();
 
         for (entry_name, entry) in self.entries {
@@ -588,10 +632,18 @@ impl<'a> ArArchiveBuilder<'a> {
                         ));
                     };
 
-                    if entry.kind == ArchiveEntryKind::RustObj
-                        && let Some(exported) = &exported_symbols
-                    {
-                        Box::new(apply_hide(data, exported))
+                    if entry.kind == ArchiveEntryKind::RustObj {
+                        let renamed = global_rename_set
+                            .as_ref()
+                            .and_then(|(rename_set, suffix)| rename_impl(data, rename_set, suffix));
+                        if hide && let Some(exported) = &exported_symbols {
+                            let src = renamed.as_deref().unwrap_or(data);
+                            Box::new(apply_hide(src, exported))
+                        } else if let Some(renamed) = renamed {
+                            Box::new(renamed)
+                        } else {
+                            Box::new(data)
+                        }
                     } else {
                         Box::new(data)
                     }
@@ -602,10 +654,22 @@ impl<'a> ArArchiveBuilder<'a> {
                             .map_err(|err| io_error_context("failed to open object file", err))?,
                     )
                     .map_err(|err| io_error_context("failed to map object file", err))?;
-                    if entry.kind == ArchiveEntryKind::RustObj
-                        && let Some(exported) = &exported_symbols
-                    {
-                        Box::new(apply_hide(&mmap, exported))
+                    if entry.kind == ArchiveEntryKind::RustObj {
+                        let renamed =
+                            global_rename_set.as_ref().and_then(|(rename_set, suffix)| {
+                                rename_impl(&mmap, rename_set, suffix)
+                            });
+                        if hide && let Some(exported) = &exported_symbols {
+                            let src = match &renamed {
+                                Some(v) => v.as_slice(),
+                                None => &*mmap,
+                            };
+                            Box::new(apply_hide(src, exported))
+                        } else if let Some(renamed) = renamed {
+                            Box::new(renamed)
+                        } else {
+                            Box::new(mmap) as Box<dyn AsRef<[u8]>>
+                        }
                     } else {
                         Box::new(mmap) as Box<dyn AsRef<[u8]>>
                     }
@@ -671,153 +735,3 @@ impl<'a> ArArchiveBuilder<'a> {
 fn io_error_context(context: &str, err: io::Error) -> io::Error {
     io::Error::new(io::ErrorKind::Other, format!("{context}: {err}"))
 }
-
-// We use the `object` crate for the read-only pass over ELF/Mach-O object files
-// because its `Sym`/`Nlist` traits provide clean access to symbol properties without
-// manual byte parsing. However, `object` does not expose mutable views into the data,
-// so we cannot use it to modify symbol fields in place. Instead, the read-only pass
-// collects byte-level patches (offset + new value), and the write pass
-// (`apply_patches`) applies them to a copy of the byte buffer without any ELF/Mach-O
-// parsing — similar to how linker relocations work.
-
-/// A byte-level patch collected in the read-only pass and applied in the write pass.
-struct Patch {
-    offset: usize,
-    value: u8,
-}
-
-/// Apply a list of byte patches to `data`, returning the (possibly modified) bytes.
-fn apply_patches(data: &[u8], patches: &[Patch]) -> Vec<u8> {
-    let mut buf = data.to_vec();
-    for p in patches {
-        buf[p.offset] = p.value;
-    }
-    buf
-}
-
-// ---------------------------------------------------------------------------
-// ELF hide – read-only pass uses `object` crate, write pass uses `Patch` list
-// ---------------------------------------------------------------------------
-
-fn elf_hide_patches_impl<'data, Elf: object::read::elf::FileHeader<Endian = Endianness>>(
-    data: &'data [u8],
-    st_other_offset: usize,
-    exported: &FxHashSet<String>,
-) -> Option<Vec<Patch>>
-where
-    u64: From<Elf::Word>,
-{
-    let header = Elf::parse(data).ok()?;
-    let endian = header.endian().ok()?;
-    let sections = header.sections(endian, data).ok()?;
-    let symtab = sections.symbols(endian, data, elf::SHT_SYMTAB).ok()?;
-
-    let data_ptr = data.as_ptr() as usize;
-    let strings = symtab.strings();
-    let mut patches = Vec::new();
-
-    for sym in symtab.iter() {
-        let binding = sym.st_bind();
-        if binding != elf::STB_GLOBAL && binding != elf::STB_WEAK {
-            continue;
-        }
-        if sym.is_undefined(endian) {
-            continue;
-        }
-        let Ok(name_bytes) = sym.name(endian, strings) else { continue };
-        let Ok(name) = str::from_utf8(name_bytes) else { continue };
-        if !exported.contains(name) {
-            let sym_addr = sym as *const Elf::Sym as usize;
-            let offset = sym_addr - data_ptr + st_other_offset;
-            let new_vis = (sym.st_other() & !0x03) | elf::STV_HIDDEN;
-            patches.push(Patch { offset, value: new_vis });
-        }
-    }
-
-    Some(patches)
-}
-
-// ---------------------------------------------------------------------------
-// Mach-O hide – same architecture: read-only pass via `object`, write via patches
-// ---------------------------------------------------------------------------
-
-fn macho_hide_patches_impl<'data, Mach: object::read::macho::MachHeader<Endian = Endianness>>(
-    data: &'data [u8],
-    n_type_offset: usize,
-    exported: &FxHashSet<String>,
-) -> Option<Vec<Patch>> {
-    let header = Mach::parse(data, 0).ok()?;
-    let endian = header.endian().ok()?;
-    let mut commands = header.load_commands(endian, data, 0).ok()?;
-
-    let symtab_cmd = loop {
-        let cmd = commands.next().ok()??;
-        if let Some(st) = cmd.symtab().ok().flatten() {
-            break st;
-        }
-    };
-    let symtab: object::read::macho::SymbolTable<'_, Mach, &_> =
-        symtab_cmd.symbols(endian, data).ok()?;
-
-    let data_ptr = data.as_ptr() as usize;
-    let strings = symtab.strings();
-    let mut patches = Vec::new();
-
-    for nlist in symtab.iter() {
-        if nlist.is_stab() {
-            continue;
-        }
-        if nlist.is_undefined() {
-            continue;
-        }
-        if nlist.n_type() & macho::N_EXT == 0 {
-            continue;
-        }
-        let Ok(name_bytes) = nlist.name(endian, strings) else { continue };
-        let Ok(name) = str::from_utf8(name_bytes) else { continue };
-        let name = name.strip_prefix('_').unwrap_or(name);
-        if !exported.contains(name) {
-            let nlist_addr = nlist as *const Mach::Nlist as usize;
-            let offset = nlist_addr - data_ptr + n_type_offset;
-            patches.push(Patch { offset, value: nlist.n_type() | macho::N_PEXT });
-        }
-    }
-
-    Some(patches)
-}
-
-// ---------------------------------------------------------------------------
-// Unified dispatch: top-level detection via `object::File::parse`
-// ---------------------------------------------------------------------------
-
-fn hide_patches(data: &[u8], exported: &FxHashSet<String>) -> Option<Vec<Patch>> {
-    let file = object::File::parse(data).ok()?;
-    match file {
-        object::File::Elf64(_) => elf_hide_patches_impl::<elf::FileHeader64<Endianness>>(
-            data,
-            mem::offset_of!(elf::Sym64<Endianness>, st_other),
-            exported,
-        ),
-        object::File::Elf32(_) => elf_hide_patches_impl::<elf::FileHeader32<Endianness>>(
-            data,
-            mem::offset_of!(elf::Sym32<Endianness>, st_other),
-            exported,
-        ),
-        object::File::MachO64(_) => macho_hide_patches_impl::<macho::MachHeader64<Endianness>>(
-            data,
-            mem::offset_of!(macho::Nlist64<Endianness>, n_type),
-            exported,
-        ),
-        object::File::MachO32(_) => macho_hide_patches_impl::<macho::MachHeader32<Endianness>>(
-            data,
-            mem::offset_of!(macho::Nlist32<Endianness>, n_type),
-            exported,
-        ),
-        _ => None,
-    }
-}
-
-fn apply_hide(data: &[u8], exported: &FxHashSet<String>) -> Vec<u8> {
-    let patches = hide_patches(data, exported).unwrap_or_default();
-    apply_patches(data, &patches)
-}

compiler/rustc_codegen_ssa/src/back/link.rs

@@ -131,7 +131,7 @@ pub fn link_binary(
                         RlibFlavor::Normal,
                         &path,
                     )
-                    .build(&out_filename, None);
+                    .build(&out_filename, None, None, false);
                 }
                 CrateType::StaticLib => {
                     link_staticlib(
@@ -566,11 +566,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 +591,15 @@ fn link_staticlib(
     } else {
         None
     };
-    ab.build(out_filename, exported_symbols);
+
+    let rename_suffix =
+        if rename && matches!(sess.target.binary_format, BinaryFormat::Elf | BinaryFormat::MachO) {
+            Some(crate_info.rename_suffix.clone())
+        } else {
+            None
+        };
+
+    ab.build(out_filename, exported_symbols, rename_suffix, hide);
 
     let crates = crate_info.used_crates.iter();
 
@@ -1280,7 +1298,7 @@ fn link_natively(
     if should_archive {
         let mut ab = archive_builder_builder.new_archive_builder(sess);
         ab.add_file(temp_filename, ArchiveEntryKind::Other);
-        ab.build(out_filename, None);
+        ab.build(out_filename, None, None, false);
     }
 }
 
@@ -3280,7 +3298,7 @@ fn add_static_crate(
             sess.dcx()
                 .emit_fatal(errors::RlibArchiveBuildFailure { path: cratepath.clone(), error });
         }
-        if archive.build(&dst, None) {
+        if archive.build(&dst, None, None, false) {
             link_upstream(&dst);
         }
     });

compiler/rustc_codegen_ssa/src/back/mod.rs

@@ -11,6 +11,7 @@ pub mod lto;
 pub mod metadata;
 pub mod rmeta_link;
 pub(crate) mod rpath;
+mod symbol_edit;
 pub mod symbol_export;
 pub mod write;