Auto merge of #95604 - nbdd0121:used2, r=petrochenkov
Generate synthetic object file to ensure all exported and used symbols participate in the linking Fix #50007 and #47384 This is the synthetic object file approach that I described in https://github.com/rust-lang/rust/pull/95363#issuecomment-1079932354, allowing all exported and used symbols to be linked while still allowing them to be GCed. Related #93791, #95363 r? `@petrochenkov` cc `@carbotaniuman`
This commit is contained in:
commit
18b53cefdf
23 changed files with 324 additions and 75 deletions
|
@ -7,6 +7,7 @@ use rustc_errors::{ErrorGuaranteed, Handler};
|
|||
use rustc_fs_util::fix_windows_verbatim_for_gcc;
|
||||
use rustc_hir::def_id::CrateNum;
|
||||
use rustc_middle::middle::dependency_format::Linkage;
|
||||
use rustc_middle::middle::exported_symbols::SymbolExportKind;
|
||||
use rustc_session::config::{self, CFGuard, CrateType, DebugInfo, LdImpl, Strip};
|
||||
use rustc_session::config::{OutputFilenames, OutputType, PrintRequest, SplitDwarfKind};
|
||||
use rustc_session::cstore::DllImport;
|
||||
|
@ -1655,6 +1656,73 @@ fn add_post_link_args(cmd: &mut dyn Linker, sess: &Session, flavor: LinkerFlavor
|
|||
}
|
||||
}
|
||||
|
||||
/// Add a synthetic object file that contains reference to all symbols that we want to expose to
|
||||
/// the linker.
|
||||
///
|
||||
/// Background: we implement rlibs as static library (archives). Linkers treat archives
|
||||
/// differently from object files: all object files participate in linking, while archives will
|
||||
/// only participate in linking if they can satisfy at least one undefined reference (version
|
||||
/// scripts doesn't count). This causes `#[no_mangle]` or `#[used]` items to be ignored by the
|
||||
/// linker, and since they never participate in the linking, using `KEEP` in the linker scripts
|
||||
/// can't keep them either. This causes #47384.
|
||||
///
|
||||
/// To keep them around, we could use `--whole-archive` and equivalents to force rlib to
|
||||
/// participate in linking like object files, but this proves to be expensive (#93791). Therefore
|
||||
/// we instead just introduce an undefined reference to them. This could be done by `-u` command
|
||||
/// line option to the linker or `EXTERN(...)` in linker scripts, however they does not only
|
||||
/// introduce an undefined reference, but also make them the GC roots, preventing `--gc-sections`
|
||||
/// from removing them, and this is especially problematic for embedded programming where every
|
||||
/// byte counts.
|
||||
///
|
||||
/// This method creates a synthetic object file, which contains undefined references to all symbols
|
||||
/// that are necessary for the linking. They are only present in symbol table but not actually
|
||||
/// used in any sections, so the linker will therefore pick relevant rlibs for linking, but
|
||||
/// unused `#[no_mangle]` or `#[used]` can still be discard by GC sections.
|
||||
fn add_linked_symbol_object(
|
||||
cmd: &mut dyn Linker,
|
||||
sess: &Session,
|
||||
tmpdir: &Path,
|
||||
symbols: &[(String, SymbolExportKind)],
|
||||
) {
|
||||
if symbols.is_empty() {
|
||||
return;
|
||||
}
|
||||
|
||||
let Some(mut file) = super::metadata::create_object_file(sess) else {
|
||||
return;
|
||||
};
|
||||
|
||||
// NOTE(nbdd0121): MSVC will hang if the input object file contains no sections,
|
||||
// so add an empty section.
|
||||
if file.format() == object::BinaryFormat::Coff {
|
||||
file.add_section(Vec::new(), ".text".into(), object::SectionKind::Text);
|
||||
}
|
||||
|
||||
for (sym, kind) in symbols.iter() {
|
||||
file.add_symbol(object::write::Symbol {
|
||||
name: sym.clone().into(),
|
||||
value: 0,
|
||||
size: 0,
|
||||
kind: match kind {
|
||||
SymbolExportKind::Text => object::SymbolKind::Text,
|
||||
SymbolExportKind::Data => object::SymbolKind::Data,
|
||||
SymbolExportKind::Tls => object::SymbolKind::Tls,
|
||||
},
|
||||
scope: object::SymbolScope::Unknown,
|
||||
weak: false,
|
||||
section: object::write::SymbolSection::Undefined,
|
||||
flags: object::SymbolFlags::None,
|
||||
});
|
||||
}
|
||||
|
||||
let path = tmpdir.join("symbols.o");
|
||||
let result = std::fs::write(&path, file.write().unwrap());
|
||||
if let Err(e) = result {
|
||||
sess.fatal(&format!("failed to write {}: {}", path.display(), e));
|
||||
}
|
||||
cmd.add_object(&path);
|
||||
}
|
||||
|
||||
/// Add object files containing code from the current crate.
|
||||
fn add_local_crate_regular_objects(cmd: &mut dyn Linker, codegen_results: &CodegenResults) {
|
||||
for obj in codegen_results.modules.iter().filter_map(|m| m.object.as_ref()) {
|
||||
|
@ -1795,6 +1863,13 @@ fn linker_with_args<'a, B: ArchiveBuilder<'a>>(
|
|||
// Pre-link CRT objects.
|
||||
add_pre_link_objects(cmd, sess, link_output_kind, crt_objects_fallback);
|
||||
|
||||
add_linked_symbol_object(
|
||||
cmd,
|
||||
sess,
|
||||
tmpdir,
|
||||
&codegen_results.crate_info.linked_symbols[&crate_type],
|
||||
);
|
||||
|
||||
// Sanitizer libraries.
|
||||
add_sanitizer_libraries(sess, crate_type, cmd);
|
||||
|
||||
|
|
|
@ -12,6 +12,7 @@ use std::{env, mem, str};
|
|||
|
||||
use rustc_hir::def_id::{CrateNum, LOCAL_CRATE};
|
||||
use rustc_middle::middle::dependency_format::Linkage;
|
||||
use rustc_middle::middle::exported_symbols::{ExportedSymbol, SymbolExportInfo, SymbolExportKind};
|
||||
use rustc_middle::ty::TyCtxt;
|
||||
use rustc_serialize::{json, Encoder};
|
||||
use rustc_session::config::{self, CrateType, DebugInfo, LinkerPluginLto, Lto, OptLevel, Strip};
|
||||
|
@ -1518,22 +1519,13 @@ impl<'a> L4Bender<'a> {
|
|||
}
|
||||
}
|
||||
|
||||
pub(crate) fn exported_symbols(tcx: TyCtxt<'_>, crate_type: CrateType) -> Vec<String> {
|
||||
if let Some(ref exports) = tcx.sess.target.override_export_symbols {
|
||||
return exports.iter().map(ToString::to_string).collect();
|
||||
}
|
||||
|
||||
let mut symbols = Vec::new();
|
||||
|
||||
let export_threshold = symbol_export::crates_export_threshold(&[crate_type]);
|
||||
for &(symbol, level) in tcx.exported_symbols(LOCAL_CRATE).iter() {
|
||||
if level.is_below_threshold(export_threshold) {
|
||||
symbols.push(symbol_export::symbol_name_for_instance_in_crate(
|
||||
tcx,
|
||||
symbol,
|
||||
LOCAL_CRATE,
|
||||
));
|
||||
}
|
||||
fn for_each_exported_symbols_include_dep<'tcx>(
|
||||
tcx: TyCtxt<'tcx>,
|
||||
crate_type: CrateType,
|
||||
mut callback: impl FnMut(ExportedSymbol<'tcx>, SymbolExportInfo, CrateNum),
|
||||
) {
|
||||
for &(symbol, info) in tcx.exported_symbols(LOCAL_CRATE).iter() {
|
||||
callback(symbol, info, LOCAL_CRATE);
|
||||
}
|
||||
|
||||
let formats = tcx.dependency_formats(());
|
||||
|
@ -1543,16 +1535,52 @@ pub(crate) fn exported_symbols(tcx: TyCtxt<'_>, crate_type: CrateType) -> Vec<St
|
|||
let cnum = CrateNum::new(index + 1);
|
||||
// For each dependency that we are linking to statically ...
|
||||
if *dep_format == Linkage::Static {
|
||||
// ... we add its symbol list to our export list.
|
||||
for &(symbol, level) in tcx.exported_symbols(cnum).iter() {
|
||||
if !level.is_below_threshold(export_threshold) {
|
||||
continue;
|
||||
}
|
||||
|
||||
symbols.push(symbol_export::symbol_name_for_instance_in_crate(tcx, symbol, cnum));
|
||||
for &(symbol, info) in tcx.exported_symbols(cnum).iter() {
|
||||
callback(symbol, info, cnum);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn exported_symbols(tcx: TyCtxt<'_>, crate_type: CrateType) -> Vec<String> {
|
||||
if let Some(ref exports) = tcx.sess.target.override_export_symbols {
|
||||
return exports.iter().map(ToString::to_string).collect();
|
||||
}
|
||||
|
||||
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::symbol_name_for_instance_in_crate(tcx, symbol, cnum));
|
||||
}
|
||||
});
|
||||
|
||||
symbols
|
||||
}
|
||||
|
||||
pub(crate) fn linked_symbols(
|
||||
tcx: TyCtxt<'_>,
|
||||
crate_type: CrateType,
|
||||
) -> Vec<(String, SymbolExportKind)> {
|
||||
match crate_type {
|
||||
CrateType::Executable | CrateType::Cdylib => (),
|
||||
CrateType::Staticlib | CrateType::ProcMacro | CrateType::Rlib | CrateType::Dylib => {
|
||||
return Vec::new();
|
||||
}
|
||||
}
|
||||
|
||||
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) || info.used {
|
||||
symbols.push((
|
||||
symbol_export::symbol_name_for_instance_in_crate(tcx, symbol, cnum),
|
||||
info.kind,
|
||||
));
|
||||
}
|
||||
});
|
||||
|
||||
symbols
|
||||
}
|
||||
|
|
|
@ -94,7 +94,7 @@ fn search_for_metadata<'a>(
|
|||
.map_err(|e| format!("failed to read {} section in '{}': {}", section, path.display(), e))
|
||||
}
|
||||
|
||||
fn create_object_file(sess: &Session) -> Option<write::Object<'static>> {
|
||||
pub(crate) fn create_object_file(sess: &Session) -> Option<write::Object<'static>> {
|
||||
let endianness = match sess.target.options.endian {
|
||||
Endian::Little => Endianness::Little,
|
||||
Endian::Big => Endianness::Big,
|
||||
|
|
|
@ -7,7 +7,7 @@ use rustc_hir::def_id::{CrateNum, DefId, DefIdMap, LocalDefId, LOCAL_CRATE};
|
|||
use rustc_hir::Node;
|
||||
use rustc_middle::middle::codegen_fn_attrs::CodegenFnAttrFlags;
|
||||
use rustc_middle::middle::exported_symbols::{
|
||||
metadata_symbol_name, ExportedSymbol, SymbolExportLevel,
|
||||
metadata_symbol_name, ExportedSymbol, SymbolExportInfo, SymbolExportKind, SymbolExportLevel,
|
||||
};
|
||||
use rustc_middle::ty::query::{ExternProviders, Providers};
|
||||
use rustc_middle::ty::subst::{GenericArgKind, SubstsRef};
|
||||
|
@ -40,7 +40,7 @@ pub fn crates_export_threshold(crate_types: &[CrateType]) -> SymbolExportLevel {
|
|||
}
|
||||
}
|
||||
|
||||
fn reachable_non_generics_provider(tcx: TyCtxt<'_>, cnum: CrateNum) -> DefIdMap<SymbolExportLevel> {
|
||||
fn reachable_non_generics_provider(tcx: TyCtxt<'_>, cnum: CrateNum) -> DefIdMap<SymbolExportInfo> {
|
||||
assert_eq!(cnum, LOCAL_CRATE);
|
||||
|
||||
if !tcx.sess.opts.output_types.should_codegen() {
|
||||
|
@ -103,36 +103,51 @@ fn reachable_non_generics_provider(tcx: TyCtxt<'_>, cnum: CrateNum) -> DefIdMap<
|
|||
}
|
||||
})
|
||||
.map(|def_id| {
|
||||
let export_level = if special_runtime_crate {
|
||||
let (export_level, used) = if special_runtime_crate {
|
||||
let name = tcx.symbol_name(Instance::mono(tcx, def_id.to_def_id())).name;
|
||||
// We can probably do better here by just ensuring that
|
||||
// it has hidden visibility rather than public
|
||||
// visibility, as this is primarily here to ensure it's
|
||||
// not stripped during LTO.
|
||||
//
|
||||
// In general though we won't link right if these
|
||||
// symbols are stripped, and LTO currently strips them.
|
||||
match name {
|
||||
// We won't link right if these symbols are stripped during LTO.
|
||||
let used = match name {
|
||||
"rust_eh_personality"
|
||||
| "rust_eh_register_frames"
|
||||
| "rust_eh_unregister_frames" =>
|
||||
SymbolExportLevel::C,
|
||||
_ => SymbolExportLevel::Rust,
|
||||
}
|
||||
| "rust_eh_unregister_frames" => true,
|
||||
_ => false,
|
||||
};
|
||||
(SymbolExportLevel::Rust, used)
|
||||
} else {
|
||||
symbol_export_level(tcx, def_id.to_def_id())
|
||||
(symbol_export_level(tcx, def_id.to_def_id()), false)
|
||||
};
|
||||
let codegen_attrs = tcx.codegen_fn_attrs(def_id.to_def_id());
|
||||
debug!(
|
||||
"EXPORTED SYMBOL (local): {} ({:?})",
|
||||
tcx.symbol_name(Instance::mono(tcx, def_id.to_def_id())),
|
||||
export_level
|
||||
);
|
||||
(def_id.to_def_id(), export_level)
|
||||
(def_id.to_def_id(), SymbolExportInfo {
|
||||
level: export_level,
|
||||
kind: if tcx.is_static(def_id.to_def_id()) {
|
||||
if codegen_attrs.flags.contains(CodegenFnAttrFlags::THREAD_LOCAL) {
|
||||
SymbolExportKind::Tls
|
||||
} else {
|
||||
SymbolExportKind::Data
|
||||
}
|
||||
} else {
|
||||
SymbolExportKind::Text
|
||||
},
|
||||
used: codegen_attrs.flags.contains(CodegenFnAttrFlags::USED)
|
||||
|| codegen_attrs.flags.contains(CodegenFnAttrFlags::USED_LINKER) || used,
|
||||
})
|
||||
})
|
||||
.collect();
|
||||
|
||||
if let Some(id) = tcx.proc_macro_decls_static(()) {
|
||||
reachable_non_generics.insert(id.to_def_id(), SymbolExportLevel::C);
|
||||
reachable_non_generics.insert(
|
||||
id.to_def_id(),
|
||||
SymbolExportInfo {
|
||||
level: SymbolExportLevel::C,
|
||||
kind: SymbolExportKind::Data,
|
||||
used: false,
|
||||
},
|
||||
);
|
||||
}
|
||||
|
||||
reachable_non_generics
|
||||
|
@ -141,8 +156,8 @@ fn reachable_non_generics_provider(tcx: TyCtxt<'_>, cnum: CrateNum) -> DefIdMap<
|
|||
fn is_reachable_non_generic_provider_local(tcx: TyCtxt<'_>, def_id: DefId) -> bool {
|
||||
let export_threshold = threshold(tcx);
|
||||
|
||||
if let Some(&level) = tcx.reachable_non_generics(def_id.krate).get(&def_id) {
|
||||
level.is_below_threshold(export_threshold)
|
||||
if let Some(&info) = tcx.reachable_non_generics(def_id.krate).get(&def_id) {
|
||||
info.level.is_below_threshold(export_threshold)
|
||||
} else {
|
||||
false
|
||||
}
|
||||
|
@ -155,7 +170,7 @@ fn is_reachable_non_generic_provider_extern(tcx: TyCtxt<'_>, def_id: DefId) -> b
|
|||
fn exported_symbols_provider_local<'tcx>(
|
||||
tcx: TyCtxt<'tcx>,
|
||||
cnum: CrateNum,
|
||||
) -> &'tcx [(ExportedSymbol<'tcx>, SymbolExportLevel)] {
|
||||
) -> &'tcx [(ExportedSymbol<'tcx>, SymbolExportInfo)] {
|
||||
assert_eq!(cnum, LOCAL_CRATE);
|
||||
|
||||
if !tcx.sess.opts.output_types.should_codegen() {
|
||||
|
@ -165,13 +180,20 @@ fn exported_symbols_provider_local<'tcx>(
|
|||
let mut symbols: Vec<_> = tcx
|
||||
.reachable_non_generics(LOCAL_CRATE)
|
||||
.iter()
|
||||
.map(|(&def_id, &level)| (ExportedSymbol::NonGeneric(def_id), level))
|
||||
.map(|(&def_id, &info)| (ExportedSymbol::NonGeneric(def_id), info))
|
||||
.collect();
|
||||
|
||||
if tcx.entry_fn(()).is_some() {
|
||||
let exported_symbol = ExportedSymbol::NoDefId(SymbolName::new(tcx, "main"));
|
||||
|
||||
symbols.push((exported_symbol, SymbolExportLevel::C));
|
||||
symbols.push((
|
||||
exported_symbol,
|
||||
SymbolExportInfo {
|
||||
level: SymbolExportLevel::C,
|
||||
kind: SymbolExportKind::Text,
|
||||
used: false,
|
||||
},
|
||||
));
|
||||
}
|
||||
|
||||
if tcx.allocator_kind(()).is_some() {
|
||||
|
@ -179,7 +201,14 @@ fn exported_symbols_provider_local<'tcx>(
|
|||
let symbol_name = format!("__rust_{}", method.name);
|
||||
let exported_symbol = ExportedSymbol::NoDefId(SymbolName::new(tcx, &symbol_name));
|
||||
|
||||
symbols.push((exported_symbol, SymbolExportLevel::Rust));
|
||||
symbols.push((
|
||||
exported_symbol,
|
||||
SymbolExportInfo {
|
||||
level: SymbolExportLevel::Rust,
|
||||
kind: SymbolExportKind::Text,
|
||||
used: false,
|
||||
},
|
||||
));
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -192,17 +221,39 @@ fn exported_symbols_provider_local<'tcx>(
|
|||
|
||||
symbols.extend(PROFILER_WEAK_SYMBOLS.iter().map(|sym| {
|
||||
let exported_symbol = ExportedSymbol::NoDefId(SymbolName::new(tcx, sym));
|
||||
(exported_symbol, SymbolExportLevel::C)
|
||||
(
|
||||
exported_symbol,
|
||||
SymbolExportInfo {
|
||||
level: SymbolExportLevel::C,
|
||||
kind: SymbolExportKind::Data,
|
||||
used: false,
|
||||
},
|
||||
)
|
||||
}));
|
||||
}
|
||||
|
||||
if tcx.sess.opts.debugging_opts.sanitizer.contains(SanitizerSet::MEMORY) {
|
||||
// Similar to profiling, preserve weak msan symbol during LTO.
|
||||
const MSAN_WEAK_SYMBOLS: [&str; 2] = ["__msan_track_origins", "__msan_keep_going"];
|
||||
let mut msan_weak_symbols = Vec::new();
|
||||
|
||||
symbols.extend(MSAN_WEAK_SYMBOLS.iter().map(|sym| {
|
||||
// Similar to profiling, preserve weak msan symbol during LTO.
|
||||
if tcx.sess.opts.debugging_opts.sanitizer_recover.contains(SanitizerSet::MEMORY) {
|
||||
msan_weak_symbols.push("__msan_keep_going");
|
||||
}
|
||||
|
||||
if tcx.sess.opts.debugging_opts.sanitizer_memory_track_origins != 0 {
|
||||
msan_weak_symbols.push("__msan_track_origins");
|
||||
}
|
||||
|
||||
symbols.extend(msan_weak_symbols.into_iter().map(|sym| {
|
||||
let exported_symbol = ExportedSymbol::NoDefId(SymbolName::new(tcx, sym));
|
||||
(exported_symbol, SymbolExportLevel::C)
|
||||
(
|
||||
exported_symbol,
|
||||
SymbolExportInfo {
|
||||
level: SymbolExportLevel::C,
|
||||
kind: SymbolExportKind::Data,
|
||||
used: false,
|
||||
},
|
||||
)
|
||||
}));
|
||||
}
|
||||
|
||||
|
@ -210,7 +261,14 @@ fn exported_symbols_provider_local<'tcx>(
|
|||
let symbol_name = metadata_symbol_name(tcx);
|
||||
let exported_symbol = ExportedSymbol::NoDefId(SymbolName::new(tcx, &symbol_name));
|
||||
|
||||
symbols.push((exported_symbol, SymbolExportLevel::Rust));
|
||||
symbols.push((
|
||||
exported_symbol,
|
||||
SymbolExportInfo {
|
||||
level: SymbolExportLevel::Rust,
|
||||
kind: SymbolExportKind::Data,
|
||||
used: false,
|
||||
},
|
||||
));
|
||||
}
|
||||
|
||||
if tcx.sess.opts.share_generics() && tcx.local_crate_exports_generics() {
|
||||
|
@ -243,7 +301,14 @@ fn exported_symbols_provider_local<'tcx>(
|
|||
MonoItem::Fn(Instance { def: InstanceDef::Item(def), substs }) => {
|
||||
if substs.non_erasable_generics().next().is_some() {
|
||||
let symbol = ExportedSymbol::Generic(def.did, substs);
|
||||
symbols.push((symbol, SymbolExportLevel::Rust));
|
||||
symbols.push((
|
||||
symbol,
|
||||
SymbolExportInfo {
|
||||
level: SymbolExportLevel::Rust,
|
||||
kind: SymbolExportKind::Text,
|
||||
used: false,
|
||||
},
|
||||
));
|
||||
}
|
||||
}
|
||||
MonoItem::Fn(Instance { def: InstanceDef::DropGlue(_, Some(ty)), substs }) => {
|
||||
|
@ -252,7 +317,14 @@ fn exported_symbols_provider_local<'tcx>(
|
|||
substs.non_erasable_generics().next(),
|
||||
Some(GenericArgKind::Type(ty))
|
||||
);
|
||||
symbols.push((ExportedSymbol::DropGlue(ty), SymbolExportLevel::Rust));
|
||||
symbols.push((
|
||||
ExportedSymbol::DropGlue(ty),
|
||||
SymbolExportInfo {
|
||||
level: SymbolExportLevel::Rust,
|
||||
kind: SymbolExportKind::Text,
|
||||
used: false,
|
||||
},
|
||||
));
|
||||
}
|
||||
_ => {
|
||||
// Any other symbols don't qualify for sharing
|
||||
|
|
|
@ -23,7 +23,7 @@ use rustc_incremental::{
|
|||
};
|
||||
use rustc_metadata::EncodedMetadata;
|
||||
use rustc_middle::dep_graph::{WorkProduct, WorkProductId};
|
||||
use rustc_middle::middle::exported_symbols::SymbolExportLevel;
|
||||
use rustc_middle::middle::exported_symbols::SymbolExportInfo;
|
||||
use rustc_middle::ty::TyCtxt;
|
||||
use rustc_session::cgu_reuse_tracker::CguReuseTracker;
|
||||
use rustc_session::config::{self, CrateType, Lto, OutputFilenames, OutputType};
|
||||
|
@ -304,7 +304,7 @@ pub type TargetMachineFactoryFn<B> = Arc<
|
|||
+ Sync,
|
||||
>;
|
||||
|
||||
pub type ExportedSymbols = FxHashMap<CrateNum, Arc<Vec<(String, SymbolExportLevel)>>>;
|
||||
pub type ExportedSymbols = FxHashMap<CrateNum, Arc<Vec<(String, SymbolExportInfo)>>>;
|
||||
|
||||
/// Additional resources used by optimize_and_codegen (not module specific)
|
||||
#[derive(Clone)]
|
||||
|
|
|
@ -801,6 +801,12 @@ impl CrateInfo {
|
|||
.iter()
|
||||
.map(|&c| (c, crate::back::linker::exported_symbols(tcx, c)))
|
||||
.collect();
|
||||
let linked_symbols = tcx
|
||||
.sess
|
||||
.crate_types()
|
||||
.iter()
|
||||
.map(|&c| (c, crate::back::linker::linked_symbols(tcx, c)))
|
||||
.collect();
|
||||
let local_crate_name = tcx.crate_name(LOCAL_CRATE);
|
||||
let crate_attrs = tcx.hir().attrs(rustc_hir::CRATE_HIR_ID);
|
||||
let subsystem = tcx.sess.first_attr_value_str_by_name(crate_attrs, sym::windows_subsystem);
|
||||
|
@ -834,6 +840,7 @@ impl CrateInfo {
|
|||
let mut info = CrateInfo {
|
||||
target_cpu,
|
||||
exported_symbols,
|
||||
linked_symbols,
|
||||
local_crate_name,
|
||||
compiler_builtins: None,
|
||||
profiler_runtime: None,
|
||||
|
|
|
@ -28,6 +28,7 @@ use rustc_hir::def_id::CrateNum;
|
|||
use rustc_hir::LangItem;
|
||||
use rustc_middle::dep_graph::WorkProduct;
|
||||
use rustc_middle::middle::dependency_format::Dependencies;
|
||||
use rustc_middle::middle::exported_symbols::SymbolExportKind;
|
||||
use rustc_middle::ty::query::{ExternProviders, Providers};
|
||||
use rustc_serialize::{opaque, Decodable, Decoder, Encoder};
|
||||
use rustc_session::config::{CrateType, OutputFilenames, OutputType, RUST_CGU_EXT};
|
||||
|
@ -141,6 +142,7 @@ impl From<&cstore::NativeLib> for NativeLib {
|
|||
pub struct CrateInfo {
|
||||
pub target_cpu: String,
|
||||
pub exported_symbols: FxHashMap<CrateType, Vec<String>>,
|
||||
pub linked_symbols: FxHashMap<CrateType, Vec<(String, SymbolExportKind)>>,
|
||||
pub local_crate_name: Symbol,
|
||||
pub compiler_builtins: Option<CrateNum>,
|
||||
pub profiler_runtime: Option<CrateNum>,
|
||||
|
|
Loading…
Add table
Add a link
Reference in a new issue