use crate::middle::lang_items;
use crate::middle::resolve_lifetime::{self, ObjectLifetimeDefault};
use crate::middle::stability;
-use crate::mir::{self, Mir, interpret, ProjectionKind};
-use crate::mir::interpret::{ConstValue, Allocation};
+use crate::mir::{self, Body, interpret, ProjectionKind};
+use crate::mir::interpret::{ConstValue, Allocation, Scalar};
use crate::ty::subst::{Kind, InternalSubsts, SubstsRef, Subst};
use crate::ty::ReprOptions;
use crate::traits;
use rustc_data_structures::stable_hasher::{HashStable, hash_stable_hashmap,
StableHasher, StableHasherResult,
StableVec};
-use arena::{TypedArena, SyncDroplessArena};
+use arena::SyncDroplessArena;
use rustc_data_structures::indexed_vec::{Idx, IndexVec};
use rustc_data_structures::sync::{Lrc, Lock, WorkerLocal};
use std::any::Any;
use crate::hir;
-pub struct AllArenas<'tcx> {
- pub global: WorkerLocal<GlobalArenas<'tcx>>,
+pub struct AllArenas {
pub interner: SyncDroplessArena,
}
-impl<'tcx> AllArenas<'tcx> {
+impl AllArenas {
pub fn new() -> Self {
AllArenas {
- global: WorkerLocal::new(|_| GlobalArenas::default()),
interner: SyncDroplessArena::default(),
}
}
}
-/// Internal storage
-#[derive(Default)]
-pub struct GlobalArenas<'tcx> {
- // internings
- layout: TypedArena<LayoutDetails>,
-
- // references
- generics: TypedArena<ty::Generics>,
- trait_def: TypedArena<ty::TraitDef>,
- adt_def: TypedArena<ty::AdtDef>,
- steal_mir: TypedArena<Steal<Mir<'tcx>>>,
- mir: TypedArena<Mir<'tcx>>,
- tables: TypedArena<ty::TypeckTables<'tcx>>,
- /// miri allocations
- const_allocs: TypedArena<interpret::Allocation>,
-}
-
type InternedSet<'tcx, T> = Lock<FxHashMap<Interned<'tcx, T>, ()>>;
pub struct CtxtInterners<'tcx> {
}
}
+pub struct Common<'tcx> {
+ pub empty_predicates: ty::GenericPredicates<'tcx>,
+}
+
pub struct CommonTypes<'tcx> {
pub unit: Ty<'tcx>,
pub bool: Ty<'tcx>,
};
CommonConsts {
- err: mk_const(ty::Const::zero_sized(types.err)),
+ err: mk_const(ty::Const {
+ val: ConstValue::Scalar(Scalar::zst()),
+ ty: types.err,
+ }),
}
}
}
pub struct GlobalCtxt<'tcx> {
pub arena: WorkerLocal<Arena<'tcx>>,
- global_arenas: &'tcx WorkerLocal<GlobalArenas<'tcx>>,
+
global_interners: CtxtInterners<'tcx>,
cstore: &'tcx CrateStoreDyn,
pub dep_graph: DepGraph,
+ /// Common objects.
+ pub common: Common<'tcx>,
+
/// Common types, pre-interned for your convenience.
pub types: CommonTypes<'tcx>,
/// Map indicating what traits are in scope for places where this
/// is relevant; generated by resolve.
trait_map: FxHashMap<DefIndex,
- Lrc<FxHashMap<ItemLocalId,
- Lrc<StableVec<TraitCandidate>>>>>,
+ FxHashMap<ItemLocalId,
+ StableVec<TraitCandidate>>>,
/// Export map produced by name resolution.
- export_map: FxHashMap<DefId, Lrc<Vec<Export<hir::HirId>>>>,
+ export_map: FxHashMap<DefId, Vec<Export<hir::HirId>>>,
hir_map: hir_map::Map<'tcx>,
// Records the captured variables referenced by every closure
// expression. Do not track deps for this, just recompute it from
// scratch every time.
- upvars: FxHashMap<DefId, Lrc<Vec<hir::Upvar>>>,
+ upvars: FxHashMap<DefId, Vec<hir::Upvar>>,
maybe_unused_trait_imports: FxHashSet<DefId>,
maybe_unused_extern_crates: Vec<(DefId, Span)>,
&self.hir_map
}
- pub fn alloc_generics(self, generics: ty::Generics) -> &'gcx ty::Generics {
- self.global_arenas.generics.alloc(generics)
- }
-
- pub fn alloc_steal_mir(self, mir: Mir<'gcx>) -> &'gcx Steal<Mir<'gcx>> {
- self.global_arenas.steal_mir.alloc(Steal::new(mir))
- }
-
- pub fn alloc_mir(self, mir: Mir<'gcx>) -> &'gcx Mir<'gcx> {
- self.global_arenas.mir.alloc(mir)
- }
-
- pub fn alloc_tables(self, tables: ty::TypeckTables<'gcx>) -> &'gcx ty::TypeckTables<'gcx> {
- self.global_arenas.tables.alloc(tables)
- }
-
- pub fn alloc_trait_def(self, def: ty::TraitDef) -> &'gcx ty::TraitDef {
- self.global_arenas.trait_def.alloc(def)
+ pub fn alloc_steal_mir(self, mir: Body<'gcx>) -> &'gcx Steal<Body<'gcx>> {
+ self.arena.alloc(Steal::new(mir))
}
pub fn alloc_adt_def(self,
repr: ReprOptions)
-> &'gcx ty::AdtDef {
let def = ty::AdtDef::new(self, did, kind, variants, repr);
- self.global_arenas.adt_def.alloc(def)
+ self.arena.alloc(def)
}
pub fn intern_const_alloc(self, alloc: Allocation) -> &'gcx Allocation {
self.allocation_interner.borrow_mut().intern(alloc, |alloc| {
- self.global_arenas.const_allocs.alloc(alloc)
+ self.arena.alloc(alloc)
})
}
// create an allocation that just contains these bytes
let alloc = interpret::Allocation::from_byte_aligned_bytes(bytes, ());
let alloc = self.intern_const_alloc(alloc);
- self.alloc_map.lock().allocate(alloc)
+ self.alloc_map.lock().create_memory_alloc(alloc)
}
pub fn intern_stability(self, stab: attr::Stability) -> &'gcx attr::Stability {
self.stability_interner.borrow_mut().intern(stab, |stab| {
- self.global_interners.arena.alloc(stab)
+ self.arena.alloc(stab)
})
}
pub fn intern_layout(self, layout: LayoutDetails) -> &'gcx LayoutDetails {
self.layout_interner.borrow_mut().intern(layout, |layout| {
- self.global_arenas.layout.alloc(layout)
+ self.arena.alloc(layout)
})
}
cstore: &'tcx CrateStoreDyn,
local_providers: ty::query::Providers<'tcx>,
extern_providers: ty::query::Providers<'tcx>,
- arenas: &'tcx AllArenas<'tcx>,
+ arenas: &'tcx AllArenas,
resolutions: ty::Resolutions,
hir: hir_map::Map<'tcx>,
on_disk_query_result_cache: query::OnDiskCache<'tcx>,
s.fatal(&err);
});
let interners = CtxtInterners::new(&arenas.interner);
+ let common = Common {
+ empty_predicates: ty::GenericPredicates {
+ parent: None,
+ predicates: vec![],
+ },
+ };
let common_types = CommonTypes::new(&interners);
let common_lifetimes = CommonLifetimes::new(&interners);
let common_consts = CommonConsts::new(&interners, &common_types);
None
};
- let mut trait_map: FxHashMap<_, Lrc<FxHashMap<_, _>>> = FxHashMap::default();
+ let mut trait_map: FxHashMap<_, FxHashMap<_, _>> = FxHashMap::default();
for (k, v) in resolutions.trait_map {
let hir_id = hir.node_to_hir_id(k);
let map = trait_map.entry(hir_id.owner).or_default();
- Lrc::get_mut(map).unwrap()
- .insert(hir_id.local_id,
- Lrc::new(StableVec::new(v)));
+ map.insert(hir_id.local_id, StableVec::new(v));
}
GlobalCtxt {
sess: s,
cstore,
arena: WorkerLocal::new(|_| Arena::default()),
- global_arenas: &arenas.global,
global_interners: interners,
dep_graph,
+ common,
types: common_types,
lifetimes: common_lifetimes,
consts: common_consts,
let exports: Vec<_> = v.into_iter().map(|e| {
e.map_id(|id| hir.node_to_hir_id(id))
}).collect();
- (k, Lrc::new(exports))
+ (k, exports)
}).collect(),
upvars: resolutions.upvars.into_iter().map(|(k, v)| {
let vars: Vec<_> = v.into_iter().map(|e| {
e.map_id(|id| hir.node_to_hir_id(id))
}).collect();
- (hir.local_def_id(k), Lrc::new(vars))
+ (hir.local_def_id(k), vars)
}).collect(),
maybe_unused_trait_imports:
resolutions.maybe_unused_trait_imports
self.sess.consider_optimizing(&cname, msg)
}
- pub fn lib_features(self) -> Lrc<middle::lib_features::LibFeatures> {
+ pub fn lib_features(self) -> &'gcx middle::lib_features::LibFeatures {
self.get_lib_features(LOCAL_CRATE)
}
- pub fn lang_items(self) -> Lrc<middle::lang_items::LanguageItems> {
+ pub fn lang_items(self) -> &'gcx middle::lang_items::LanguageItems {
self.get_lang_items(LOCAL_CRATE)
}
else { None }
}
- pub fn stability(self) -> Lrc<stability::Index<'tcx>> {
+ pub fn stability(self) -> &'gcx stability::Index<'gcx> {
self.stability_index(LOCAL_CRATE)
}
- pub fn crates(self) -> Lrc<Vec<CrateNum>> {
+ pub fn crates(self) -> &'gcx [CrateNum] {
self.all_crate_nums(LOCAL_CRATE)
}
- pub fn features(self) -> Lrc<feature_gate::Features> {
+ pub fn features(self) -> &'gcx feature_gate::Features {
self.features_query(LOCAL_CRATE)
}
// this is the impl for `&'a InternalSubsts<'a>`
nop_list_lift!{Kind<'a> => Kind<'tcx>}
-impl<'a, 'tcx> Lift<'tcx> for &'a mir::interpret::Allocation {
- type Lifted = &'tcx mir::interpret::Allocation;
- fn lift_to_tcx<'b, 'gcx>(&self, tcx: TyCtxt<'b, 'gcx, 'tcx>) -> Option<Self::Lifted> {
- assert!(tcx.global_arenas.const_allocs.in_arena(*self as *const _));
- Some(unsafe { mem::transmute(*self) })
- }
-}
-
pub mod tls {
use super::{GlobalCtxt, TyCtxt, ptr_eq};
#[inline]
pub fn mk_array(self, ty: Ty<'tcx>, n: u64) -> Ty<'tcx> {
- self.mk_ty(Array(ty, self.mk_const(
- ty::Const::from_usize(self.global_tcx(), n)
- )))
+ self.mk_ty(Array(ty, ty::Const::from_usize(self.global_tcx(), n)))
}
#[inline]
lint::struct_lint_level(self.sess, lint, level, src, None, msg)
}
- pub fn in_scope_traits(self, id: HirId) -> Option<Lrc<StableVec<TraitCandidate>>> {
+ pub fn in_scope_traits(self, id: HirId) -> Option<&'gcx StableVec<TraitCandidate>> {
self.in_scope_traits_map(id.owner)
- .and_then(|map| map.get(&id.local_id).cloned())
+ .and_then(|map| map.get(&id.local_id))
}
pub fn named_region(self, id: HirId) -> Option<resolve_lifetime::Region> {
}
pub fn object_lifetime_defaults(self, id: HirId)
- -> Option<Lrc<Vec<ObjectLifetimeDefault>>>
+ -> Option<&'gcx [ObjectLifetimeDefault]>
{
self.object_lifetime_defaults_map(id.owner)
- .and_then(|map| map.get(&id.local_id).cloned())
+ .and_then(|map| map.get(&id.local_id).map(|v| &**v))
}
}
}
pub fn provide(providers: &mut ty::query::Providers<'_>) {
- providers.in_scope_traits_map = |tcx, id| tcx.gcx.trait_map.get(&id).cloned();
- providers.module_exports = |tcx, id| tcx.gcx.export_map.get(&id).cloned();
+ providers.in_scope_traits_map = |tcx, id| tcx.gcx.trait_map.get(&id);
+ providers.module_exports = |tcx, id| tcx.gcx.export_map.get(&id).map(|v| &v[..]);
providers.crate_name = |tcx, id| {
assert_eq!(id, LOCAL_CRATE);
tcx.crate_name
};
providers.get_lib_features = |tcx, id| {
assert_eq!(id, LOCAL_CRATE);
- Lrc::new(middle::lib_features::collect(tcx))
+ tcx.arena.alloc(middle::lib_features::collect(tcx))
};
providers.get_lang_items = |tcx, id| {
assert_eq!(id, LOCAL_CRATE);
- Lrc::new(middle::lang_items::collect(tcx))
+ tcx.arena.alloc(middle::lang_items::collect(tcx))
};
- providers.upvars = |tcx, id| tcx.gcx.upvars.get(&id).cloned();
+ providers.upvars = |tcx, id| tcx.gcx.upvars.get(&id).map(|v| &v[..]);
providers.maybe_unused_trait_import = |tcx, id| {
tcx.maybe_unused_trait_imports.contains(&id)
};
providers.maybe_unused_extern_crates = |tcx, cnum| {
assert_eq!(cnum, LOCAL_CRATE);
- Lrc::new(tcx.maybe_unused_extern_crates.clone())
+ &tcx.maybe_unused_extern_crates[..]
};
providers.names_imported_by_glob_use = |tcx, id| {
assert_eq!(id.krate, LOCAL_CRATE);
providers.stability_index = |tcx, cnum| {
assert_eq!(cnum, LOCAL_CRATE);
- Lrc::new(stability::Index::new(tcx))
+ tcx.arena.alloc(stability::Index::new(tcx))
};
providers.lookup_stability = |tcx, id| {
assert_eq!(id.krate, LOCAL_CRATE);
};
providers.all_crate_nums = |tcx, cnum| {
assert_eq!(cnum, LOCAL_CRATE);
- Lrc::new(tcx.cstore.crates_untracked())
+ tcx.arena.alloc_slice(&tcx.cstore.crates_untracked())
};
providers.postorder_cnums = |tcx, cnum| {
assert_eq!(cnum, LOCAL_CRATE);
- Lrc::new(tcx.cstore.postorder_cnums_untracked())
+ tcx.arena.alloc_slice(&tcx.cstore.postorder_cnums_untracked())
};
providers.output_filenames = |tcx, cnum| {
assert_eq!(cnum, LOCAL_CRATE);
};
providers.features_query = |tcx, cnum| {
assert_eq!(cnum, LOCAL_CRATE);
- Lrc::new(tcx.sess.features_untracked().clone())
+ tcx.arena.alloc(tcx.sess.features_untracked().clone())
};
providers.is_panic_runtime = |tcx, cnum| {
assert_eq!(cnum, LOCAL_CRATE);