1 use std::collections::hash_map::Entry::*;
3 use rustc_ast::expand::allocator::ALLOCATOR_METHODS;
4 use rustc_data_structures::fingerprint::Fingerprint;
5 use rustc_data_structures::fx::FxHashMap;
7 use rustc_hir::def_id::{CrateNum, DefId, DefIdMap, CRATE_DEF_INDEX, LOCAL_CRATE};
9 use rustc_index::vec::IndexVec;
10 use rustc_middle::middle::codegen_fn_attrs::CodegenFnAttrFlags;
11 use rustc_middle::middle::exported_symbols::{
12 metadata_symbol_name, ExportedSymbol, SymbolExportLevel,
14 use rustc_middle::ty::query::Providers;
15 use rustc_middle::ty::subst::{GenericArgKind, SubstsRef};
16 use rustc_middle::ty::Instance;
17 use rustc_middle::ty::{SymbolName, TyCtxt};
18 use rustc_session::config::{CrateType, SanitizerSet};
20 pub fn threshold(tcx: TyCtxt<'_>) -> SymbolExportLevel {
21 crates_export_threshold(&tcx.sess.crate_types())
24 fn crate_export_threshold(crate_type: CrateType) -> SymbolExportLevel {
26 CrateType::Executable | CrateType::Staticlib | CrateType::ProcMacro | CrateType::Cdylib => {
29 CrateType::Rlib | CrateType::Dylib => SymbolExportLevel::Rust,
33 pub fn crates_export_threshold(crate_types: &[CrateType]) -> SymbolExportLevel {
36 .any(|&crate_type| crate_export_threshold(crate_type) == SymbolExportLevel::Rust)
38 SymbolExportLevel::Rust
44 fn reachable_non_generics_provider(tcx: TyCtxt<'_>, cnum: CrateNum) -> DefIdMap<SymbolExportLevel> {
45 assert_eq!(cnum, LOCAL_CRATE);
47 if !tcx.sess.opts.output_types.should_codegen() {
48 return Default::default();
51 // Check to see if this crate is a "special runtime crate". These
52 // crates, implementation details of the standard library, typically
53 // have a bunch of `pub extern` and `#[no_mangle]` functions as the
54 // ABI between them. We don't want their symbols to have a `C`
55 // export level, however, as they're just implementation details.
56 // Down below we'll hardwire all of the symbols to the `Rust` export
58 let special_runtime_crate =
59 tcx.is_panic_runtime(LOCAL_CRATE) || tcx.is_compiler_builtins(LOCAL_CRATE);
61 let mut reachable_non_generics: DefIdMap<_> = tcx
62 .reachable_set(LOCAL_CRATE)
64 .filter_map(|&hir_id| {
65 // We want to ignore some FFI functions that are not exposed from
66 // this crate. Reachable FFI functions can be lumped into two
69 // 1. Those that are included statically via a static library
70 // 2. Those included otherwise (e.g., dynamically or via a framework)
72 // Although our LLVM module is not literally emitting code for the
73 // statically included symbols, it's an export of our library which
74 // needs to be passed on to the linker and encoded in the metadata.
76 // As a result, if this id is an FFI item (foreign item) then we only
77 // let it through if it's included statically.
78 match tcx.hir().get(hir_id) {
79 Node::ForeignItem(..) => {
80 let def_id = tcx.hir().local_def_id(hir_id);
81 tcx.is_statically_included_foreign_item(def_id).then_some(def_id)
84 // Only consider nodes that actually have exported symbols.
85 Node::Item(&hir::Item {
86 kind: hir::ItemKind::Static(..) | hir::ItemKind::Fn(..),
89 | Node::ImplItem(&hir::ImplItem { kind: hir::ImplItemKind::Fn(..), .. }) => {
90 let def_id = tcx.hir().local_def_id(hir_id);
91 let generics = tcx.generics_of(def_id);
92 if !generics.requires_monomorphization(tcx)
93 // Functions marked with #[inline] are codegened with "internal"
94 // linkage and are not exported unless marked with an extern
96 && (!Instance::mono(tcx, def_id.to_def_id()).def.generates_cgu_internal_copy(tcx)
97 || tcx.codegen_fn_attrs(def_id.to_def_id()).contains_extern_indicator())
109 let export_level = if special_runtime_crate {
110 let name = tcx.symbol_name(Instance::mono(tcx, def_id.to_def_id())).name;
111 // We can probably do better here by just ensuring that
112 // it has hidden visibility rather than public
113 // visibility, as this is primarily here to ensure it's
114 // not stripped during LTO.
116 // In general though we won't link right if these
117 // symbols are stripped, and LTO currently strips them.
119 "rust_eh_personality"
120 | "rust_eh_register_frames"
121 | "rust_eh_unregister_frames" =>
122 SymbolExportLevel::C,
123 _ => SymbolExportLevel::Rust,
126 symbol_export_level(tcx, def_id.to_def_id())
129 "EXPORTED SYMBOL (local): {} ({:?})",
130 tcx.symbol_name(Instance::mono(tcx, def_id.to_def_id())),
133 (def_id.to_def_id(), export_level)
137 if let Some(id) = tcx.proc_macro_decls_static(LOCAL_CRATE) {
138 reachable_non_generics.insert(id, SymbolExportLevel::C);
141 if let Some(id) = tcx.plugin_registrar_fn(LOCAL_CRATE) {
142 reachable_non_generics.insert(id, SymbolExportLevel::C);
145 reachable_non_generics
148 fn is_reachable_non_generic_provider_local(tcx: TyCtxt<'_>, def_id: DefId) -> bool {
149 let export_threshold = threshold(tcx);
151 if let Some(&level) = tcx.reachable_non_generics(def_id.krate).get(&def_id) {
152 level.is_below_threshold(export_threshold)
158 fn is_reachable_non_generic_provider_extern(tcx: TyCtxt<'_>, def_id: DefId) -> bool {
159 tcx.reachable_non_generics(def_id.krate).contains_key(&def_id)
162 fn exported_symbols_provider_local(
165 ) -> &'tcx [(ExportedSymbol<'tcx>, SymbolExportLevel)] {
166 assert_eq!(cnum, LOCAL_CRATE);
168 if !tcx.sess.opts.output_types.should_codegen() {
172 let mut symbols: Vec<_> = tcx
173 .reachable_non_generics(LOCAL_CRATE)
175 .map(|(&def_id, &level)| (ExportedSymbol::NonGeneric(def_id), level))
178 if tcx.entry_fn(LOCAL_CRATE).is_some() {
179 let exported_symbol = ExportedSymbol::NoDefId(SymbolName::new(tcx, "main"));
181 symbols.push((exported_symbol, SymbolExportLevel::C));
184 if tcx.allocator_kind().is_some() {
185 for method in ALLOCATOR_METHODS {
186 let symbol_name = format!("__rust_{}", method.name);
187 let exported_symbol = ExportedSymbol::NoDefId(SymbolName::new(tcx, &symbol_name));
189 symbols.push((exported_symbol, SymbolExportLevel::Rust));
193 if tcx.sess.opts.cg.profile_generate.enabled() {
194 // These are weak symbols that point to the profile version and the
195 // profile name, which need to be treated as exported so LTO doesn't nix
197 const PROFILER_WEAK_SYMBOLS: [&str; 2] =
198 ["__llvm_profile_raw_version", "__llvm_profile_filename"];
200 symbols.extend(PROFILER_WEAK_SYMBOLS.iter().map(|sym| {
201 let exported_symbol = ExportedSymbol::NoDefId(SymbolName::new(tcx, sym));
202 (exported_symbol, SymbolExportLevel::C)
206 if tcx.sess.opts.debugging_opts.instrument_coverage {
207 // Similar to PGO profiling, preserve symbols used by LLVM InstrProf coverage profiling.
208 const COVERAGE_WEAK_SYMBOLS: [&str; 3] =
209 ["__llvm_profile_filename", "__llvm_coverage_mapping", "__llvm_covmap"];
211 symbols.extend(COVERAGE_WEAK_SYMBOLS.iter().map(|sym| {
212 let exported_symbol = ExportedSymbol::NoDefId(SymbolName::new(tcx, sym));
213 (exported_symbol, SymbolExportLevel::C)
217 if tcx.sess.opts.debugging_opts.sanitizer.contains(SanitizerSet::MEMORY) {
218 // Similar to profiling, preserve weak msan symbol during LTO.
219 const MSAN_WEAK_SYMBOLS: [&str; 2] = ["__msan_track_origins", "__msan_keep_going"];
221 symbols.extend(MSAN_WEAK_SYMBOLS.iter().map(|sym| {
222 let exported_symbol = ExportedSymbol::NoDefId(SymbolName::new(tcx, sym));
223 (exported_symbol, SymbolExportLevel::C)
227 if tcx.sess.crate_types().contains(&CrateType::Dylib) {
228 let symbol_name = metadata_symbol_name(tcx);
229 let exported_symbol = ExportedSymbol::NoDefId(SymbolName::new(tcx, &symbol_name));
231 symbols.push((exported_symbol, SymbolExportLevel::Rust));
234 if tcx.sess.opts.share_generics() && tcx.local_crate_exports_generics() {
235 use rustc_middle::mir::mono::{Linkage, MonoItem, Visibility};
236 use rustc_middle::ty::InstanceDef;
238 // Normally, we require that shared monomorphizations are not hidden,
239 // because if we want to re-use a monomorphization from a Rust dylib, it
240 // needs to be exported.
241 // However, on platforms that don't allow for Rust dylibs, having
242 // external linkage is enough for monomorphization to be linked to.
243 let need_visibility = tcx.sess.target.target.options.dynamic_linking
244 && !tcx.sess.target.target.options.only_cdylib;
246 let (_, cgus) = tcx.collect_and_partition_mono_items(LOCAL_CRATE);
248 for (mono_item, &(linkage, visibility)) in cgus.iter().flat_map(|cgu| cgu.items().iter()) {
249 if linkage != Linkage::External {
250 // We can only re-use things with external linkage, otherwise
251 // we'll get a linker error
255 if need_visibility && visibility == Visibility::Hidden {
256 // If we potentially share things from Rust dylibs, they must
262 MonoItem::Fn(Instance { def: InstanceDef::Item(def), substs }) => {
263 if substs.non_erasable_generics().next().is_some() {
264 let symbol = ExportedSymbol::Generic(def.did, substs);
265 symbols.push((symbol, SymbolExportLevel::Rust));
268 MonoItem::Fn(Instance { def: InstanceDef::DropGlue(_, Some(ty)), substs }) => {
269 // A little sanity-check
271 substs.non_erasable_generics().next(),
272 Some(GenericArgKind::Type(ty))
274 symbols.push((ExportedSymbol::DropGlue(ty), SymbolExportLevel::Rust));
277 // Any other symbols don't qualify for sharing
283 // Sort so we get a stable incr. comp. hash.
284 symbols.sort_by_cached_key(|s| s.0.symbol_name_for_local_instance(tcx));
286 tcx.arena.alloc_from_iter(symbols)
289 fn upstream_monomorphizations_provider(
292 ) -> DefIdMap<FxHashMap<SubstsRef<'_>, CrateNum>> {
293 debug_assert!(cnum == LOCAL_CRATE);
295 let cnums = tcx.all_crate_nums(LOCAL_CRATE);
297 let mut instances: DefIdMap<FxHashMap<_, _>> = Default::default();
299 let cnum_stable_ids: IndexVec<CrateNum, Fingerprint> = {
300 let mut cnum_stable_ids = IndexVec::from_elem_n(Fingerprint::ZERO, cnums.len() + 1);
302 for &cnum in cnums.iter() {
303 cnum_stable_ids[cnum] =
304 tcx.def_path_hash(DefId { krate: cnum, index: CRATE_DEF_INDEX }).0;
310 let drop_in_place_fn_def_id = tcx.lang_items().drop_in_place_fn();
312 for &cnum in cnums.iter() {
313 for (exported_symbol, _) in tcx.exported_symbols(cnum).iter() {
314 let (def_id, substs) = match *exported_symbol {
315 ExportedSymbol::Generic(def_id, substs) => (def_id, substs),
316 ExportedSymbol::DropGlue(ty) => {
317 if let Some(drop_in_place_fn_def_id) = drop_in_place_fn_def_id {
318 (drop_in_place_fn_def_id, tcx.intern_substs(&[ty.into()]))
320 // `drop_in_place` in place does not exist, don't try
325 ExportedSymbol::NonGeneric(..) | ExportedSymbol::NoDefId(..) => {
326 // These are no monomorphizations
331 let substs_map = instances.entry(def_id).or_default();
333 match substs_map.entry(substs) {
335 // If there are multiple monomorphizations available,
336 // we select one deterministically.
337 let other_cnum = *e.get();
338 if cnum_stable_ids[other_cnum] > cnum_stable_ids[cnum] {
352 fn upstream_monomorphizations_for_provider(
355 ) -> Option<&FxHashMap<SubstsRef<'_>, CrateNum>> {
356 debug_assert!(!def_id.is_local());
357 tcx.upstream_monomorphizations(LOCAL_CRATE).get(&def_id)
360 fn upstream_drop_glue_for_provider<'tcx>(
362 substs: SubstsRef<'tcx>,
363 ) -> Option<CrateNum> {
364 if let Some(def_id) = tcx.lang_items().drop_in_place_fn() {
365 tcx.upstream_monomorphizations_for(def_id).and_then(|monos| monos.get(&substs).cloned())
371 fn is_unreachable_local_definition_provider(tcx: TyCtxt<'_>, def_id: DefId) -> bool {
372 if let Some(def_id) = def_id.as_local() {
373 !tcx.reachable_set(LOCAL_CRATE).contains(&tcx.hir().as_local_hir_id(def_id))
375 bug!("is_unreachable_local_definition called with non-local DefId: {:?}", def_id)
379 pub fn provide(providers: &mut Providers) {
380 providers.reachable_non_generics = reachable_non_generics_provider;
381 providers.is_reachable_non_generic = is_reachable_non_generic_provider_local;
382 providers.exported_symbols = exported_symbols_provider_local;
383 providers.upstream_monomorphizations = upstream_monomorphizations_provider;
384 providers.is_unreachable_local_definition = is_unreachable_local_definition_provider;
385 providers.upstream_drop_glue_for = upstream_drop_glue_for_provider;
388 pub fn provide_extern(providers: &mut Providers) {
389 providers.is_reachable_non_generic = is_reachable_non_generic_provider_extern;
390 providers.upstream_monomorphizations_for = upstream_monomorphizations_for_provider;
393 fn symbol_export_level(tcx: TyCtxt<'_>, sym_def_id: DefId) -> SymbolExportLevel {
394 // We export anything that's not mangled at the "C" layer as it probably has
395 // to do with ABI concerns. We do not, however, apply such treatment to
396 // special symbols in the standard library for various plumbing between
397 // core/std/allocators/etc. For example symbols used to hook up allocation
398 // are not considered for export
399 let codegen_fn_attrs = tcx.codegen_fn_attrs(sym_def_id);
400 let is_extern = codegen_fn_attrs.contains_extern_indicator();
402 codegen_fn_attrs.flags.contains(CodegenFnAttrFlags::RUSTC_STD_INTERNAL_SYMBOL);
404 if is_extern && !std_internal {
405 let target = &tcx.sess.target.target.llvm_target;
406 // WebAssembly cannot export data symbols, so reduce their export level
407 if target.contains("emscripten") {
408 if let Some(Node::Item(&hir::Item { kind: hir::ItemKind::Static(..), .. })) =
409 tcx.hir().get_if_local(sym_def_id)
411 return SymbolExportLevel::Rust;
417 SymbolExportLevel::Rust
421 /// This is the symbol name of the given instance instantiated in a specific crate.
422 pub fn symbol_name_for_instance_in_crate<'tcx>(
424 symbol: ExportedSymbol<'tcx>,
425 instantiating_crate: CrateNum,
427 // If this is something instantiated in the local crate then we might
428 // already have cached the name as a query result.
429 if instantiating_crate == LOCAL_CRATE {
430 return symbol.symbol_name_for_local_instance(tcx).to_string();
433 // This is something instantiated in an upstream crate, so we have to use
434 // the slower (because uncached) version of computing the symbol name.
436 ExportedSymbol::NonGeneric(def_id) => {
437 rustc_symbol_mangling::symbol_name_for_instance_in_crate(
439 Instance::mono(tcx, def_id),
443 ExportedSymbol::Generic(def_id, substs) => {
444 rustc_symbol_mangling::symbol_name_for_instance_in_crate(
446 Instance::new(def_id, substs),
450 ExportedSymbol::DropGlue(ty) => rustc_symbol_mangling::symbol_name_for_instance_in_crate(
452 Instance::resolve_drop_in_place(tcx, ty),
455 ExportedSymbol::NoDefId(symbol_name) => symbol_name.to_string(),