Link object files that use #[used]

dianqk · dianqk · commit b5d92a27ae9d · 2025-02-22T23:32:45.000+08:00
diff --git a/compiler/rustc_codegen_ssa/src/back/link.rs b/compiler/rustc_codegen_ssa/src/back/link.rs
@@ -9,6 +9,7 @@ use std::{env, fmt, fs, io, mem, str};
 
 use cc::windows_registry;
 use itertools::Itertools;
+use object::read::archive::{ArchiveFile, ArchiveOffset};
 use regex::Regex;
 use rustc_arena::TypedArena;
 use rustc_ast::CRATE_NODE_ID;
@@ -78,6 +79,7 @@ pub fn link_binary(
     let _timer = sess.timer("link_binary");
     let output_metadata = sess.opts.output_types.contains_key(&OutputType::Metadata);
     let mut tempfiles_for_stdout_output: Vec<PathBuf> = Vec::new();
+    let mut tempfiles_for_linked_objects: Vec<PathBuf> = Vec::new();
     for &crate_type in &codegen_results.crate_info.crate_types {
         // Ignore executable crates if we have -Z no-codegen, as they will error.
         if (sess.opts.unstable_opts.no_codegen || !sess.opts.output_types.should_codegen())
@@ -142,6 +144,8 @@ pub fn link_binary(
                         &out_filename,
                         &codegen_results,
                         path.as_ref(),
+                        &mut tempfiles_for_linked_objects,
+                        outputs,
                     );
                 }
             }
@@ -214,6 +218,10 @@ pub fn link_binary(
             ensure_removed(sess.dcx(), &temp);
         }
 
+        for temp in tempfiles_for_linked_objects {
+            ensure_removed(sess.dcx(), &temp);
+        }
+
         // If no requested outputs require linking, then the object temporaries should
         // be kept.
         if !sess.opts.output_types.should_link() {
@@ -771,6 +779,8 @@ fn link_natively(
     out_filename: &Path,
     codegen_results: &CodegenResults,
     tmpdir: &Path,
+    tempfiles_for_linked_objects: &mut Vec<PathBuf>,
+    outputs: &OutputFilenames,
 ) {
     info!("preparing {:?} to {:?}", crate_type, out_filename);
     let (linker_path, flavor) = linker_and_flavor(sess);
@@ -795,6 +805,8 @@ fn link_natively(
         temp_filename,
         codegen_results,
         self_contained_components,
+        tempfiles_for_linked_objects,
+        outputs,
     );
 
     linker::disable_localization(&mut cmd);
@@ -2254,6 +2266,8 @@ fn linker_with_args(
     out_filename: &Path,
     codegen_results: &CodegenResults,
     self_contained_components: LinkSelfContainedComponents,
+    tempfiles_for_linked_objects: &mut Vec<PathBuf>,
+    outputs: &OutputFilenames,
 ) -> Command {
     let self_contained_crt_objects = self_contained_components.is_crt_objects_enabled();
     let cmd = &mut *super::linker::get_linker(
@@ -2329,6 +2343,13 @@ fn linker_with_args(
     add_local_crate_regular_objects(cmd, codegen_results);
     add_local_crate_metadata_objects(cmd, crate_type, codegen_results);
     add_local_crate_allocator_objects(cmd, codegen_results);
+    add_local_crate_linked_objects(
+        cmd,
+        codegen_results,
+        crate_type,
+        tempfiles_for_linked_objects,
+        outputs,
+    );
 
     // Avoid linking to dynamic libraries unless they satisfy some undefined symbols
     // at the point at which they are specified on the command line.
@@ -2925,6 +2946,32 @@ fn rehome_lib_path(sess: &Session, path: &Path) -> PathBuf {
     }
 }
 
+fn add_local_crate_linked_objects(
+    cmd: &mut dyn Linker,
+    codegen_results: &CodegenResults,
+    crate_type: CrateType,
+    tempfiles_for_linked_objects: &mut Vec<PathBuf>,
+    outputs: &OutputFilenames,
+) {
+    for (cnum, offsets) in &codegen_results.crate_info.linked_objects[&crate_type] {
+        let src = &codegen_results.crate_info.used_crate_source[cnum];
+        let cratepath = &src.rlib.as_ref().unwrap().0;
+        let archive_map = unsafe { Mmap::map(File::open(cratepath).unwrap()).unwrap() };
+        let archive = ArchiveFile::parse(&*archive_map)
+            .map_err(|err| io::Error::new(io::ErrorKind::InvalidData, err))
+            .unwrap();
+        for &offset in offsets {
+            let member = archive.member(ArchiveOffset(offset)).unwrap();
+            let name = std::str::from_utf8(member.name()).unwrap();
+            let data = member.data(&*archive_map).unwrap();
+            let obj = outputs.temp_path(OutputType::Object, Some(&format!("{name}.linked_object")));
+            fs::write(&obj, data).unwrap();
+            cmd.add_object(&obj);
+            tempfiles_for_linked_objects.push(obj);
+        }
+    }
+}
+
 // Adds the static "rlib" versions of all crates to the command line.
 // There's a bit of magic which happens here specifically related to LTO,
 // namely that we remove upstream object files.
diff --git a/compiler/rustc_codegen_ssa/src/back/linker.rs b/compiler/rustc_codegen_ssa/src/back/linker.rs
@@ -5,14 +5,18 @@ use std::path::{Path, PathBuf};
 use std::{env, io, iter, mem, str};
 
 use cc::windows_registry;
+use object::read::archive::ArchiveFile;
+use rustc_data_structures::fx::{FxHashSet, FxIndexMap, FxIndexSet};
+use rustc_data_structures::memmap::Mmap;
 use rustc_hir::def_id::{CrateNum, LOCAL_CRATE};
 use rustc_metadata::{
     find_native_static_library, try_find_native_dynamic_library, try_find_native_static_library,
 };
 use rustc_middle::bug;
 use rustc_middle::middle::dependency_format::Linkage;
-use rustc_middle::middle::exported_symbols;
-use rustc_middle::middle::exported_symbols::{ExportedSymbol, SymbolExportInfo, SymbolExportKind};
+use rustc_middle::middle::exported_symbols::{
+    self, ExportedSymbol, SymbolExportInfo, SymbolExportKind,
+};
 use rustc_middle::ty::TyCtxt;
 use rustc_session::Session;
 use rustc_session::config::{self, CrateType, DebugInfo, LinkerPluginLto, Lto, OptLevel, Strip};
@@ -21,6 +25,7 @@ use rustc_target::spec::{Cc, LinkOutputKind, LinkerFlavor, Lld};
 use tracing::{debug, warn};
 
 use super::command::Command;
+use super::link::are_upstream_rust_objects_already_included;
 use super::symbol_export;
 use crate::errors;
 
@@ -1753,17 +1758,15 @@ impl<'a> Linker for AixLinker<'a> {
 fn for_each_exported_symbols_include_dep<'tcx>(
     tcx: TyCtxt<'tcx>,
     crate_type: CrateType,
-    mut callback: impl FnMut(ExportedSymbol<'tcx>, SymbolExportInfo, CrateNum),
+    mut callback: impl FnMut(&'tcx [(ExportedSymbol<'tcx>, SymbolExportInfo)], CrateNum),
 ) {
     let formats = tcx.dependency_formats(());
     let deps = &formats[&crate_type];
 
     for (cnum, dep_format) in deps.iter_enumerated() {
         // For each dependency that we are linking to statically ...
         if *dep_format == Linkage::Static {
-            for &(symbol, info) in tcx.exported_symbols(cnum).iter() {
-                callback(symbol, info, cnum);
-            }
+            callback(tcx.exported_symbols(cnum), cnum);
         }
     }
 }
@@ -1783,12 +1786,14 @@ pub(crate) fn exported_symbols(tcx: TyCtxt<'_>, crate_type: CrateType) -> Vec<St
 fn exported_symbols_for_non_proc_macro(tcx: TyCtxt<'_>, crate_type: CrateType) -> Vec<String> {
     let mut symbols = Vec::new();
     let export_threshold = symbol_export::crates_export_threshold(&[crate_type]);
-    for_each_exported_symbols_include_dep(tcx, crate_type, |symbol, info, cnum| {
-        if info.level.is_below_threshold(export_threshold) {
-            symbols.push(symbol_export::exporting_symbol_name_for_instance_in_crate(
-                tcx, symbol, cnum,
-            ));
-            symbol_export::extend_exported_symbols(&mut symbols, tcx, symbol, cnum);
+    for_each_exported_symbols_include_dep(tcx, crate_type, |exported_symbols, cnum| {
+        for &(symbol, info) in exported_symbols {
+            if info.level.is_below_threshold(export_threshold) {
+                symbols.push(symbol_export::exporting_symbol_name_for_instance_in_crate(
+                    tcx, symbol, cnum,
+                ));
+                symbol_export::extend_exported_symbols(&mut symbols, tcx, symbol, cnum);
+            }
         }
     });
 
@@ -1808,30 +1813,97 @@ fn exported_symbols_for_proc_macro_crate(tcx: TyCtxt<'_>) -> Vec<String> {
     vec![proc_macro_decls_name, metadata_symbol_name]
 }
 
-pub(crate) fn linked_symbols(
+fn add_linked_objects(
+    archive_path: &Path,
+    linked_symbols: &mut FxHashSet<String>,
+) -> Option<FxIndexSet<u64>> {
+    let archive_map = unsafe { Mmap::map(File::open(&archive_path).unwrap()).unwrap() };
+    let archive = ArchiveFile::parse(&*archive_map)
+        .map_err(|err| io::Error::new(io::ErrorKind::InvalidData, err))
+        .unwrap();
+    let Some(archive_symbols) = archive.symbols().unwrap() else {
+        return None;
+    };
+    let mut offsets = FxIndexSet::default();
+    for symbol in archive_symbols {
+        let symbol = symbol.unwrap();
+        let name = std::str::from_utf8(symbol.name()).unwrap();
+        if linked_symbols.remove(name) {
+            offsets.insert(symbol.offset().0);
+        }
+    }
+    Some(offsets)
+}
+
+pub(crate) fn linked_objects(
     tcx: TyCtxt<'_>,
     crate_type: CrateType,
-) -> Vec<(String, SymbolExportKind)> {
+    linked_symbols: &mut Vec<(String, SymbolExportKind)>,
+) -> FxIndexMap<CrateNum, FxIndexSet<u64>> {
     match crate_type {
         CrateType::Executable | CrateType::Cdylib | CrateType::Dylib => (),
         CrateType::Staticlib | CrateType::ProcMacro | CrateType::Rlib => {
-            return Vec::new();
+            return FxIndexMap::default();
         }
     }
 
-    let mut symbols = Vec::new();
-
+    let mut objects = FxIndexMap::default();
+    let upstream_rust_objects_already_included =
+        are_upstream_rust_objects_already_included(tcx.sess);
     let export_threshold = symbol_export::crates_export_threshold(&[crate_type]);
-    for_each_exported_symbols_include_dep(tcx, crate_type, |symbol, info, cnum| {
-        if info.level.is_below_threshold(export_threshold) || info.used {
-            symbols.push((
-                symbol_export::linking_symbol_name_for_instance_in_crate(tcx, symbol, cnum),
-                info.kind,
-            ));
+    for_each_exported_symbols_include_dep(tcx, crate_type, |exported_symbols, cnum| {
+        if cnum == LOCAL_CRATE {
+            // We don't know here if the symbols are undefined, so we add them all.
+            // Since the local crate is always linked directly to object files, `#[used]` works as expected.
+            linked_symbols.extend(
+                exported_symbols
+                    .iter()
+                    .filter(|(_, info)| {
+                        info.level.is_below_threshold(export_threshold) || info.used
+                    })
+                    .map(|&(symbol, info)| {
+                        (
+                            symbol_export::linking_symbol_name_for_instance_in_crate(
+                                tcx, symbol, cnum,
+                            ),
+                            info.kind,
+                        )
+                    }),
+            );
+            return;
+        }
+        // TODO: let lto = upstream_rust_objects_already_included && !ignored_for_lto(tcx.sess, &codegen_results.crate_info, cnum);
+        let lto = upstream_rust_objects_already_included;
+        if lto {
+            return;
+        }
+        let symbols: Vec<_> = exported_symbols
+            .iter()
+            .filter(|(_, info)| info.level.is_below_threshold(export_threshold) || info.used)
+            .map(|&(symbol, info)| {
+                (
+                    symbol_export::linking_symbol_name_for_instance_in_crate(tcx, symbol, cnum),
+                    info.kind,
+                )
+            })
+            .collect();
+        if symbols.is_empty() {
+            return;
         }
+        let used_crate_source = tcx.used_crate_source(cnum);
+        let cratepath = &used_crate_source.rlib.as_ref().unwrap().0;
+        let mut crate_linked_symbols: FxHashSet<_> =
+            symbols.iter().map(|(symbol, _)| symbol.to_string()).collect();
+        if let Some(archive_offsets) = add_linked_objects(cratepath, &mut crate_linked_symbols) {
+            objects.insert(cnum, archive_offsets);
+        }
+        // Unresolved symbols may come from external libraries.
+        linked_symbols.extend(
+            symbols.into_iter().filter(|(symbol, _)| crate_linked_symbols.contains(symbol)),
+        );
     });
 
-    symbols
+    objects
 }
 
 /// Much simplified and explicit CLI for the NVPTX linker. The linker operates
diff --git a/compiler/rustc_codegen_ssa/src/base.rs b/compiler/rustc_codegen_ssa/src/base.rs
@@ -6,7 +6,7 @@ use std::time::{Duration, Instant};
 use itertools::Itertools;
 use rustc_abi::FIRST_VARIANT;
 use rustc_ast::expand::allocator::{ALLOCATOR_METHODS, AllocatorKind, global_fn_name};
-use rustc_data_structures::fx::{FxHashMap, FxIndexSet};
+use rustc_data_structures::fx::{FxHashMap, FxIndexMap, FxIndexSet};
 use rustc_data_structures::profiling::{get_resident_set_size, print_time_passes_entry};
 use rustc_data_structures::sync::par_map;
 use rustc_data_structures::unord::UnordMap;
@@ -872,8 +872,21 @@ impl CrateInfo {
             .iter()
             .map(|&c| (c, crate::back::linker::exported_symbols(tcx, c)))
             .collect();
-        let linked_symbols =
-            crate_types.iter().map(|&c| (c, crate::back::linker::linked_symbols(tcx, c))).collect();
+        let mut linked_symbols: FxIndexMap<CrateType, Vec<(String, SymbolExportKind)>> =
+            crate_types.iter().map(|&c| (c, Vec::new())).collect();
+        let linked_objects = crate_types
+            .iter()
+            .map(|&c| {
+                (
+                    c,
+                    crate::back::linker::linked_objects(
+                        tcx,
+                        c,
+                        linked_symbols.get_mut(&c).unwrap(),
+                    ),
+                )
+            })
+            .collect();
         let local_crate_name = tcx.crate_name(LOCAL_CRATE);
         let crate_attrs = tcx.hir().attrs(rustc_hir::CRATE_HIR_ID);
         let subsystem =
@@ -919,6 +932,7 @@ impl CrateInfo {
             crate_types,
             exported_symbols,
             linked_symbols,
+            linked_objects,
             local_crate_name,
             compiler_builtins,
             profiler_runtime: None,
diff --git a/compiler/rustc_codegen_ssa/src/lib.rs b/compiler/rustc_codegen_ssa/src/lib.rs
@@ -27,7 +27,7 @@ use std::path::{Path, PathBuf};
 use std::sync::Arc;
 
 use rustc_ast as ast;
-use rustc_data_structures::fx::{FxHashSet, FxIndexMap};
+use rustc_data_structures::fx::{FxHashSet, FxIndexMap, FxIndexSet};
 use rustc_data_structures::unord::UnordMap;
 use rustc_hir::CRATE_HIR_ID;
 use rustc_hir::def_id::CrateNum;
@@ -194,6 +194,7 @@ pub struct CrateInfo {
     pub crate_types: Vec<CrateType>,
     pub exported_symbols: UnordMap<CrateType, Vec<String>>,
     pub linked_symbols: FxIndexMap<CrateType, Vec<(String, SymbolExportKind)>>,
+    pub linked_objects: FxIndexMap<CrateType, FxIndexMap<CrateNum, FxIndexSet<u64>>>,
     pub local_crate_name: Symbol,
     pub compiler_builtins: Option<CrateNum>,
     pub profiler_runtime: Option<CrateNum>,
diff --git a/tests/run-make/linker-warning/short-error.txt b/tests/run-make/linker-warning/short-error.txt
@@ -1,6 +1,6 @@
 error: linking with `./fake-linker` failed: exit status: 1
   |
-  = note:  "./fake-linker" "-m64" "/tmp/rustc/symbols.o" "<2 object files omitted>" "-Wl,--as-needed" "-Wl,-Bstatic" "<sysroot>/lib/rustlib/x86_64-unknown-linux-gnu/lib/{libstd-*,libpanic_unwind-*,libobject-*,libmemchr-*,libaddr2line-*,libgimli-*,librustc_demangle-*,libstd_detect-*,libhashbrown-*,librustc_std_workspace_alloc-*,libminiz_oxide-*,libadler2-*,libunwind-*,libcfg_if-*,liblibc-*,liballoc-*,librustc_std_workspace_core-*,libcore-*,libcompiler_builtins-*}.rlib" "-Wl,-Bdynamic" "-lgcc_s" "-lutil" "-lrt" "-lpthread" "-lm" "-ldl" "-lc" "-Wl,--eh-frame-hdr" "-Wl,-z,noexecstack" "-L" "/build-root/test/run-make/linker-warning/rmake_out" "-L" "<sysroot>/lib/rustlib/x86_64-unknown-linux-gnu/lib" "-o" "main" "-Wl,--gc-sections" "-pie" "-Wl,-z,relro,-z,now" "-nodefaultlibs" "run_make_error"
+  = note:  "./fake-linker" "-m64" "/tmp/rustc/symbols.o" "<5 object files omitted>" "-Wl,--as-needed" "-Wl,-Bstatic" "<sysroot>/lib/rustlib/x86_64-unknown-linux-gnu/lib/{libstd-*,libpanic_unwind-*,libobject-*,libmemchr-*,libaddr2line-*,libgimli-*,librustc_demangle-*,libstd_detect-*,libhashbrown-*,librustc_std_workspace_alloc-*,libminiz_oxide-*,libadler2-*,libunwind-*,libcfg_if-*,liblibc-*,liballoc-*,librustc_std_workspace_core-*,libcore-*,libcompiler_builtins-*}.rlib" "-Wl,-Bdynamic" "-lgcc_s" "-lutil" "-lrt" "-lpthread" "-lm" "-ldl" "-lc" "-Wl,--eh-frame-hdr" "-Wl,-z,noexecstack" "-L" "/build-root/test/run-make/linker-warning/rmake_out" "-L" "<sysroot>/lib/rustlib/x86_64-unknown-linux-gnu/lib" "-o" "main" "-Wl,--gc-sections" "-pie" "-Wl,-z,relro,-z,now" "-nodefaultlibs" "run_make_error"
   = note: some arguments are omitted. use `--verbose` to show all linker arguments
   = note: error: baz
           

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	error: linking with `./fake-linker` failed: exit status: 1
`2`	`2`	`\|`
`3`		- = note: "./fake-linker" "-m64" "/tmp/rustc/symbols.o" "<2 object files omitted>" "-Wl,--as-needed" "-Wl,-Bstatic" "<sysroot>/lib/rustlib/x86_64-unknown-linux-gnu/lib/{libstd-,libpanic_unwind-,libobject-,libmemchr-,libaddr2line-,libgimli-,librustc_demangle-,libstd_detect-,libhashbrown-,librustc_std_workspace_alloc-,libminiz_oxide-,libadler2-,libunwind-,libcfg_if-,liblibc-,liballoc-,librustc_std_workspace_core-,libcore-,libcompiler_builtins-*}.rlib" "-Wl,-Bdynamic" "-lgcc_s" "-lutil" "-lrt" "-lpthread" "-lm" "-ldl" "-lc" "-Wl,--eh-frame-hdr" "-Wl,-z,noexecstack" "-L" "/build-root/test/run-make/linker-warning/rmake_out" "-L" "<sysroot>/lib/rustlib/x86_64-unknown-linux-gnu/lib" "-o" "main" "-Wl,--gc-sections" "-pie" "-Wl,-z,relro,-z,now" "-nodefaultlibs" "run_make_error"
	`3`	+ = note: "./fake-linker" "-m64" "/tmp/rustc/symbols.o" "<5 object files omitted>" "-Wl,--as-needed" "-Wl,-Bstatic" "<sysroot>/lib/rustlib/x86_64-unknown-linux-gnu/lib/{libstd-,libpanic_unwind-,libobject-,libmemchr-,libaddr2line-,libgimli-,librustc_demangle-,libstd_detect-,libhashbrown-,librustc_std_workspace_alloc-,libminiz_oxide-,libadler2-,libunwind-,libcfg_if-,liblibc-,liballoc-,librustc_std_workspace_core-,libcore-,libcompiler_builtins-*}.rlib" "-Wl,-Bdynamic" "-lgcc_s" "-lutil" "-lrt" "-lpthread" "-lm" "-ldl" "-lc" "-Wl,--eh-frame-hdr" "-Wl,-z,noexecstack" "-L" "/build-root/test/run-make/linker-warning/rmake_out" "-L" "<sysroot>/lib/rustlib/x86_64-unknown-linux-gnu/lib" "-o" "main" "-Wl,--gc-sections" "-pie" "-Wl,-z,relro,-z,now" "-nodefaultlibs" "run_make_error"
`4`	`4`	= note: some arguments are omitted. use `--verbose` to show all linker arguments
`5`	`5`	`= note: error: baz`
`6`	`6`