bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Move stable_crate_ids from CrateStore to Untracked

Browse source 
This way it's like `Definitions`, which creates `DefId`s by interning `DefPathData`s, but for interning stable crate hashes
This commit is contained in:
Oli Scherer 2024-03-26 16:52:06 +00:00
parent 10be74569c
commit fbc9b94064
5 changed files with 42 additions and 32 deletions
Download patch file Download diff file Expand all files Collapse all files

14
compiler/rustc_interface/src/queries.rs
View file

@ -8,7 +8,7 @@ use rustc_codegen_ssa::CodegenResults;
use rustc_data_structures::steal::Steal;
use rustc_data_structures::svh::Svh;
use rustc_data_structures::sync::{AppendOnlyIndexVec, FreezeLock, OnceLock, WorkerLocal};
use rustc_hir::def_id::{StableCrateId, LOCAL_CRATE};
use rustc_hir::def_id::{StableCrateId, StableCrateIdMap, LOCAL_CRATE};
use rustc_hir::definitions::Definitions;
use rustc_incremental::setup_dep_graph;
use rustc_metadata::creader::CStore;
@ -140,11 +140,17 @@ impl<'tcx> Queries<'tcx> {
let cstore = FreezeLock::new(Box::new(CStore::new(
self.compiler.codegen_backend.metadata_loader(),
stable_crate_id,
)) as _);
let definitions = FreezeLock::new(Definitions::new(stable_crate_id));
let untracked =
Untracked { cstore, source_span: AppendOnlyIndexVec::new(), definitions };
let mut stable_crate_ids = StableCrateIdMap::default();
stable_crate_ids.insert(stable_crate_id, LOCAL_CRATE);
let untracked = Untracked {
cstore,
source_span: AppendOnlyIndexVec::new(),
definitions,
stable_crate_ids: FreezeLock::new(stable_crate_ids),
};
let qcx = passes::create_global_ctxt(
self.compiler,

31
compiler/rustc_metadata/src/creader.rs
View file

@ -13,7 +13,7 @@ use rustc_data_structures::sync::{self, FreezeReadGuard, FreezeWriteGuard};
use rustc_errors::DiagCtxt;
use rustc_expand::base::SyntaxExtension;
use rustc_fs_util::try_canonicalize;
use rustc_hir::def_id::{CrateNum, LocalDefId, StableCrateId, StableCrateIdMap, LOCAL_CRATE};
use rustc_hir::def_id::{CrateNum, LocalDefId, StableCrateId, LOCAL_CRATE};
use rustc_hir::definitions::Definitions;
use rustc_index::IndexVec;
use rustc_middle::ty::TyCtxt;
@ -62,9 +62,6 @@ pub struct CStore {
/// This crate has a `#[alloc_error_handler]` item.
has_alloc_error_handler: bool,
/// The interned [StableCrateId]s.
pub(crate) stable_crate_ids: StableCrateIdMap,
/// Unused externs of the crate
unused_externs: Vec<Symbol>,
}
@ -165,9 +162,15 @@ impl CStore {
})
}
fn intern_stable_crate_id(&mut self, root: &CrateRoot) -> Result<CrateNum, CrateError> {
assert_eq!(self.metas.len(), self.stable_crate_ids.len());
if let Some(&existing) = self.stable_crate_ids.get(&root.stable_crate_id()) {
fn intern_stable_crate_id<'tcx>(
&mut self,
root: &CrateRoot,
tcx: TyCtxt<'tcx>,
) -> Result<CrateNum, CrateError> {
assert_eq!(self.metas.len(), tcx.untracked().stable_crate_ids.read().len());
if let Some(&existing) =
tcx.untracked().stable_crate_ids.read().get(&root.stable_crate_id())
{
// Check for (potential) conflicts with the local crate
if existing == LOCAL_CRATE {
Err(CrateError::SymbolConflictsCurrent(root.name()))
@ -180,8 +183,8 @@ impl CStore {
}
} else {
self.metas.push(None);
let num = CrateNum::new(self.stable_crate_ids.len());
self.stable_crate_ids.insert(root.stable_crate_id(), num);
let num = CrateNum::new(tcx.untracked().stable_crate_ids.read().len());
tcx.untracked().stable_crate_ids.write().insert(root.stable_crate_id(), num);
Ok(num)
}
}
@ -289,12 +292,7 @@ impl CStore {
}
}
pub fn new(
metadata_loader: Box<MetadataLoaderDyn>,
local_stable_crate_id: StableCrateId,
) -> CStore {
let mut stable_crate_ids = StableCrateIdMap::default();
stable_crate_ids.insert(local_stable_crate_id, LOCAL_CRATE);
pub fn new(metadata_loader: Box<MetadataLoaderDyn>) -> CStore {
CStore {
metadata_loader,
// We add an empty entry for LOCAL_CRATE (which maps to zero) in
@ -307,7 +305,6 @@ impl CStore {
alloc_error_handler_kind: None,
has_global_allocator: false,
has_alloc_error_handler: false,
stable_crate_ids,
unused_externs: Vec::new(),
}
}
@ -416,7 +413,7 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
let private_dep = self.is_private_dep(name.as_str(), private_dep);
// Claim this crate number and cache it
let cnum = self.cstore.intern_stable_crate_id(&crate_root)?;
let cnum = self.cstore.intern_stable_crate_id(&crate_root, self.tcx)?;
info!(
"register crate `{}` (cnum = {}. private_dep = {})",

15
compiler/rustc_metadata/src/rmeta/decoder/cstore_impl.rs
View file

@ -629,13 +629,6 @@ impl CrateStore for CStore {
self.get_crate_data(cnum).root.stable_crate_id
}
fn stable_crate_id_to_crate_num(&self, stable_crate_id: StableCrateId) -> CrateNum {
*self
.stable_crate_ids
.get(&stable_crate_id)
.unwrap_or_else(|| bug!("uninterned StableCrateId: {stable_crate_id:?}"))
}
/// 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.
@ -657,7 +650,13 @@ fn provide_cstore_hooks(providers: &mut Providers) {
// If this is a DefPathHash from an upstream crate, let the CrateStore map
// it to a DefId.
let cstore = CStore::from_tcx(tcx.tcx);
let cnum = cstore.stable_crate_id_to_crate_num(stable_crate_id);
let cnum = *tcx
.untracked()
.stable_crate_ids
.read()
.get(&stable_crate_id)
.unwrap_or_else(|| bug!("uninterned StableCrateId: {stable_crate_id:?}"));
assert_ne!(cnum, LOCAL_CRATE);
let def_index = cstore.get_crate_data(cnum).def_path_hash_to_def_index(hash);
DefId { krate: cnum, index: def_index }
};

7
compiler/rustc_middle/src/ty/context.rs
View file

@ -1140,7 +1140,12 @@ impl<'tcx> TyCtxt<'tcx> {
if stable_crate_id == self.stable_crate_id(LOCAL_CRATE) {
LOCAL_CRATE
} else {
self.cstore_untracked().stable_crate_id_to_crate_num(stable_crate_id)
*self
.untracked()
.stable_crate_ids
.read()
.get(&stable_crate_id)
.unwrap_or_else(|| bug!("uninterned StableCrateId: {stable_crate_id:?}"))
}
}

7
compiler/rustc_session/src/cstore.rs
View file

@ -6,7 +6,9 @@ use crate::search_paths::PathKind;
use crate::utils::NativeLibKind;
use rustc_ast as ast;
use rustc_data_structures::sync::{self, AppendOnlyIndexVec, FreezeLock};
use rustc_hir::def_id::{CrateNum, DefId, LocalDefId, StableCrateId, LOCAL_CRATE};
use rustc_hir::def_id::{
CrateNum, DefId, LocalDefId, StableCrateId, StableCrateIdMap, LOCAL_CRATE,
};
use rustc_hir::definitions::{DefKey, DefPath, DefPathHash, Definitions};
use rustc_span::symbol::Symbol;
use rustc_span::Span;
@ -217,7 +219,6 @@ pub trait CrateStore: std::fmt::Debug {
// incr. comp. uses to identify a CrateNum.
fn crate_name(&self, cnum: CrateNum) -> Symbol;
fn stable_crate_id(&self, cnum: CrateNum) -> StableCrateId;
fn stable_crate_id_to_crate_num(&self, stable_crate_id: StableCrateId) -> CrateNum;
}
pub type CrateStoreDyn = dyn CrateStore + sync::DynSync + sync::DynSend;
@ -227,4 +228,6 @@ pub struct Untracked {
/// Reference span for definitions.
pub source_span: AppendOnlyIndexVec<LocalDefId, Span>,
pub definitions: FreezeLock<Definitions>,
/// The interned [StableCrateId]s.
pub stable_crate_ids: FreezeLock<StableCrateIdMap>,
}