Staticlib hide internal symbols

compiler/rustc_codegen_ssa/src/back/link.rs

@@ -131,7 +131,7 @@ pub fn link_binary(
                         RlibFlavor::Normal,
                         &path,
                     )
-                    .build(&out_filename);
+                    .build(&out_filename, None);
                 }
                 CrateType::StaticLib => {
                     link_staticlib(
@@ -342,11 +342,11 @@ fn link_rlib<'a>(
                     // normal linkers for the platform. Sometimes this is not possible however.
                     // If it is possible however, placing the metadata object first improves
                     // performance of getting metadata from rlibs.
-                    ab.add_file(&metadata);
+                    ab.add_file(&metadata, false);
                     // Place the rmeta-link member immediately after metadata so consumers
                     // can find it without iterating the whole archive.
                     if let Some(file) = &metadata_link_file {
-                        ab.add_file(file);
+                        ab.add_file(file, false);
                     }
                     None
                 }
@@ -359,15 +359,15 @@ fn link_rlib<'a>(
 
     for m in &compiled_modules.modules {
         if let Some(obj) = m.object.as_ref() {
-            ab.add_file(obj);
+            ab.add_file(obj, true);
         }
 
         if let Some(obj) = m.global_asm_object.as_ref() {
-            ab.add_file(obj);
+            ab.add_file(obj, true);
         }
 
         if let Some(dwarf_obj) = m.dwarf_object.as_ref() {
-            ab.add_file(dwarf_obj);
+            ab.add_file(dwarf_obj, false);
         }
     }
 
@@ -376,10 +376,10 @@ fn link_rlib<'a>(
         RlibFlavor::StaticlibBase => {
             if let Some(m) = &compiled_modules.allocator_module {
                 if let Some(obj) = &m.object {
-                    ab.add_file(obj);
+                    ab.add_file(obj, true);
                 }
                 if let Some(obj) = &m.global_asm_object {
-                    ab.add_file(obj);
+                    ab.add_file(obj, true);
                 }
             }
         }
@@ -469,18 +469,18 @@ fn link_rlib<'a>(
         //
         // Basically, all this means is that this code should not move above the
         // code above.
-        ab.add_file(&trailing_metadata);
+        ab.add_file(&trailing_metadata, false);
         // Place the rmeta-link member immediately after metadata so consumers can
         // find it without iterating the whole archive.
         if let Some(file) = &metadata_link_file {
-            ab.add_file(file);
+            ab.add_file(file, false);
         }
     }
 
     // Add all bundled static native library dependencies.
     // Archives added to the end of .rlib archive, see comment above for the reason.
     for lib in packed_bundled_libs {
-        ab.add_file(&lib)
+        ab.add_file(&lib, false)
     }
 
     ab
@@ -568,7 +568,22 @@ fn link_staticlib(
         sess.dcx().emit_fatal(e);
     }
 
-    ab.build(out_filename);
+    let exported_symbols = if sess.opts.unstable_opts.staticlib_hide_internal_symbols {
+        if !matches!(&*sess.target.archive_format, "gnu" | "bsd" | "darwin") {
+            sess.dcx().emit_warn(errors::StaticlibHideInternalSymbolsUnsupported {
+                archive_format: sess.target.archive_format.to_string(),
+            });
+            None
+        } else {
+            crate_info
+                .exported_symbols
+                .get(&CrateType::StaticLib)
+                .map(|symbols| symbols.iter().map(|(s, _)| s.clone()).collect())
+        }
+    } else {
+        None
+    };
+    ab.build(out_filename, exported_symbols);
 
     let crates = crate_info.used_crates.iter();
 
@@ -1266,8 +1281,8 @@ fn link_natively(
 
     if should_archive {
         let mut ab = archive_builder_builder.new_archive_builder(sess);
-        ab.add_file(temp_filename);
-        ab.build(out_filename);
+        ab.add_file(temp_filename, false);
+        ab.build(out_filename, None);
     }
 }
 
@@ -3273,7 +3288,7 @@ fn add_static_crate(
             sess.dcx()
                 .emit_fatal(errors::RlibArchiveBuildFailure { path: cratepath.clone(), error });
         }
-        if archive.build(&dst) {
+        if archive.build(&dst, None) {
             link_upstream(&dst);
         }
     });

compiler/rustc_codegen_ssa/src/errors.rs

@@ -693,6 +693,14 @@ pub(crate) struct IncompatibleArchiveFormat {
 #[diag("linking static libraries is not supported for BPF")]
 pub(crate) struct BpfStaticlibNotSupported;
 
+#[derive(Diagnostic)]
+#[diag(
+    "-Zstaticlib-hide-internal-symbols only supports ELF and Mach-O archive formats (gnu/bsd/darwin), but the target uses `{$archive_format}`"
+)]
+pub(crate) struct StaticlibHideInternalSymbolsUnsupported {
+    pub archive_format: String,
+}
+
 #[derive(Diagnostic)]
 #[diag("entry symbol `main` declared multiple times")]
 #[help(

compiler/rustc_interface/src/tests.rs

@@ -866,6 +866,7 @@ fn test_unstable_options_tracking_hash() {
     tracked!(split_lto_unit, Some(true));
     tracked!(src_hash_algorithm, Some(SourceFileHashAlgorithm::Sha1));
     tracked!(stack_protector, StackProtector::All);
+    tracked!(staticlib_hide_internal_symbols, true);
     tracked!(teach, true);
     tracked!(thinlto, Some(true));
     tracked!(tiny_const_eval_limit, true);

compiler/rustc_interface/src/util.rs

@@ -471,7 +471,7 @@ impl ArchiveBuilderBuilder for DummyArchiveBuilderBuilder {
         output_path: &Path,
     ) {
         // Build an empty static library to avoid calling an external dlltool on mingw
-        ArArchiveBuilderBuilder.new_archive_builder(sess).build(output_path);
+        ArArchiveBuilderBuilder.new_archive_builder(sess).build(output_path, None);
     }
 }
 

compiler/rustc_session/src/config.rs

@@ -2456,6 +2456,14 @@ pub fn build_session_options(early_dcx: &mut EarlyDiagCtxt, matches: &getopts::M
     let mut collected_options = Default::default();
 
     let mut unstable_opts = UnstableOptions::build(early_dcx, matches, &mut collected_options);
+
+    if unstable_opts.staticlib_hide_internal_symbols && !crate_types.contains(&CrateType::StaticLib)
+    {
+        early_dcx.early_warn(
+            "-Zstaticlib-hide-internal-symbols has no effect without `--crate-type staticlib`",
+        );
+    }
+
     let (lint_opts, describe_lints, lint_cap) = get_cmd_lint_options(early_dcx, matches);
 
     if !unstable_opts.unstable_options && json_timings {

compiler/rustc_session/src/options.rs

@@ -2661,6 +2661,8 @@ written to standard error output)"),
         "control stack smash protection strategy (`rustc --print stack-protector-strategies` for details)"),
     staticlib_allow_rdylib_deps: bool = (false, parse_bool, [TRACKED],
         "allow staticlibs to have rust dylib dependencies"),
+    staticlib_hide_internal_symbols: bool = (false, parse_bool, [TRACKED],
+        "hide non-exported symbols in ELF static libraries by setting STV_HIDDEN"),
     staticlib_prefer_dynamic: bool = (false, parse_bool, [TRACKED],
         "prefer dynamic linking to static linking for staticlibs (default: no)"),
     strict_init_checks: bool = (false, parse_bool, [TRACKED],

src/doc/unstable-book/src/compiler-flags/staticlib-hide-internal-symbols.md

@@ -0,0 +1,32 @@
+# `staticlib-hide-internal-symbols`
+
+When building a `staticlib`, this option hides all non-exported Rust-internal
+symbols. On ELF targets, this sets `STV_HIDDEN` visibility. On Apple (Mach-O)
+targets, this sets the `N_PEXT` (private external) bit.
+
+This is a lightweight, zero-overhead operation: only the visibility/type byte of
+each internal symbol is modified in-place.
+
+Only symbols explicitly exported via `#[no_mangle]` or `#[export_name]` are left
+unchanged. All other `GLOBAL`/`WEAK` symbols (including `pub(crate)` and `pub`
+items without `#[no_mangle]`) are hidden.
+
+This option can only be used with `--crate-type staticlib`. Using it with
+other crate types will result in a compilation warning.
+
+Supported on ELF targets (Linux, BSD, etc.) and Apple targets (macOS, iOS, etc.).
+On unsupported targets (Windows), a warning is emitted and the flag has no effect.
+
+This option can be combined with `-Zstaticlib-rename-internal-symbols`.
+When both are enabled, symbols are both renamed and hidden.
+
+## Comparison with `-Zdefault-visibility=hidden`
+
+`-Zdefault-visibility=hidden` sets visibility at LLVM IR codegen time. It targets
+shared objects (`cdylib`/`dylib`) and only affects the current crate's codegen.
+
+`-Zstaticlib-hide-internal-symbols` patches visibility bytes post-compilation in
+the final `.a` archive, which includes object files from all upstream static
+dependencies. This means internal symbols from the entire dependency tree are
+hidden, not just those from the current crate. Hidden symbols are also excluded
+from the linker's global symbol table, which can slightly reduce final binary size.

tests/run-make/staticlib-hide-internal-symbols-macho/rmake.rs

@@ -0,0 +1,115 @@
+//@ only-apple
+//@ ignore-cross-compile
+
+use std::collections::HashSet;
+
+use run_make_support::object::Endianness;
+use run_make_support::object::macho::{MachHeader64, N_EXT, N_PEXT, N_SECT, N_STAB, N_TYPE};
+use run_make_support::object::read::archive::ArchiveFile;
+use run_make_support::object::read::macho::{MachHeader as _, Nlist as _};
+use run_make_support::path_helpers::source_root;
+use run_make_support::{cc, extra_c_flags, rfs, run, rustc, static_lib_name};
+
+type MachOFileHeader64 = MachHeader64<Endianness>;
+type SymbolTable<'data> =
+    run_make_support::object::read::macho::SymbolTable<'data, MachOFileHeader64>;
+
+const EXPORTED: &[&str] = &["my_add", "my_hash_lookup", "call_internal", "my_safe_div"];
+
+fn main() {
+    let sibling = source_root().join("tests/run-make/staticlib-hide-internal-symbols");
+    rfs::copy(sibling.join("lib.rs"), "lib.rs");
+    rfs::copy(sibling.join("main.c"), "main.c");
+
+    let lib_name = static_lib_name("lib");
+
+    rustc()
+        .input("lib.rs")
+        .crate_type("staticlib")
+        .arg("-Zstaticlib-hide-internal-symbols")
+        .opt()
+        .run();
+
+    cc().input("main.c").input(&lib_name).out_exe("main").args(extra_c_flags()).run();
+    run("main");
+
+    let data = rfs::read(&lib_name);
+    check_symbols(&data, true);
+
+    rfs::remove_file(&lib_name);
+    rustc().input("lib.rs").crate_type("staticlib").opt().run();
+
+    let data = rfs::read(&lib_name);
+    check_symbols(&data, false);
+}
+
+fn check_symbols(archive_data: &[u8], with_flag: bool) {
+    let archive = ArchiveFile::parse(archive_data).unwrap();
+    let mut found_exported = HashSet::new();
+
+    for member in archive.members() {
+        let member = member.unwrap();
+        let data = member.data(archive_data).unwrap();
+
+        let Ok(header) = MachOFileHeader64::parse(data, 0) else { continue };
+        let Ok(endian) = header.endian() else { continue };
+
+        let Some(symtab) = find_symtab(header, endian, data) else { continue };
+        let strtab = symtab.strings();
+
+        for nlist in symtab.iter() {
+            let n_type = nlist.n_type();
+            if n_type & N_STAB != 0 {
+                continue;
+            }
+            if n_type & N_EXT == 0 {
+                continue;
+            }
+            if n_type & N_TYPE != N_SECT {
+                continue;
+            }
+
+            let Ok(name_bytes) = nlist.name(endian, strtab) else { continue };
+            let Ok(name) = str::from_utf8(name_bytes) else { continue };
+            let name = name.strip_prefix('_').unwrap_or(name);
+
+            let exported = EXPORTED.contains(&name);
+            let has_pext = n_type & N_PEXT != 0;
+
+            if with_flag {
+                if exported {
+                    assert!(!has_pext, "with -Z hide: exported `{name}` should NOT have N_PEXT");
+                } else {
+                    assert!(has_pext, "with -Z hide: internal `{name}` should have N_PEXT");
+                }
+            } else if exported {
+                assert!(!has_pext, "without -Z: exported `{name}` should NOT have N_PEXT");
+            }
+
+            if exported {
+                found_exported.insert(name.to_string());
+            }
+        }
+    }
+
+    for expected in EXPORTED {
+        assert!(
+            found_exported.contains(*expected),
+            "expected to find exported symbol `{expected}` in archive"
+        );
+    }
+}
+
+fn find_symtab<'data>(
+    header: &MachOFileHeader64,
+    endian: Endianness,
+    data: &'data [u8],
+) -> Option<SymbolTable<'data>> {
+    let mut commands = header.load_commands(endian, data, 0).ok()?;
+    while let Ok(Some(command)) = commands.next() {
+        if let Ok(Some(symtab_cmd)) = command.symtab() {
+            return symtab_cmd.symbols::<MachOFileHeader64, _>(endian, data).ok();
+        }
+    }
+    None
+}

tests/run-make/staticlib-hide-internal-symbols/lib.rs

@@ -0,0 +1,40 @@
+#![crate_type = "staticlib"]
+
+use std::collections::HashMap;
+use std::panic::{AssertUnwindSafe, catch_unwind};
+
+#[no_mangle]
+pub extern "C" fn my_add(a: i32, b: i32) -> i32 {
+    a + b
+}
+
+#[no_mangle]
+pub extern "C" fn my_hash_lookup(key: u64) -> u64 {
+    let mut map = HashMap::new();
+    for i in 0..100u64 {
+        map.insert(i, i.wrapping_mul(2654435761));
+    }
+    *map.get(&key).unwrap_or(&0)
+}
+
+fn internal_helper() -> i32 {
+    42
+}
+
+#[no_mangle]
+pub extern "C" fn call_internal() -> i32 {
+    internal_helper()
+}
+
+#[no_mangle]
+pub extern "C" fn my_safe_div(a: i32, b: i32) -> i32 {
+    match catch_unwind(AssertUnwindSafe(|| {
+        if b == 0 {
+            panic!("division by zero!");
+        }
+        a / b
+    })) {
+        Ok(result) => result,
+        Err(_) => -1,
+    }
+}

tests/run-make/staticlib-hide-internal-symbols/main.c

@@ -0,0 +1,18 @@
+extern int my_add(int a, int b);
+extern unsigned long my_hash_lookup(unsigned long key);
+extern int call_internal(void);
+extern int my_safe_div(int a, int b);
+
+int main() {
+    if (my_add(10, 20) != 30)
+        return 1;
+    if (my_hash_lookup(5) != 5UL * 2654435761UL)
+        return 1;
+    if (call_internal() != 42)
+        return 1;
+    if (my_safe_div(100, 5) != 20)
+        return 1;
+    if (my_safe_div(100, 0) != -1)
+        return 1;
+    return 0;
+}