Auto merge of #56382 - Zoxc:arena-drops, r=<try>

Promote types which allocate to an arena to avoid the use of Lrc

Author: bors

src/libarena/lib.rs

@@ -35,16 +35,18 @@
 extern crate alloc;
 extern crate rustc_data_structures;
 
-use rustc_data_structures::sync::MTLock;
+use rustc_data_structures::OnDrop;
+use rustc_data_structures::defer_deallocs::{DeferDeallocs, DeferredDeallocs};
+use rustc_data_structures::sync::{MTLock, WorkerLocal};
 
+use std::process;
 use std::cell::{Cell, RefCell};
 use std::cmp;
 use std::intrinsics;
 use std::marker::{PhantomData, Send};
 use std::mem;
 use std::ptr;
 use std::slice;
-
 use alloc::raw_vec::RawVec;
 
 /// An arena that can hold objects of only one type.
@@ -450,12 +452,20 @@ impl<T> SyncTypedArena<T> {
     }
 }
 
-#[derive(Default)]
 pub struct SyncDroplessArena {
     lock: MTLock<DroplessArena>,
+    deferred: WorkerLocal<RefCell<DeferredDeallocs>>,
 }
 
 impl SyncDroplessArena {
+    #[inline]
+    pub fn new() -> Self {
+        SyncDroplessArena {
+            lock: Default::default(),
+            deferred: WorkerLocal::new(|_| Default::default()),
+        }
+    }
+
     #[inline(always)]
     pub fn in_arena<T: ?Sized>(&self, ptr: *const T) -> bool {
         self.lock.lock().in_arena(ptr)
@@ -481,6 +491,39 @@ impl SyncDroplessArena {
         // Extend the lifetime of the result since it's limited to the lock guard
         unsafe { &mut *(self.lock.lock().alloc_slice(slice) as *mut [T]) }
     }
+
+    #[inline]
+    pub fn promote<T: DeferDeallocs>(&self, object: T) -> &T {
+        let mem = self.alloc_raw(mem::size_of::<T>(), mem::align_of::<T>()) as *mut _ as *mut T;
+
+        {
+            // Abort the process if we panic here to ensure that we don't both
+            // record and allocation and also destroy object, resulting in a double free
+            let abort = OnDrop(|| process::abort());
+
+            // Defer the allocations
+            object.defer(&mut *self.deferred.borrow_mut());
+
+            mem::forget(abort);
+        }
+
+        unsafe {
+            // Write into uninitialized memory.
+            ptr::write(mem, object);
+            &mut *mem
+        }
+    }
+
+    #[inline(always)]
+    pub fn promote_vec<T: DeferDeallocs>(&self, vec: Vec<T>) -> &[T] {
+        // Defer the allocations
+        vec.defer(&mut *self.deferred.borrow_mut());
+
+        // Then just return the slice
+        let result = &vec[..] as *const [T];
+        mem::forget(vec);
+        unsafe { &*result }
+    }
 }
 
 #[cfg(test)]

src/librustc/hir/def_id.rs

@@ -223,6 +223,8 @@ pub struct DefId {
     pub index: DefIndex,
 }
 
+impl_defer_dellocs_for_no_drop_type!([] DefId);
+
 impl fmt::Debug for DefId {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "DefId({}/{}:{}",

src/librustc/hir/mod.rs

@@ -135,6 +135,8 @@ mod item_local_id_inner {
     }
 }
 
+impl_defer_dellocs_for_no_drop_type!([] ItemLocalId);
+
 pub use self::item_local_id_inner::ItemLocalId;
 
 /// The `HirId` corresponding to CRATE_NODE_ID and CRATE_DEF_INDEX
@@ -1269,6 +1271,8 @@ pub struct BodyId {
     pub node_id: NodeId,
 }
 
+impl_defer_dellocs_for_no_drop_type!([] BodyId);
+
 /// The body of a function, closure, or constant value. In the case of
 /// a function, the body contains not only the function body itself
 /// (which is an expression), but also the argument patterns, since

src/librustc/ich/impls_ty.rs

@@ -847,16 +847,12 @@ impl_stable_hash_for!(struct ty::Destructor {
     did
 });
 
-impl_stable_hash_for!(struct ty::CrateVariancesMap {
+impl_stable_hash_for!(struct ty::CrateVariancesMap<'tcx> {
     variances,
-    // This is just an irrelevant helper value.
-    empty_variance -> _,
 });
 
 impl_stable_hash_for!(struct ty::CratePredicatesMap<'tcx> {
     predicates,
-    // This is just an irrelevant helper value.
-    empty_predicate -> _,
 });
 
 impl_stable_hash_for!(struct ty::AssociatedItem {

src/librustc/infer/mod.rs

@@ -478,7 +478,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'gcx> {
     pub fn infer_ctxt(self) -> InferCtxtBuilder<'a, 'gcx, 'tcx> {
         InferCtxtBuilder {
             global_tcx: self,
-            arena: SyncDroplessArena::default(),
+            arena: SyncDroplessArena::new(),
             fresh_tables: None,
         }
     }

src/librustc/middle/expr_use_visitor.rs

@@ -27,7 +27,6 @@ use middle::region;
 use ty::{self, TyCtxt, adjustment};
 
 use hir::{self, PatKind};
-use rustc_data_structures::sync::Lrc;
 use std::rc::Rc;
 use syntax::ast;
 use syntax::ptr::P;
@@ -280,7 +279,7 @@ impl<'a, 'tcx> ExprUseVisitor<'a, 'tcx, 'tcx> {
                param_env: ty::ParamEnv<'tcx>,
                region_scope_tree: &'a region::ScopeTree,
                tables: &'a ty::TypeckTables<'tcx>,
-               rvalue_promotable_map: Option<Lrc<ItemLocalSet>>)
+               rvalue_promotable_map: Option<&'tcx ItemLocalSet>)
                -> Self
     {
         ExprUseVisitor {

src/librustc/middle/mem_categorization.rs

@@ -87,7 +87,6 @@ use syntax_pos::Span;
 use std::borrow::Cow;
 use std::fmt;
 use std::hash::{Hash, Hasher};
-use rustc_data_structures::sync::Lrc;
 use rustc_data_structures::indexed_vec::Idx;
 use std::rc::Rc;
 use util::nodemap::ItemLocalSet;
@@ -300,7 +299,7 @@ pub struct MemCategorizationContext<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
     pub tcx: TyCtxt<'a, 'gcx, 'tcx>,
     pub region_scope_tree: &'a region::ScopeTree,
     pub tables: &'a ty::TypeckTables<'tcx>,
-    rvalue_promotable_map: Option<Lrc<ItemLocalSet>>,
+    rvalue_promotable_map: Option<&'tcx ItemLocalSet>,
     infcx: Option<&'a InferCtxt<'a, 'gcx, 'tcx>>,
 }
 
@@ -410,7 +409,7 @@ impl<'a, 'tcx> MemCategorizationContext<'a, 'tcx, 'tcx> {
     pub fn new(tcx: TyCtxt<'a, 'tcx, 'tcx>,
                region_scope_tree: &'a region::ScopeTree,
                tables: &'a ty::TypeckTables<'tcx>,
-               rvalue_promotable_map: Option<Lrc<ItemLocalSet>>)
+               rvalue_promotable_map: Option<&'tcx ItemLocalSet>)
                -> MemCategorizationContext<'a, 'tcx, 'tcx> {
         MemCategorizationContext {
             tcx,

src/librustc/middle/region.rs

@@ -22,7 +22,6 @@ use ty;
 
 use std::mem;
 use std::fmt;
-use rustc_data_structures::sync::Lrc;
 use syntax::source_map;
 use syntax::ast;
 use syntax_pos::{Span, DUMMY_SP};
@@ -34,6 +33,7 @@ use hir::Node;
 use hir::def_id::DefId;
 use hir::intravisit::{self, Visitor, NestedVisitorMap};
 use hir::{Block, Arm, Pat, PatKind, Stmt, Expr, Local};
+use rustc_data_structures::defer_deallocs::{DeferDeallocs, DeferredDeallocs};
 use rustc_data_structures::indexed_vec::Idx;
 use rustc_data_structures::stable_hasher::{HashStable, StableHasher,
                                            StableHasherResult};
@@ -106,6 +106,8 @@ pub struct Scope {
     pub data: ScopeData,
 }
 
+impl_defer_dellocs_for_no_drop_type!([] Scope);
+
 impl fmt::Debug for Scope {
     fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self.data {
@@ -349,6 +351,18 @@ pub struct ScopeTree {
     body_expr_count: FxHashMap<hir::BodyId, usize>,
 }
 
+unsafe impl DeferDeallocs for ScopeTree {
+    fn defer(&self, deferred: &mut DeferredDeallocs) {
+        self.parent_map.defer(deferred);
+        self.var_map.defer(deferred);
+        self.destruction_scopes.defer(deferred);
+        self.rvalue_scopes.defer(deferred);
+        self.closure_tree.defer(deferred);
+        self.yield_in_scope.defer(deferred);
+        self.body_expr_count.defer(deferred);
+    }
+}
+
 #[derive(Debug, Copy, Clone)]
 pub struct Context {
     /// the root of the current region tree. This is typically the id
@@ -1329,7 +1343,7 @@ impl<'a, 'tcx> Visitor<'tcx> for RegionResolutionVisitor<'a, 'tcx> {
 }
 
 fn region_scope_tree<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId)
-    -> Lrc<ScopeTree>
+    -> &'tcx ScopeTree
 {
     let closure_base_def_id = tcx.closure_base_def_id(def_id);
     if closure_base_def_id != def_id {
@@ -1371,7 +1385,7 @@ fn region_scope_tree<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId)
         ScopeTree::default()
     };
 
-    Lrc::new(scope_tree)
+    tcx.promote(scope_tree)
 }
 
 pub fn provide(providers: &mut Providers<'_>) {

src/librustc/traits/mod.rs

@@ -31,7 +31,6 @@ use ty::fold::{TypeFolder, TypeFoldable, TypeVisitor};
 use infer::{InferCtxt};
 use util::common::ErrorReported;
 
-use rustc_data_structures::sync::Lrc;
 use std::fmt::Debug;
 use std::rc::Rc;
 use syntax::ast;
@@ -959,11 +958,11 @@ fn substitute_normalize_and_test_predicates<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx
 fn vtable_methods<'a, 'tcx>(
     tcx: TyCtxt<'a, 'tcx, 'tcx>,
     trait_ref: ty::PolyTraitRef<'tcx>)
-    -> Lrc<Vec<Option<(DefId, &'tcx Substs<'tcx>)>>>
+    -> &'tcx [Option<(DefId, &'tcx Substs<'tcx>)>]
 {
     debug!("vtable_methods({:?})", trait_ref);
 
-    Lrc::new(
+    tcx.promote_vec(
         supertraits(tcx, trait_ref).flat_map(move |trait_ref| {
             let trait_methods = tcx.associated_items(trait_ref.def_id())
                 .filter(|item| item.kind == ty::AssociatedKind::Method);

src/librustc/ty/context.rs

@@ -54,6 +54,7 @@ use ty::CanonicalPolyFnSig;
 use util::nodemap::{DefIdMap, DefIdSet, ItemLocalMap};
 use util::nodemap::{FxHashMap, FxHashSet};
 use smallvec::SmallVec;
+use rustc_data_structures::defer_deallocs::DeferDeallocs;
 use rustc_data_structures::stable_hasher::{HashStable, hash_stable_hashmap,
                                            StableHasher, StableHasherResult,
                                            StableVec};
@@ -91,7 +92,7 @@ impl<'tcx> AllArenas<'tcx> {
     pub fn new() -> Self {
         AllArenas {
             global: WorkerLocal::new(|_| GlobalArenas::default()),
-            interner: SyncDroplessArena::default(),
+            interner: SyncDroplessArena::new(),
         }
     }
 }
@@ -980,6 +981,16 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
         }
     }
 
+    #[inline(always)]
+    pub fn promote<T: DeferDeallocs>(&self, object: T) -> &'gcx T {
+        self.gcx.global_interners.arena.promote(object)
+    }
+
+    #[inline(always)]
+    pub fn promote_vec<T: DeferDeallocs>(&self, vec: Vec<T>) -> &'gcx [T] {
+        self.gcx.global_interners.arena.promote_vec(vec)
+    }
+
     pub fn alloc_generics(self, generics: ty::Generics) -> &'gcx ty::Generics {
         self.global_arenas.generics.alloc(generics)
     }

src/librustc/ty/mod.rs

@@ -57,6 +57,7 @@ use syntax::symbol::{keywords, Symbol, LocalInternedString, InternedString};
 use syntax_pos::{DUMMY_SP, Span};
 
 use smallvec;
+use rustc_data_structures::defer_deallocs::{DeferredDeallocs, DeferDeallocs};
 use rustc_data_structures::indexed_vec::{Idx, IndexVec};
 use rustc_data_structures::stable_hasher::{StableHasher, StableHasherResult,
                                            HashStable};
@@ -338,20 +339,19 @@ pub enum Variance {
     Bivariant,      // T<A> <: T<B>            -- e.g., unused type parameter
 }
 
+impl_defer_dellocs_for_no_drop_type!([] Variance);
+
 /// The crate variances map is computed during typeck and contains the
 /// variance of every item in the local crate. You should not use it
 /// directly, because to do so will make your pass dependent on the
 /// HIR of every item in the local crate. Instead, use
 /// `tcx.variances_of()` to get the variance for a *particular*
 /// item.
-pub struct CrateVariancesMap {
+pub struct CrateVariancesMap<'tcx> {
     /// For each item with generics, maps to a vector of the variance
     /// of its generics.  If an item has no generics, it will have no
     /// entry.
-    pub variances: FxHashMap<DefId, Lrc<Vec<ty::Variance>>>,
-
-    /// An empty vector, useful for cloning.
-    pub empty_variance: Lrc<Vec<ty::Variance>>,
+    pub variances: FxHashMap<DefId, &'tcx [ty::Variance]>,
 }
 
 impl Variance {
@@ -1087,6 +1087,8 @@ pub enum Predicate<'tcx> {
     ConstEvaluatable(DefId, &'tcx Substs<'tcx>),
 }
 
+impl_defer_dellocs_for_no_drop_type!([<'tcx>] Predicate<'tcx>);
+
 /// The crate outlives map is computed during typeck and contains the
 /// outlives of every item in the local crate. You should not use it
 /// directly, because to do so will make your pass dependent on the
@@ -1097,10 +1099,7 @@ pub struct CratePredicatesMap<'tcx> {
     /// For each struct with outlive bounds, maps to a vector of the
     /// predicate of its outlive bounds. If an item has no outlives
     /// bounds, it will have no entry.
-    pub predicates: FxHashMap<DefId, Lrc<Vec<ty::Predicate<'tcx>>>>,
-
-    /// An empty vector, useful for cloning.
-    pub empty_predicate: Lrc<Vec<ty::Predicate<'tcx>>>,
+    pub predicates: FxHashMap<DefId, &'tcx [ty::Predicate<'tcx>]>,
 }
 
 impl<'tcx> AsRef<Predicate<'tcx>> for Predicate<'tcx> {
@@ -2957,7 +2956,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
 
 pub struct AssociatedItemsIterator<'a, 'gcx: 'tcx, 'tcx: 'a> {
     tcx: TyCtxt<'a, 'gcx, 'tcx>,
-    def_ids: Lrc<Vec<DefId>>,
+    def_ids: &'gcx [DefId],
     next_index: usize,
 }
 
@@ -3043,7 +3042,7 @@ fn adt_sized_constraint<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
 
 fn associated_item_def_ids<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
                                      def_id: DefId)
-                                     -> Lrc<Vec<DefId>> {
+                                     -> &'tcx [DefId] {
     let id = tcx.hir.as_local_node_id(def_id).unwrap();
     let item = tcx.hir.expect_item(id);
     let vec: Vec<_> = match item.node {
@@ -3062,7 +3061,7 @@ fn associated_item_def_ids<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
         hir::ItemKind::TraitAlias(..) => vec![],
         _ => span_bug!(item.span, "associated_item_def_ids: not impl or trait")
     };
-    Lrc::new(vec)
+    tcx.promote_vec(vec)
 }
 
 fn def_span<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) -> Span {
@@ -3204,7 +3203,13 @@ pub fn provide(providers: &mut ty::query::Providers<'_>) {
 /// (constructing this map requires touching the entire crate).
 #[derive(Clone, Debug, Default)]
 pub struct CrateInherentImpls {
-    pub inherent_impls: DefIdMap<Lrc<Vec<DefId>>>,
+    pub inherent_impls: DefIdMap<Vec<DefId>>,
+}
+
+unsafe impl DeferDeallocs for CrateInherentImpls {
+    fn defer(&self, deferred: &mut DeferredDeallocs) {
+        self.inherent_impls.defer(deferred)
+    }
 }
 
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, RustcEncodable, RustcDecodable)]