diff --git a/src/librustc/dep_graph/dep_node.rs b/src/librustc/dep_graph/dep_node.rs index 5f6a7c452c4..84fdeba4ab3 100644 --- a/src/librustc/dep_graph/dep_node.rs +++ b/src/librustc/dep_graph/dep_node.rs @@ -556,7 +556,7 @@ define_dep_nodes!( <'tcx> [] RvaluePromotableMap(DefId), [] ImplParent(DefId), [] TraitOfItem(DefId), - [] IsExportedSymbol(DefId), + [] IsReachableNonGeneric(DefId), [] IsMirAvailable(DefId), [] ItemAttrs(DefId), [] FnArgNames(DefId), @@ -574,7 +574,7 @@ define_dep_nodes!( <'tcx> [] GetPanicStrategy(CrateNum), [] IsNoBuiltins(CrateNum), [] ImplDefaultness(DefId), - [] ExportedSymbolIds(CrateNum), + [] ReachableNonGenerics(CrateNum), [] NativeLibraries(CrateNum), [] PluginRegistrarFn(CrateNum), [] DeriveRegistrarFn(CrateNum), diff --git a/src/librustc/ty/maps/config.rs b/src/librustc/ty/maps/config.rs index c91b30440e5..cfc552bdc85 100644 --- a/src/librustc/ty/maps/config.rs +++ b/src/librustc/ty/maps/config.rs @@ -212,9 +212,9 @@ impl<'tcx> QueryDescription<'tcx> for queries::item_attrs<'tcx> { } } -impl<'tcx> QueryDescription<'tcx> for queries::is_exported_symbol<'tcx> { +impl<'tcx> QueryDescription<'tcx> for queries::is_reachable_non_generic<'tcx> { fn describe(_: TyCtxt, _: DefId) -> String { - bug!("is_exported_symbol") + bug!("is_reachable_non_generic") } } @@ -383,7 +383,7 @@ impl<'tcx> QueryDescription<'tcx> for queries::is_sanitizer_runtime<'tcx> { } } -impl<'tcx> QueryDescription<'tcx> for queries::exported_symbol_ids<'tcx> { +impl<'tcx> QueryDescription<'tcx> for queries::reachable_non_generics<'tcx> { fn describe(_tcx: TyCtxt, _: CrateNum) -> String { format!("looking up the exported symbols of a crate") } diff --git a/src/librustc/ty/maps/mod.rs b/src/librustc/ty/maps/mod.rs index c211713db6b..e91ccce8ffa 100644 --- a/src/librustc/ty/maps/mod.rs +++ b/src/librustc/ty/maps/mod.rs @@ -238,7 +238,6 @@ define_maps! { <'tcx> [] fn fn_arg_names: FnArgNames(DefId) -> Vec, [] fn impl_parent: ImplParent(DefId) -> Option, [] fn trait_of_item: TraitOfItem(DefId) -> Option, - [] fn is_exported_symbol: IsExportedSymbol(DefId) -> bool, [] fn item_body_nested_bodies: ItemBodyNestedBodies(DefId) -> ExternBodyNestedBodies, [] fn const_is_rvalue_promotable_to_static: ConstIsRvaluePromotableToStatic(DefId) -> bool, [] fn rvalue_promotable_map: RvaluePromotableMap(DefId) -> Lrc, @@ -290,7 +289,23 @@ define_maps! { <'tcx> [] fn lint_levels: lint_levels_node(CrateNum) -> Lrc, [] fn impl_defaultness: ImplDefaultness(DefId) -> hir::Defaultness, - [] fn exported_symbol_ids: ExportedSymbolIds(CrateNum) -> Lrc, + + // The DefIds of all non-generic functions and statics in the given crate + // that can be reached from outside the crate. + // + // We expect this items to be available for being linked to. + // + // This query can also be called for LOCAL_CRATE. In this case it will + // compute which items will be reachable to other crates, taking into account + // the kind of crate that is currently compiled. Crates with only a + // C interface have fewer reachable things. + // + // Does not include external symbols that don't have a corresponding DefId, + // like the compiler-generated `main` function and so on. + [] fn reachable_non_generics: ReachableNonGenerics(CrateNum) -> Lrc, + [] fn is_reachable_non_generic: IsReachableNonGeneric(DefId) -> bool, + + [] fn native_libraries: NativeLibraries(CrateNum) -> Lrc>, [] fn plugin_registrar_fn: PluginRegistrarFn(CrateNum) -> Option, [] fn derive_registrar_fn: DeriveRegistrarFn(CrateNum) -> Option, diff --git a/src/librustc/ty/maps/plumbing.rs b/src/librustc/ty/maps/plumbing.rs index 3443b9b61b2..13f286d6a26 100644 --- a/src/librustc/ty/maps/plumbing.rs +++ b/src/librustc/ty/maps/plumbing.rs @@ -851,7 +851,7 @@ pub fn force_from_dep_node<'a, 'gcx, 'lcx>(tcx: TyCtxt<'a, 'gcx, 'lcx>, DepKind::RvaluePromotableMap => { force!(rvalue_promotable_map, def_id!()); } DepKind::ImplParent => { force!(impl_parent, def_id!()); } DepKind::TraitOfItem => { force!(trait_of_item, def_id!()); } - DepKind::IsExportedSymbol => { force!(is_exported_symbol, def_id!()); } + DepKind::IsReachableNonGeneric => { force!(is_reachable_non_generic, def_id!()); } DepKind::IsMirAvailable => { force!(is_mir_available, def_id!()); } DepKind::ItemAttrs => { force!(item_attrs, def_id!()); } DepKind::FnArgNames => { force!(fn_arg_names, def_id!()); } @@ -868,7 +868,7 @@ pub fn force_from_dep_node<'a, 'gcx, 'lcx>(tcx: TyCtxt<'a, 'gcx, 'lcx>, DepKind::GetPanicStrategy => { force!(panic_strategy, krate!()); } DepKind::IsNoBuiltins => { force!(is_no_builtins, krate!()); } DepKind::ImplDefaultness => { force!(impl_defaultness, def_id!()); } - DepKind::ExportedSymbolIds => { force!(exported_symbol_ids, krate!()); } + DepKind::ReachableNonGenerics => { force!(reachable_non_generics, krate!()); } DepKind::NativeLibraries => { force!(native_libraries, krate!()); } DepKind::PluginRegistrarFn => { force!(plugin_registrar_fn, krate!()); } DepKind::DeriveRegistrarFn => { force!(derive_registrar_fn, krate!()); } diff --git a/src/librustc_metadata/creader.rs b/src/librustc_metadata/creader.rs index 876e7e8dc31..789ecd0f613 100644 --- a/src/librustc_metadata/creader.rs +++ b/src/librustc_metadata/creader.rs @@ -225,9 +225,6 @@ impl<'a> CrateLoader<'a> { crate_root.def_path_table.decode((&metadata, self.sess)) }); - let exported_symbols = crate_root.exported_symbols - .decode((&metadata, self.sess)) - .collect(); let trait_impls = crate_root .impls .decode((&metadata, self.sess)) @@ -238,7 +235,6 @@ impl<'a> CrateLoader<'a> { name, extern_crate: Cell::new(None), def_path_table: Lrc::new(def_path_table), - exported_symbols, trait_impls, proc_macros: crate_root.macro_derive_registrar.map(|_| { self.load_derive_macros(&crate_root, dylib.clone().map(|p| p.0), span) diff --git a/src/librustc_metadata/cstore.rs b/src/librustc_metadata/cstore.rs index 8b59eec0190..2e95c23b4ae 100644 --- a/src/librustc_metadata/cstore.rs +++ b/src/librustc_metadata/cstore.rs @@ -78,8 +78,6 @@ pub struct CrateMetadata { /// compilation support. pub def_path_table: Lrc, - pub exported_symbols: FxHashSet, - pub trait_impls: FxHashMap<(u32, DefIndex), schema::LazySeq>, pub dep_kind: Cell, diff --git a/src/librustc_metadata/cstore_impl.rs b/src/librustc_metadata/cstore_impl.rs index 7b8194d9eab..20fc45696a9 100644 --- a/src/librustc_metadata/cstore_impl.rs +++ b/src/librustc_metadata/cstore_impl.rs @@ -160,9 +160,6 @@ provide! { <'tcx> tcx, def_id, other, cdata, fn_arg_names => { cdata.get_fn_arg_names(def_id.index) } impl_parent => { cdata.get_parent_impl(def_id.index) } trait_of_item => { cdata.get_trait_of_item(def_id.index) } - is_exported_symbol => { - cdata.exported_symbols.contains(&def_id.index) - } item_body_nested_bodies => { cdata.item_body_nested_bodies(def_id.index) } const_is_rvalue_promotable_to_static => { cdata.const_is_rvalue_promotable_to_static(def_id.index) @@ -179,7 +176,7 @@ provide! { <'tcx> tcx, def_id, other, cdata, extern_crate => { Lrc::new(cdata.extern_crate.get()) } is_no_builtins => { cdata.is_no_builtins(tcx.sess) } impl_defaultness => { cdata.get_impl_defaultness(def_id.index) } - exported_symbol_ids => { Lrc::new(cdata.get_exported_symbols()) } + reachable_non_generics => { Lrc::new(cdata.reachable_non_generics()) } native_libraries => { Lrc::new(cdata.get_native_libraries(tcx.sess)) } plugin_registrar_fn => { cdata.root.plugin_registrar_fn.map(|index| { diff --git a/src/librustc_metadata/decoder.rs b/src/librustc_metadata/decoder.rs index 0c6a286e227..2831b63bbac 100644 --- a/src/librustc_metadata/decoder.rs +++ b/src/librustc_metadata/decoder.rs @@ -1006,10 +1006,11 @@ impl<'a, 'tcx> CrateMetadata { arg_names.decode(self).collect() } - pub fn get_exported_symbols(&self) -> DefIdSet { - self.exported_symbols - .iter() - .map(|&index| self.local_def_id(index)) + pub fn reachable_non_generics(&self) -> DefIdSet { + self.root + .reachable_non_generics + .decode(self) + .map(|index| self.local_def_id(index)) .collect() } diff --git a/src/librustc_metadata/encoder.rs b/src/librustc_metadata/encoder.rs index d3f046c5544..7198f7ccf35 100644 --- a/src/librustc_metadata/encoder.rs +++ b/src/librustc_metadata/encoder.rs @@ -53,7 +53,7 @@ pub struct EncodeContext<'a, 'tcx: 'a> { opaque: opaque::Encoder<'a>, pub tcx: TyCtxt<'a, 'tcx, 'tcx>, link_meta: &'a LinkMeta, - exported_symbols: &'a NodeSet, + reachable_non_generics: &'a NodeSet, lazy_state: LazyState, type_shorthands: FxHashMap, usize>, @@ -395,10 +395,10 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> { // Encode exported symbols info. i = self.position(); - let exported_symbols = self.tracked( - IsolatedEncoder::encode_exported_symbols, - self.exported_symbols); - let exported_symbols_bytes = self.position() - i; + let reachable_non_generics = self.tracked( + IsolatedEncoder::encode_reachable_non_generics, + self.reachable_non_generics); + let reachable_non_generics_bytes = self.position() - i; // Encode and index the items. i = self.position(); @@ -442,7 +442,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> { codemap, def_path_table, impls, - exported_symbols, + reachable_non_generics, index, }); @@ -462,7 +462,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> { println!(" native bytes: {}", native_lib_bytes); println!(" codemap bytes: {}", codemap_bytes); println!(" impl bytes: {}", impl_bytes); - println!(" exp. symbols bytes: {}", exported_symbols_bytes); + println!(" exp. symbols bytes: {}", reachable_non_generics_bytes); println!(" def-path table bytes: {}", def_path_table_bytes); println!(" item bytes: {}", item_bytes); println!(" index bytes: {}", index_bytes); @@ -1388,9 +1388,12 @@ impl<'a, 'b: 'a, 'tcx: 'b> IsolatedEncoder<'a, 'b, 'tcx> { // middle::reachable module but filters out items that either don't have a // symbol associated with them (they weren't translated) or if they're an FFI // definition (as that's not defined in this crate). - fn encode_exported_symbols(&mut self, exported_symbols: &NodeSet) -> LazySeq { + fn encode_reachable_non_generics(&mut self, + reachable_non_generics: &NodeSet) + -> LazySeq { let tcx = self.tcx; - self.lazy_seq(exported_symbols.iter().map(|&id| tcx.hir.local_def_id(id).index)) + self.lazy_seq(reachable_non_generics.iter() + .map(|&id| tcx.hir.local_def_id(id).index)) } fn encode_dylib_dependency_formats(&mut self, _: ()) -> LazySeq> { @@ -1664,7 +1667,7 @@ impl<'a, 'tcx, 'v> ItemLikeVisitor<'v> for ImplVisitor<'a, 'tcx> { pub fn encode_metadata<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, link_meta: &LinkMeta, - exported_symbols: &NodeSet) + reachable_non_generics: &NodeSet) -> EncodedMetadata { let mut cursor = Cursor::new(vec![]); @@ -1678,7 +1681,7 @@ pub fn encode_metadata<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, opaque: opaque::Encoder::new(&mut cursor), tcx, link_meta, - exported_symbols, + reachable_non_generics, lazy_state: LazyState::NoNode, type_shorthands: Default::default(), predicate_shorthands: Default::default(), diff --git a/src/librustc_metadata/schema.rs b/src/librustc_metadata/schema.rs index c542f65dcec..3e7d31513a2 100644 --- a/src/librustc_metadata/schema.rs +++ b/src/librustc_metadata/schema.rs @@ -202,7 +202,7 @@ pub struct CrateRoot { pub codemap: LazySeq, pub def_path_table: Lazy, pub impls: LazySeq, - pub exported_symbols: LazySeq, + pub reachable_non_generics: LazySeq, pub index: LazySeq, } diff --git a/src/librustc_mir/monomorphize/collector.rs b/src/librustc_mir/monomorphize/collector.rs index eb4ba21489c..10c2f9f758f 100644 --- a/src/librustc_mir/monomorphize/collector.rs +++ b/src/librustc_mir/monomorphize/collector.rs @@ -736,7 +736,7 @@ fn should_monomorphize_locally<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, instance: } Some(_) => true, None => { - if tcx.is_exported_symbol(def_id) || + if tcx.is_reachable_non_generic(def_id) || tcx.is_foreign_item(def_id) { // We can link to the item in question, no instance needed @@ -984,7 +984,7 @@ impl<'b, 'a, 'v> RootCollector<'b, 'a, 'v> { } MonoItemCollectionMode::Lazy => { self.entry_fn == Some(def_id) || - self.tcx.is_exported_symbol(def_id) || + self.tcx.is_reachable_non_generic(def_id) || attr::contains_name(&self.tcx.get_attrs(def_id), "rustc_std_internal_symbol") } diff --git a/src/librustc_mir/monomorphize/partitioning.rs b/src/librustc_mir/monomorphize/partitioning.rs index 2b558e71483..d65c1e03298 100644 --- a/src/librustc_mir/monomorphize/partitioning.rs +++ b/src/librustc_mir/monomorphize/partitioning.rs @@ -363,7 +363,7 @@ fn place_root_translation_items<'a, 'tcx, I>(tcx: TyCtxt<'a, 'tcx, 'tcx>, can_be_internalized = false; Visibility::Hidden } else if def_id.is_local() { - if tcx.is_exported_symbol(def_id) { + if tcx.is_reachable_non_generic(def_id) { can_be_internalized = false; default_visibility(def_id) } else { @@ -385,7 +385,7 @@ fn place_root_translation_items<'a, 'tcx, I>(tcx: TyCtxt<'a, 'tcx, 'tcx>, (Linkage::External, visibility) } MonoItem::Static(def_id) => { - let visibility = if tcx.is_exported_symbol(def_id) { + let visibility = if tcx.is_reachable_non_generic(def_id) { can_be_internalized = false; default_visibility(def_id) } else { @@ -395,7 +395,7 @@ fn place_root_translation_items<'a, 'tcx, I>(tcx: TyCtxt<'a, 'tcx, 'tcx>, } MonoItem::GlobalAsm(node_id) => { let def_id = tcx.hir.local_def_id(node_id); - let visibility = if tcx.is_exported_symbol(def_id) { + let visibility = if tcx.is_reachable_non_generic(def_id) { can_be_internalized = false; default_visibility(def_id) } else { diff --git a/src/librustc_trans/back/symbol_export.rs b/src/librustc_trans/back/symbol_export.rs index 55ef4e7ed3a..57da02eaa52 100644 --- a/src/librustc_trans/back/symbol_export.rs +++ b/src/librustc_trans/back/symbol_export.rs @@ -61,7 +61,7 @@ pub fn crates_export_threshold(crate_types: &[config::CrateType]) } pub fn provide(providers: &mut Providers) { - providers.exported_symbol_ids = |tcx, cnum| { + providers.reachable_non_generics = |tcx, cnum| { let export_threshold = threshold(tcx); Lrc::new(tcx.exported_symbols(cnum) .iter() @@ -77,8 +77,8 @@ pub fn provide(providers: &mut Providers) { .collect()) }; - providers.is_exported_symbol = |tcx, id| { - tcx.exported_symbol_ids(id.krate).contains(&id) + providers.is_reachable_non_generic = |tcx, id| { + tcx.reachable_non_generics(id.krate).contains(&id) }; providers.exported_symbols = |tcx, cnum| { @@ -156,7 +156,7 @@ pub fn provide_extern(providers: &mut Providers) { tcx.is_panic_runtime(cnum) || tcx.is_compiler_builtins(cnum); let mut crate_exports: Vec<_> = tcx - .exported_symbol_ids(cnum) + .reachable_non_generics(cnum) .iter() .map(|&def_id| { let name = tcx.symbol_name(Instance::mono(tcx, def_id)); @@ -190,6 +190,11 @@ pub fn provide_extern(providers: &mut Providers) { Arc::new(crate_exports) }; + + providers.is_reachable_non_generic = |tcx, id| { + tcx.reachable_non_generics(id.krate).contains(&id) + }; + providers.symbol_export_level = export_level; } diff --git a/src/librustc_trans/callee.rs b/src/librustc_trans/callee.rs index 8c40aa6a2ac..54cc561e804 100644 --- a/src/librustc_trans/callee.rs +++ b/src/librustc_trans/callee.rs @@ -151,7 +151,7 @@ pub fn get_fn<'a, 'tcx>(cx: &CodegenCx<'a, 'tcx>, if cx.tcx.is_translated_item(instance_def_id) { if instance_def_id.is_local() { - if !cx.tcx.is_exported_symbol(instance_def_id) { + if !cx.tcx.is_reachable_non_generic(instance_def_id) { llvm::LLVMRustSetVisibility(llfn, llvm::Visibility::Hidden); } } else { diff --git a/src/librustc_trans/consts.rs b/src/librustc_trans/consts.rs index 1608c4a87bf..fd9cb8c5a6b 100644 --- a/src/librustc_trans/consts.rs +++ b/src/librustc_trans/consts.rs @@ -134,7 +134,7 @@ pub fn get_static(cx: &CodegenCx, def_id: DefId) -> ValueRef { let g = declare::define_global(cx, &sym[..], llty).unwrap(); - if !cx.tcx.is_exported_symbol(def_id) { + if !cx.tcx.is_reachable_non_generic(def_id) { unsafe { llvm::LLVMRustSetVisibility(g, llvm::Visibility::Hidden); } diff --git a/src/librustc_trans/debuginfo/utils.rs b/src/librustc_trans/debuginfo/utils.rs index 9559cd4d9ea..0a3f06b55f1 100644 --- a/src/librustc_trans/debuginfo/utils.rs +++ b/src/librustc_trans/debuginfo/utils.rs @@ -32,7 +32,7 @@ pub fn is_node_local_to_unit(cx: &CodegenCx, def_id: DefId) -> bool // visible). It might better to use the `exported_items` set from // `driver::CrateAnalysis` in the future, but (atm) this set is not // available in the translation pass. - !cx.tcx.is_exported_symbol(def_id) + !cx.tcx.is_reachable_non_generic(def_id) } #[allow(non_snake_case)]