From e84c926d4758ba8600a3841d442e888fd2c25f6b Mon Sep 17 00:00:00 2001 From: Vadim Petrochenkov Date: Sun, 24 Nov 2019 18:12:02 +0300 Subject: [PATCH] rustc: Move some queries to `rustc_metadata` --- src/librustc/middle/cstore.rs | 6 +--- src/librustc/ty/context.rs | 20 ++--------- src/librustc_metadata/creader.rs | 5 +++ src/librustc_metadata/dependency_format.rs | 6 ++-- .../rmeta/decoder/cstore_impl.rs | 33 +++++++------------ 5 files changed, 24 insertions(+), 46 deletions(-) diff --git a/src/librustc/middle/cstore.rs b/src/librustc/middle/cstore.rs index 5128270148015..44c6f6b07f56c 100644 --- a/src/librustc/middle/cstore.rs +++ b/src/librustc/middle/cstore.rs @@ -211,7 +211,7 @@ pub type MetadataLoaderDyn = dyn MetadataLoader + Sync; /// (it'd break incremental compilation) and should only be called pre-HIR (e.g. /// during resolve) pub trait CrateStore { - fn crate_data_as_any(&self, cnum: CrateNum) -> &dyn Any; + fn as_any(&self) -> &dyn Any; // resolve fn def_key(&self, def: DefId) -> DefKey; @@ -224,9 +224,7 @@ pub trait CrateStore { fn crate_is_private_dep_untracked(&self, cnum: CrateNum) -> bool; fn crate_disambiguator_untracked(&self, cnum: CrateNum) -> CrateDisambiguator; fn crate_hash_untracked(&self, cnum: CrateNum) -> Svh; - fn crate_host_hash_untracked(&self, cnum: CrateNum) -> Option; fn item_generics_cloned_untracked(&self, def: DefId, sess: &Session) -> ty::Generics; - fn postorder_cnums_untracked(&self) -> Vec; // This is basically a 1-based range of ints, which is a little // silly - I may fix that. @@ -235,9 +233,7 @@ pub trait CrateStore { // utility functions fn encode_metadata(&self, tcx: TyCtxt<'_>) -> EncodedMetadata; fn metadata_encoding_version(&self) -> &[u8]; - fn injected_panic_runtime(&self) -> Option; fn allocator_kind(&self) -> Option; - fn has_global_allocator(&self) -> bool; } pub type CrateStoreDyn = dyn CrateStore + sync::Sync; diff --git a/src/librustc/ty/context.rs b/src/librustc/ty/context.rs index 0f3441267f561..5a7078cdb2612 100644 --- a/src/librustc/ty/context.rs +++ b/src/librustc/ty/context.rs @@ -1307,10 +1307,6 @@ impl<'tcx> TyCtxt<'tcx> { self.all_crate_nums(LOCAL_CRATE) } - pub fn injected_panic_runtime(self) -> Option { - self.cstore.injected_panic_runtime() - } - pub fn allocator_kind(self) -> Option { self.cstore.allocator_kind() } @@ -1391,8 +1387,8 @@ impl<'tcx> TyCtxt<'tcx> { // Note that this is *untracked* and should only be used within the query // system if the result is otherwise tracked through queries - pub fn crate_data_as_any(self, cnum: CrateNum) -> &'tcx dyn Any { - self.cstore.crate_data_as_any(cnum) + pub fn cstore_as_any(self) -> &'tcx dyn Any { + self.cstore.as_any() } #[inline(always)] @@ -2999,14 +2995,6 @@ pub fn provide(providers: &mut ty::query::Providers<'_>) { assert_eq!(cnum, LOCAL_CRATE); tcx.arena.alloc_slice(&tcx.cstore.crates_untracked()) }; - providers.crate_host_hash = |tcx, cnum| { - assert_ne!(cnum, LOCAL_CRATE); - tcx.cstore.crate_host_hash_untracked(cnum) - }; - providers.postorder_cnums = |tcx, cnum| { - assert_eq!(cnum, LOCAL_CRATE); - tcx.arena.alloc_slice(&tcx.cstore.postorder_cnums_untracked()) - }; providers.output_filenames = |tcx, cnum| { assert_eq!(cnum, LOCAL_CRATE); tcx.output_filenames.clone() @@ -3028,8 +3016,4 @@ pub fn provide(providers: &mut ty::query::Providers<'_>) { // We want to check if the panic handler was defined in this crate tcx.lang_items().panic_impl().map_or(false, |did| did.is_local()) }; - providers.has_global_allocator = |tcx, cnum| { - assert_eq!(cnum, LOCAL_CRATE); - tcx.cstore.has_global_allocator() - }; } diff --git a/src/librustc_metadata/creader.rs b/src/librustc_metadata/creader.rs index 00f3f7f08faba..dbf2dcf1c0aea 100644 --- a/src/librustc_metadata/creader.rs +++ b/src/librustc_metadata/creader.rs @@ -15,6 +15,7 @@ use rustc::session::search_paths::PathKind; use rustc::middle::cstore::{CrateSource, ExternCrate, ExternCrateSource, MetadataLoaderDyn}; use rustc::hir::map::Definitions; use rustc::hir::def_id::LOCAL_CRATE; +use rustc::ty::TyCtxt; use std::path::Path; use std::{cmp, fs}; @@ -94,6 +95,10 @@ fn dump_crates(cstore: &CStore) { } impl CStore { + crate fn from_tcx(tcx: TyCtxt<'_>) -> &CStore { + tcx.cstore_as_any().downcast_ref::().expect("`tcx.cstore` is not a `CStore`") + } + fn alloc_new_crate_num(&mut self) -> CrateNum { self.metas.push(None); CrateNum::new(self.metas.len() - 1) diff --git a/src/librustc_metadata/dependency_format.rs b/src/librustc_metadata/dependency_format.rs index dbf7fede1469f..d6d722c47b3a7 100644 --- a/src/librustc_metadata/dependency_format.rs +++ b/src/librustc_metadata/dependency_format.rs @@ -51,6 +51,8 @@ //! Additionally, the algorithm is geared towards finding *any* solution rather //! than finding a number of solutions (there are normally quite a few). +use crate::creader::CStore; + use rustc::hir::def_id::CrateNum; use rustc::middle::cstore::LinkagePreference::{self, RequireStatic, RequireDynamic}; use rustc::middle::cstore::{self, DepKind}; @@ -184,7 +186,7 @@ fn calculate_type(tcx: TyCtxt<'_>, ty: config::CrateType) -> DependencyList { // // Things like allocators and panic runtimes may not have been activated // quite yet, so do so here. - activate_injected_dep(tcx.injected_panic_runtime(), &mut ret, + activate_injected_dep(CStore::from_tcx(tcx).injected_panic_runtime(), &mut ret, &|cnum| tcx.is_panic_runtime(cnum)); // When dylib B links to dylib A, then when using B we must also link to A. @@ -263,7 +265,7 @@ fn attempt_static(tcx: TyCtxt<'_>) -> Option { // Our allocator/panic runtime may not have been linked above if it wasn't // explicitly linked, which is the case for any injected dependency. Handle // that here and activate them. - activate_injected_dep(tcx.injected_panic_runtime(), &mut ret, + activate_injected_dep(CStore::from_tcx(tcx).injected_panic_runtime(), &mut ret, &|cnum| tcx.is_panic_runtime(cnum)); Some(ret) diff --git a/src/librustc_metadata/rmeta/decoder/cstore_impl.rs b/src/librustc_metadata/rmeta/decoder/cstore_impl.rs index f21fff956d4fb..8214153f153f1 100644 --- a/src/librustc_metadata/rmeta/decoder/cstore_impl.rs +++ b/src/librustc_metadata/rmeta/decoder/cstore_impl.rs @@ -51,9 +51,7 @@ macro_rules! provide { let ($def_id, $other) = def_id_arg.into_args(); assert!(!$def_id.is_local()); - let $cdata = $tcx.crate_data_as_any($def_id.krate); - let $cdata = $cdata.downcast_ref::() - .expect("CrateStore created data is not a CrateMetadata"); + let $cdata = CStore::from_tcx($tcx).get_crate_data($def_id.krate); if $tcx.dep_graph.is_fully_enabled() { let crate_dep_node_index = $cdata.get_crate_dep_node_index($tcx); @@ -192,6 +190,7 @@ provide! { <'tcx> tcx, def_id, other, cdata, } crate_disambiguator => { cdata.root.disambiguator } crate_hash => { cdata.root.hash } + crate_host_hash => { cdata.host_hash } original_crate_name => { cdata.root.name } extra_filename => { cdata.root.extra_filename.clone() } @@ -377,6 +376,14 @@ pub fn provide(providers: &mut Providers<'_>) { assert_eq!(cnum, LOCAL_CRATE); Lrc::new(crate::dependency_format::calculate(tcx)) }, + has_global_allocator: |tcx, cnum| { + assert_eq!(cnum, LOCAL_CRATE); + CStore::from_tcx(tcx).has_global_allocator() + }, + postorder_cnums: |tcx, cnum| { + assert_eq!(cnum, LOCAL_CRATE); + tcx.arena.alloc_slice(&CStore::from_tcx(tcx).crate_dependencies_in_postorder(cnum)) + }, ..*providers }; @@ -459,8 +466,8 @@ impl CStore { } impl CrateStore for CStore { - fn crate_data_as_any(&self, cnum: CrateNum) -> &dyn Any { - self.get_crate_data(cnum) + fn as_any(&self) -> &dyn Any { + self } fn item_generics_cloned_untracked(&self, def: DefId, sess: &Session) -> ty::Generics { @@ -486,10 +493,6 @@ impl CrateStore for CStore { self.get_crate_data(cnum).root.hash } - fn crate_host_hash_untracked(&self, cnum: CrateNum) -> Option { - self.get_crate_data(cnum).host_hash - } - /// Returns the `DefKey` for a given `DefId`. This indicates the /// parent `DefId` as well as some idea of what kind of data the /// `DefId` refers to. @@ -516,10 +519,6 @@ impl CrateStore for CStore { result } - fn postorder_cnums_untracked(&self) -> Vec { - self.crate_dependencies_in_postorder(LOCAL_CRATE) - } - fn encode_metadata(&self, tcx: TyCtxt<'_>) -> EncodedMetadata { encoder::encode_metadata(tcx) } @@ -529,15 +528,7 @@ impl CrateStore for CStore { rmeta::METADATA_HEADER } - fn injected_panic_runtime(&self) -> Option { - self.injected_panic_runtime() - } - fn allocator_kind(&self) -> Option { self.allocator_kind() } - - fn has_global_allocator(&self) -> bool { - self.has_global_allocator() - } }