diff options
| -rw-r--r-- | src/librustc_trans/abi.rs | 2 | ||||
| -rw-r--r-- | src/librustc_trans/base.rs | 4 | ||||
| -rw-r--r-- | src/librustc_trans/callee.rs | 4 | ||||
| -rw-r--r-- | src/librustc_trans/collector.rs | 188 | ||||
| -rw-r--r-- | src/librustc_trans/common.rs | 27 | ||||
| -rw-r--r-- | src/librustc_trans/consts.rs | 4 | ||||
| -rw-r--r-- | src/librustc_trans/context.rs | 8 | ||||
| -rw-r--r-- | src/librustc_trans/debuginfo/metadata.rs | 2 | ||||
| -rw-r--r-- | src/librustc_trans/debuginfo/mod.rs | 2 | ||||
| -rw-r--r-- | src/librustc_trans/glue.rs | 11 | ||||
| -rw-r--r-- | src/librustc_trans/meth.rs | 2 | ||||
| -rw-r--r-- | src/librustc_trans/mir/block.rs | 6 | ||||
| -rw-r--r-- | src/librustc_trans/mir/constant.rs | 2 | ||||
| -rw-r--r-- | src/librustc_trans/mir/rvalue.rs | 2 | ||||
| -rw-r--r-- | src/librustc_trans/monomorphize.rs | 51 | ||||
| -rw-r--r-- | src/librustc_trans/partitioning.rs | 2 | ||||
| -rw-r--r-- | src/librustc_trans/trans_item.rs | 4 |
17 files changed, 166 insertions, 155 deletions
diff --git a/src/librustc_trans/abi.rs b/src/librustc_trans/abi.rs index 4211c8df5ca..8e933d5ac88 100644 --- a/src/librustc_trans/abi.rs +++ b/src/librustc_trans/abi.rs @@ -612,7 +612,7 @@ pub struct FnType<'tcx> { impl<'a, 'tcx> FnType<'tcx> { pub fn of_instance(ccx: &CrateContext<'a, 'tcx>, instance: &ty::Instance<'tcx>) -> Self { - let fn_ty = instance_ty(ccx.shared(), &instance); + let fn_ty = instance_ty(ccx.tcx(), &instance); let sig = ty_fn_sig(ccx, fn_ty); let sig = ccx.tcx().erase_late_bound_regions_and_normalize(&sig); Self::new(ccx, sig, &[]) diff --git a/src/librustc_trans/base.rs b/src/librustc_trans/base.rs index 026417682cc..216c05b4b0a 100644 --- a/src/librustc_trans/base.rs +++ b/src/librustc_trans/base.rs @@ -578,7 +578,7 @@ pub fn trans_instance<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, instance: Instance // release builds. info!("trans_instance({})", instance); - let fn_ty = common::instance_ty(ccx.shared(), &instance); + let fn_ty = common::instance_ty(ccx.tcx(), &instance); let sig = common::ty_fn_sig(ccx, fn_ty); let sig = ccx.tcx().erase_late_bound_regions_and_normalize(&sig); @@ -1424,7 +1424,7 @@ fn collect_and_partition_translation_items<'a, 'tcx>(scx: &SharedCrateContext<'a let (items, inlining_map) = time(time_passes, "translation item collection", || { - collector::collect_crate_translation_items(&scx, + collector::collect_crate_translation_items(scx.tcx(), exported_symbols, collection_mode) }); diff --git a/src/librustc_trans/callee.rs b/src/librustc_trans/callee.rs index 246eb49ffa6..ffdd76dd687 100644 --- a/src/librustc_trans/callee.rs +++ b/src/librustc_trans/callee.rs @@ -45,7 +45,7 @@ pub fn get_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, assert!(!instance.substs.has_escaping_regions()); assert!(!instance.substs.has_param_types()); - let fn_ty = common::instance_ty(ccx.shared(), &instance); + let fn_ty = common::instance_ty(ccx.tcx(), &instance); if let Some(&llfn) = ccx.instances().borrow().get(&instance) { return llfn; } @@ -148,5 +148,5 @@ pub fn resolve_and_get_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, substs: &'tcx Substs<'tcx>) -> ValueRef { - get_fn(ccx, monomorphize::resolve(ccx.shared(), def_id, substs)) + get_fn(ccx, monomorphize::resolve(ccx.tcx(), def_id, substs)) } diff --git a/src/librustc_trans/collector.rs b/src/librustc_trans/collector.rs index f0d8c7e9bfb..bda035fc343 100644 --- a/src/librustc_trans/collector.rs +++ b/src/librustc_trans/collector.rs @@ -202,8 +202,7 @@ use rustc::ty::adjustment::CustomCoerceUnsized; use rustc::mir::{self, Location}; use rustc::mir::visit::Visitor as MirVisitor; -use context::SharedCrateContext; -use common::{def_ty, instance_ty}; +use common::{def_ty, instance_ty, type_is_sized}; use monomorphize::{self, Instance}; use rustc::util::nodemap::{FxHashSet, FxHashMap, DefIdMap}; @@ -294,15 +293,15 @@ impl<'tcx> InliningMap<'tcx> { } } -pub fn collect_crate_translation_items<'a, 'tcx>(scx: &SharedCrateContext<'a, 'tcx>, +pub fn collect_crate_translation_items<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, exported_symbols: &ExportedSymbols, mode: TransItemCollectionMode) -> (FxHashSet<TransItem<'tcx>>, InliningMap<'tcx>) { // We are not tracking dependencies of this pass as it has to be re-executed // every time no matter what. - scx.tcx().dep_graph.with_ignore(|| { - let roots = collect_roots(scx, exported_symbols, mode); + tcx.dep_graph.with_ignore(|| { + let roots = collect_roots(tcx, exported_symbols, mode); debug!("Building translation item graph, beginning at roots"); let mut visited = FxHashSet(); @@ -310,7 +309,7 @@ pub fn collect_crate_translation_items<'a, 'tcx>(scx: &SharedCrateContext<'a, 't let mut inlining_map = InliningMap::new(); for root in roots { - collect_items_rec(scx, + collect_items_rec(tcx, root, &mut visited, &mut recursion_depths, @@ -323,7 +322,7 @@ pub fn collect_crate_translation_items<'a, 'tcx>(scx: &SharedCrateContext<'a, 't // Find all non-generic items by walking the HIR. These items serve as roots to // start monomorphizing from. -fn collect_roots<'a, 'tcx>(scx: &SharedCrateContext<'a, 'tcx>, +fn collect_roots<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, exported_symbols: &ExportedSymbols, mode: TransItemCollectionMode) -> Vec<TransItem<'tcx>> { @@ -332,25 +331,25 @@ fn collect_roots<'a, 'tcx>(scx: &SharedCrateContext<'a, 'tcx>, { let mut visitor = RootCollector { - scx, + tcx, mode, exported_symbols, output: &mut roots, }; - scx.tcx().hir.krate().visit_all_item_likes(&mut visitor); + tcx.hir.krate().visit_all_item_likes(&mut visitor); } // We can only translate items that are instantiable - items all of // whose predicates hold. Luckily, items that aren't instantiable // can't actually be used, so we can just skip translating them. - roots.retain(|root| root.is_instantiable(scx.tcx())); + roots.retain(|root| root.is_instantiable(tcx)); roots } // Collect all monomorphized translation items reachable from `starting_point` -fn collect_items_rec<'a, 'tcx: 'a>(scx: &SharedCrateContext<'a, 'tcx>, +fn collect_items_rec<'a, 'tcx: 'a>(tcx: TyCtxt<'a, 'tcx, 'tcx>, starting_point: TransItem<'tcx>, visited: &mut FxHashSet<TransItem<'tcx>>, recursion_depths: &mut DefIdMap<usize>, @@ -359,54 +358,54 @@ fn collect_items_rec<'a, 'tcx: 'a>(scx: &SharedCrateContext<'a, 'tcx>, // We've been here already, no need to search again. return; } - debug!("BEGIN collect_items_rec({})", starting_point.to_string(scx.tcx())); + debug!("BEGIN collect_items_rec({})", starting_point.to_string(tcx)); let mut neighbors = Vec::new(); let recursion_depth_reset; match starting_point { TransItem::Static(node_id) => { - let def_id = scx.tcx().hir.local_def_id(node_id); - let instance = Instance::mono(scx.tcx(), def_id); + let def_id = tcx.hir.local_def_id(node_id); + let instance = Instance::mono(tcx, def_id); // Sanity check whether this ended up being collected accidentally - debug_assert!(should_trans_locally(scx.tcx(), &instance)); + debug_assert!(should_trans_locally(tcx, &instance)); - let ty = instance_ty(scx, &instance); - visit_drop_use(scx, ty, true, &mut neighbors); + let ty = instance_ty(tcx, &instance); + visit_drop_use(tcx, ty, true, &mut neighbors); recursion_depth_reset = None; - collect_neighbours(scx, instance, true, &mut neighbors); + collect_neighbours(tcx, instance, true, &mut neighbors); } TransItem::Fn(instance) => { // Sanity check whether this ended up being collected accidentally - debug_assert!(should_trans_locally(scx.tcx(), &instance)); + debug_assert!(should_trans_locally(tcx, &instance)); // Keep track of the monomorphization recursion depth - recursion_depth_reset = Some(check_recursion_limit(scx.tcx(), + recursion_depth_reset = Some(check_recursion_limit(tcx, instance, recursion_depths)); - check_type_length_limit(scx.tcx(), instance); + check_type_length_limit(tcx, instance); - collect_neighbours(scx, instance, false, &mut neighbors); + collect_neighbours(tcx, instance, false, &mut neighbors); } TransItem::GlobalAsm(..) => { recursion_depth_reset = None; } } - record_accesses(scx.tcx(), starting_point, &neighbors[..], inlining_map); + record_accesses(tcx, starting_point, &neighbors[..], inlining_map); for neighbour in neighbors { - collect_items_rec(scx, neighbour, visited, recursion_depths, inlining_map); + collect_items_rec(tcx, neighbour, visited, recursion_depths, inlining_map); } if let Some((def_id, depth)) = recursion_depth_reset { recursion_depths.insert(def_id, depth); } - debug!("END collect_items_rec({})", starting_point.to_string(scx.tcx())); + debug!("END collect_items_rec({})", starting_point.to_string(tcx)); } fn record_accesses<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, @@ -494,7 +493,7 @@ fn check_type_length_limit<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, } struct MirNeighborCollector<'a, 'tcx: 'a> { - scx: &'a SharedCrateContext<'a, 'tcx>, + tcx: TyCtxt<'a, 'tcx, 'tcx>, mir: &'a mir::Mir<'tcx>, output: &'a mut Vec<TransItem<'tcx>>, param_substs: &'tcx Substs<'tcx>, @@ -511,49 +510,49 @@ impl<'a, 'tcx> MirVisitor<'tcx> for MirNeighborCollector<'a, 'tcx> { // have to instantiate all methods of the trait being cast to, so we // can build the appropriate vtable. mir::Rvalue::Cast(mir::CastKind::Unsize, ref operand, target_ty) => { - let target_ty = self.scx.tcx().trans_apply_param_substs(self.param_substs, - &target_ty); - let source_ty = operand.ty(self.mir, self.scx.tcx()); - let source_ty = self.scx.tcx().trans_apply_param_substs(self.param_substs, - &source_ty); - let (source_ty, target_ty) = find_vtable_types_for_unsizing(self.scx, + let target_ty = self.tcx.trans_apply_param_substs(self.param_substs, + &target_ty); + let source_ty = operand.ty(self.mir, self.tcx); + let source_ty = self.tcx.trans_apply_param_substs(self.param_substs, + &source_ty); + let (source_ty, target_ty) = find_vtable_types_for_unsizing(self.tcx, source_ty, target_ty); // This could also be a different Unsize instruction, like // from a fixed sized array to a slice. But we are only // interested in things that produce a vtable. if target_ty.is_trait() && !source_ty.is_trait() { - create_trans_items_for_vtable_methods(self.scx, + create_trans_items_for_vtable_methods(self.tcx, target_ty, source_ty, self.output); } } mir::Rvalue::Cast(mir::CastKind::ReifyFnPointer, ref operand, _) => { - let fn_ty = operand.ty(self.mir, self.scx.tcx()); - let fn_ty = self.scx.tcx().trans_apply_param_substs(self.param_substs, - &fn_ty); - visit_fn_use(self.scx, fn_ty, false, &mut self.output); + let fn_ty = operand.ty(self.mir, self.tcx); + let fn_ty = self.tcx.trans_apply_param_substs(self.param_substs, + &fn_ty); + visit_fn_use(self.tcx, fn_ty, false, &mut self.output); } mir::Rvalue::Cast(mir::CastKind::ClosureFnPointer, ref operand, _) => { - let source_ty = operand.ty(self.mir, self.scx.tcx()); - let source_ty = self.scx.tcx().trans_apply_param_substs(self.param_substs, - &source_ty); + let source_ty = operand.ty(self.mir, self.tcx); + let source_ty = self.tcx.trans_apply_param_substs(self.param_substs, + &source_ty); match source_ty.sty { ty::TyClosure(def_id, substs) => { let instance = monomorphize::resolve_closure( - self.scx, def_id, substs, ty::ClosureKind::FnOnce); + self.tcx, def_id, substs, ty::ClosureKind::FnOnce); self.output.push(create_fn_trans_item(instance)); } _ => bug!(), } } mir::Rvalue::NullaryOp(mir::NullOp::Box, _) => { - let tcx = self.scx.tcx(); + let tcx = self.tcx; let exchange_malloc_fn_def_id = tcx .lang_items() .require(ExchangeMallocFnLangItem) - .unwrap_or_else(|e| self.scx.sess().fatal(&e)); + .unwrap_or_else(|e| tcx.sess.fatal(&e)); let instance = Instance::mono(tcx, exchange_malloc_fn_def_id); if should_trans_locally(tcx, &instance) { self.output.push(create_fn_trans_item(instance)); @@ -569,10 +568,10 @@ impl<'a, 'tcx> MirVisitor<'tcx> for MirNeighborCollector<'a, 'tcx> { debug!("visiting const {:?} @ {:?}", *constant, location); if let ConstVal::Unevaluated(def_id, substs) = constant.val { - let substs = self.scx.tcx().trans_apply_param_substs(self.param_substs, - &substs); - let instance = monomorphize::resolve(self.scx, def_id, substs); - collect_neighbours(self.scx, instance, true, self.output); + let substs = self.tcx.trans_apply_param_substs(self.param_substs, + &substs); + let instance = monomorphize::resolve(self.tcx, def_id, substs); + collect_neighbours(self.tcx, instance, true, self.output); } self.super_const(constant); @@ -584,15 +583,15 @@ impl<'a, 'tcx> MirVisitor<'tcx> for MirNeighborCollector<'a, 'tcx> { location: Location) { debug!("visiting terminator {:?} @ {:?}", kind, location); - let tcx = self.scx.tcx(); + let tcx = self.tcx; match *kind { mir::TerminatorKind::Call { ref func, .. } => { let callee_ty = func.ty(self.mir, tcx); let callee_ty = tcx.trans_apply_param_substs(self.param_substs, &callee_ty); let constness = match (self.const_context, &callee_ty.sty) { - (true, &ty::TyFnDef(def_id, substs)) if self.scx.tcx().is_const_fn(def_id) => { - let instance = monomorphize::resolve(self.scx, def_id, substs); + (true, &ty::TyFnDef(def_id, substs)) if self.tcx.is_const_fn(def_id) => { + let instance = monomorphize::resolve(self.tcx, def_id, substs); Some(instance) } _ => None @@ -602,20 +601,20 @@ impl<'a, 'tcx> MirVisitor<'tcx> for MirNeighborCollector<'a, 'tcx> { // If this is a const fn, called from a const context, we // have to visit its body in order to find any fn reifications // it might contain. - collect_neighbours(self.scx, + collect_neighbours(self.tcx, const_fn_instance, true, self.output); } else { - visit_fn_use(self.scx, callee_ty, true, &mut self.output); + visit_fn_use(self.tcx, callee_ty, true, &mut self.output); } } mir::TerminatorKind::Drop { ref location, .. } | mir::TerminatorKind::DropAndReplace { ref location, .. } => { - let ty = location.ty(self.mir, self.scx.tcx()) - .to_ty(self.scx.tcx()); + let ty = location.ty(self.mir, self.tcx) + .to_ty(self.tcx); let ty = tcx.trans_apply_param_substs(self.param_substs, &ty); - visit_drop_use(self.scx, ty, true, self.output); + visit_drop_use(self.tcx, ty, true, self.output); } mir::TerminatorKind::Goto { .. } | mir::TerminatorKind::SwitchInt { .. } | @@ -636,7 +635,7 @@ impl<'a, 'tcx> MirVisitor<'tcx> for MirNeighborCollector<'a, 'tcx> { location: Location) { debug!("visiting static {:?} @ {:?}", static_.def_id, location); - let tcx = self.scx.tcx(); + let tcx = self.tcx; let instance = Instance::mono(tcx, static_.def_id); if should_trans_locally(tcx, &instance) { let node_id = tcx.hir.as_local_node_id(static_.def_id).unwrap(); @@ -647,33 +646,33 @@ impl<'a, 'tcx> MirVisitor<'tcx> for MirNeighborCollector<'a, 'tcx> { } } -fn visit_drop_use<'a, 'tcx>(scx: &SharedCrateContext<'a, 'tcx>, +fn visit_drop_use<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, ty: Ty<'tcx>, is_direct_call: bool, output: &mut Vec<TransItem<'tcx>>) { - let instance = monomorphize::resolve_drop_in_place(scx, ty); - visit_instance_use(scx, instance, is_direct_call, output); + let instance = monomorphize::resolve_drop_in_place(tcx, ty); + visit_instance_use(tcx, instance, is_direct_call, output); } -fn visit_fn_use<'a, 'tcx>(scx: &SharedCrateContext<'a, 'tcx>, +fn visit_fn_use<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, ty: Ty<'tcx>, is_direct_call: bool, output: &mut Vec<TransItem<'tcx>>) { if let ty::TyFnDef(def_id, substs) = ty.sty { - let instance = monomorphize::resolve(scx, def_id, substs); - visit_instance_use(scx, instance, is_direct_call, output); + let instance = monomorphize::resolve(tcx, def_id, substs); + visit_instance_use(tcx, instance, is_direct_call, output); } } -fn visit_instance_use<'a, 'tcx>(scx: &SharedCrateContext<'a, 'tcx>, +fn visit_instance_use<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, instance: ty::Instance<'tcx>, is_direct_call: bool, output: &mut Vec<TransItem<'tcx>>) { debug!("visit_item_use({:?}, is_direct_call={:?})", instance, is_direct_call); - if !should_trans_locally(scx.tcx(), &instance) { + if !should_trans_locally(tcx, &instance) { return } @@ -775,15 +774,15 @@ fn should_trans_locally<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, instance: &Instan /// /// Finally, there is also the case of custom unsizing coercions, e.g. for /// smart pointers such as `Rc` and `Arc`. -fn find_vtable_types_for_unsizing<'a, 'tcx>(scx: &SharedCrateContext<'a, 'tcx>, +fn find_vtable_types_for_unsizing<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, source_ty: Ty<'tcx>, target_ty: Ty<'tcx>) -> (Ty<'tcx>, Ty<'tcx>) { let ptr_vtable = |inner_source: Ty<'tcx>, inner_target: Ty<'tcx>| { - if !scx.type_is_sized(inner_source) { + if !type_is_sized(tcx, inner_source) { (inner_source, inner_target) } else { - scx.tcx().struct_lockstep_tails(inner_source, inner_target) + tcx.struct_lockstep_tails(inner_source, inner_target) } }; match (&source_ty.sty, &target_ty.sty) { @@ -804,7 +803,7 @@ fn find_vtable_types_for_unsizing<'a, 'tcx>(scx: &SharedCrateContext<'a, 'tcx>, assert_eq!(source_adt_def, target_adt_def); let kind = - monomorphize::custom_coerce_unsize_info(scx, source_ty, target_ty); + monomorphize::custom_coerce_unsize_info(tcx, source_ty, target_ty); let coerce_index = match kind { CustomCoerceUnsized::Struct(i) => i @@ -816,10 +815,10 @@ fn find_vtable_types_for_unsizing<'a, 'tcx>(scx: &SharedCrateContext<'a, 'tcx>, assert!(coerce_index < source_fields.len() && source_fields.len() == target_fields.len()); - find_vtable_types_for_unsizing(scx, - source_fields[coerce_index].ty(scx.tcx(), + find_vtable_types_for_unsizing(tcx, + source_fields[coerce_index].ty(tcx, source_substs), - target_fields[coerce_index].ty(scx.tcx(), + target_fields[coerce_index].ty(tcx, target_substs)) } _ => bug!("find_vtable_types_for_unsizing: invalid coercion {:?} -> {:?}", @@ -835,7 +834,7 @@ fn create_fn_trans_item<'a, 'tcx>(instance: Instance<'tcx>) -> TransItem<'tcx> { /// Creates a `TransItem` for each method that is referenced by the vtable for /// the given trait/impl pair. -fn create_trans_items_for_vtable_methods<'a, 'tcx>(scx: &SharedCrateContext<'a, 'tcx>, +fn create_trans_items_for_vtable_methods<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, trait_ty: Ty<'tcx>, impl_ty: Ty<'tcx>, output: &mut Vec<TransItem<'tcx>>) { @@ -844,19 +843,19 @@ fn create_trans_items_for_vtable_methods<'a, 'tcx>(scx: &SharedCrateContext<'a, if let ty::TyDynamic(ref trait_ty, ..) = trait_ty.sty { if let Some(principal) = trait_ty.principal() { - let poly_trait_ref = principal.with_self_ty(scx.tcx(), impl_ty); + let poly_trait_ref = principal.with_self_ty(tcx, impl_ty); assert!(!poly_trait_ref.has_escaping_regions()); // Walk all methods of the trait, including those of its supertraits - let methods = traits::get_vtable_methods(scx.tcx(), poly_trait_ref); + let methods = traits::get_vtable_methods(tcx, poly_trait_ref); let methods = methods.filter_map(|method| method) - .map(|(def_id, substs)| monomorphize::resolve(scx, def_id, substs)) - .filter(|&instance| should_trans_locally(scx.tcx(), &instance)) + .map(|(def_id, substs)| monomorphize::resolve(tcx, def_id, substs)) + .filter(|&instance| should_trans_locally(tcx, &instance)) .map(|instance| create_fn_trans_item(instance)); output.extend(methods); } // Also add the destructor - visit_drop_use(scx, impl_ty, false, output); + visit_drop_use(tcx, impl_ty, false, output); } } @@ -865,7 +864,7 @@ fn create_trans_items_for_vtable_methods<'a, 'tcx>(scx: &SharedCrateContext<'a, //=----------------------------------------------------------------------------- struct RootCollector<'b, 'a: 'b, 'tcx: 'a + 'b> { - scx: &'b SharedCrateContext<'a, 'tcx>, + tcx: TyCtxt<'a, 'tcx, 'tcx>, exported_symbols: &'b ExportedSymbols, mode: TransItemCollectionMode, output: &'b mut Vec<TransItem<'tcx>>, @@ -886,7 +885,7 @@ impl<'b, 'a, 'v> ItemLikeVisitor<'v> for RootCollector<'b, 'a, 'v> { hir::ItemImpl(..) => { if self.mode == TransItemCollectionMode::Eager { - create_trans_items_for_default_impls(self.scx, + create_trans_items_for_default_impls(self.tcx, item, self.output); } @@ -897,25 +896,25 @@ impl<'b, 'a, 'v> ItemLikeVisitor<'v> for RootCollector<'b, 'a, 'v> { hir::ItemUnion(_, ref generics) => { if !generics.is_parameterized() { if self.mode == TransItemCollectionMode::Eager { - let def_id = self.scx.tcx().hir.local_def_id(item.id); + let def_id = self.tcx.hir.local_def_id(item.id); debug!("RootCollector: ADT drop-glue for {}", - def_id_to_string(self.scx.tcx(), def_id)); + def_id_to_string(self.tcx, def_id)); - let ty = def_ty(self.scx, def_id, Substs::empty()); - visit_drop_use(self.scx, ty, true, self.output); + let ty = def_ty(self.tcx, def_id, Substs::empty()); + visit_drop_use(self.tcx, ty, true, self.output); } } } hir::ItemGlobalAsm(..) => { debug!("RootCollector: ItemGlobalAsm({})", - def_id_to_string(self.scx.tcx(), - self.scx.tcx().hir.local_def_id(item.id))); + def_id_to_string(self.tcx, + self.tcx.hir.local_def_id(item.id))); self.output.push(TransItem::GlobalAsm(item.id)); } hir::ItemStatic(..) => { debug!("RootCollector: ItemStatic({})", - def_id_to_string(self.scx.tcx(), - self.scx.tcx().hir.local_def_id(item.id))); + def_id_to_string(self.tcx, + self.tcx.hir.local_def_id(item.id))); self.output.push(TransItem::Static(item.id)); } hir::ItemConst(..) => { @@ -923,7 +922,7 @@ impl<'b, 'a, 'v> ItemLikeVisitor<'v> for RootCollector<'b, 'a, 'v> { // actually used somewhere. Just declaring them is insufficient. } hir::ItemFn(..) => { - let tcx = self.scx.tcx(); + let tcx = self.tcx; let def_id = tcx.hir.local_def_id(item.id); if (self.mode == TransItemCollectionMode::Eager || @@ -949,7 +948,7 @@ impl<'b, 'a, 'v> ItemLikeVisitor<'v> for RootCollector<'b, 'a, 'v> { fn visit_impl_item(&mut self, ii: &'v hir::ImplItem) { match ii.node { hir::ImplItemKind::Method(hir::MethodSig { .. }, _) => { - let tcx = self.scx.tcx(); + let tcx = self.tcx; let def_id = tcx.hir.local_def_id(ii.id); if (self.mode == TransItemCollectionMode::Eager || @@ -973,10 +972,9 @@ fn item_has_type_parameters<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId generics.parent_types as usize + generics.types.len() > 0 } -fn create_trans_items_for_default_impls<'a, 'tcx>(scx: &SharedCrateContext<'a, 'tcx>, +fn create_trans_items_for_default_impls<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, item: &'tcx hir::Item, output: &mut Vec<TransItem<'tcx>>) { - let tcx = scx.tcx(); match item.node { hir::ItemImpl(_, _, @@ -1009,7 +1007,7 @@ fn create_trans_items_for_default_impls<'a, 'tcx>(scx: &SharedCrateContext<'a, ' } let instance = - monomorphize::resolve(scx, method.def_id, callee_substs); + monomorphize::resolve(tcx, method.def_id, callee_substs); let trans_item = create_fn_trans_item(instance); if trans_item.is_instantiable(tcx) && should_trans_locally(tcx, &instance) { @@ -1025,15 +1023,15 @@ fn create_trans_items_for_default_impls<'a, 'tcx>(scx: &SharedCrateContext<'a, ' } /// Scan the MIR in order to find function calls, closures, and drop-glue -fn collect_neighbours<'a, 'tcx>(scx: &SharedCrateContext<'a, 'tcx>, +fn collect_neighbours<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, instance: Instance<'tcx>, const_context: bool, output: &mut Vec<TransItem<'tcx>>) { - let mir = scx.tcx().instance_mir(instance.def); + let mir = tcx.instance_mir(instance.def); let mut visitor = MirNeighborCollector { - scx, + tcx, mir: &mir, output, param_substs: instance.substs, diff --git a/src/librustc_trans/common.rs b/src/librustc_trans/common.rs index 67c95b92e52..52607904f73 100644 --- a/src/librustc_trans/common.rs +++ b/src/librustc_trans/common.rs @@ -26,6 +26,7 @@ use machine; use monomorphize; use type_::Type; use value::Value; +use rustc::traits; use rustc::ty::{self, Ty, TyCtxt}; use rustc::ty::layout::{Layout, LayoutTyper}; use rustc::ty::subst::{Kind, Subst, Substs}; @@ -37,7 +38,7 @@ use std::iter; use syntax::abi::Abi; use syntax::attr; use syntax::symbol::InternedString; -use syntax_pos::Span; +use syntax_pos::{Span, DUMMY_SP}; pub use context::{CrateContext, SharedCrateContext}; @@ -140,6 +141,18 @@ pub fn type_is_zero_size<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, ty: Ty<'tcx>) - !layout.is_unsized() && layout.size(ccx).bytes() == 0 } +pub fn type_needs_drop<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, ty: Ty<'tcx>) -> bool { + ty.needs_drop(tcx, ty::ParamEnv::empty(traits::Reveal::All)) +} + +pub fn type_is_sized<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, ty: Ty<'tcx>) -> bool { + ty.is_sized(tcx, ty::ParamEnv::empty(traits::Reveal::All), DUMMY_SP) +} + +pub fn type_is_freeze<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, ty: Ty<'tcx>) -> bool { + ty.is_freeze(tcx, ty::ParamEnv::empty(traits::Reveal::All), DUMMY_SP) +} + /* * A note on nomenclature of linking: "extern", "foreign", and "upcall". * @@ -573,20 +586,20 @@ pub fn is_inline_instance<'a, 'tcx>( } /// Given a DefId and some Substs, produces the monomorphic item type. -pub fn def_ty<'a, 'tcx>(shared: &SharedCrateContext<'a, 'tcx>, +pub fn def_ty<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId, substs: &'tcx Substs<'tcx>) -> Ty<'tcx> { - let ty = shared.tcx().type_of(def_id); - shared.tcx().trans_apply_param_substs(substs, &ty) + let ty = tcx.type_of(def_id); + tcx.trans_apply_param_substs(substs, &ty) } /// Return the substituted type of an instance. -pub fn instance_ty<'a, 'tcx>(shared: &SharedCrateContext<'a, 'tcx>, +pub fn instance_ty<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, instance: &ty::Instance<'tcx>) -> Ty<'tcx> { - let ty = instance.def.def_ty(shared.tcx()); - shared.tcx().trans_apply_param_substs(instance.substs, &ty) + let ty = instance.def.def_ty(tcx); + tcx.trans_apply_param_substs(instance.substs, &ty) } diff --git a/src/librustc_trans/consts.rs b/src/librustc_trans/consts.rs index bad8a8655d0..a566cddde56 100644 --- a/src/librustc_trans/consts.rs +++ b/src/librustc_trans/consts.rs @@ -109,7 +109,7 @@ pub fn get_static(ccx: &CrateContext, def_id: DefId) -> ValueRef { return g; } - let ty = common::instance_ty(ccx.shared(), &instance); + let ty = common::instance_ty(ccx.tcx(), &instance); let g = if let Some(id) = ccx.tcx().hir.as_local_node_id(def_id) { let llty = type_of::type_of(ccx, ty); @@ -269,7 +269,7 @@ pub fn trans_static<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, }; let instance = Instance::mono(ccx.tcx(), def_id); - let ty = common::instance_ty(ccx.shared(), &instance); + let ty = common::instance_ty(ccx.tcx(), &instance); let llty = type_of::type_of(ccx, ty); let g = if val_llty == llty { g diff --git a/src/librustc_trans/context.rs b/src/librustc_trans/context.rs index 4211be362ef..3ad96d482f1 100644 --- a/src/librustc_trans/context.rs +++ b/src/librustc_trans/context.rs @@ -8,6 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use common; use llvm; use llvm::{ContextRef, ModuleRef, ValueRef}; use rustc::dep_graph::{DepGraph, DepGraphSafe}; @@ -39,7 +40,6 @@ use std::str; use std::sync::Arc; use std::marker::PhantomData; use syntax::symbol::InternedString; -use syntax_pos::DUMMY_SP; use abi::Abi; #[derive(Clone, Default)] @@ -319,15 +319,15 @@ impl<'b, 'tcx> SharedCrateContext<'b, 'tcx> { } pub fn type_needs_drop(&self, ty: Ty<'tcx>) -> bool { - ty.needs_drop(self.tcx, ty::ParamEnv::empty(traits::Reveal::All)) + common::type_needs_drop(self.tcx, ty) } pub fn type_is_sized(&self, ty: Ty<'tcx>) -> bool { - ty.is_sized(self.tcx, ty::ParamEnv::empty(traits::Reveal::All), DUMMY_SP) + common::type_is_sized(self.tcx, ty) } pub fn type_is_freeze(&self, ty: Ty<'tcx>) -> bool { - ty.is_freeze(self.tcx, ty::ParamEnv::empty(traits::Reveal::All), DUMMY_SP) + common::type_is_freeze(self.tcx, ty) } pub fn tcx<'a>(&'a self) -> TyCtxt<'a, 'tcx, 'tcx> { diff --git a/src/librustc_trans/debuginfo/metadata.rs b/src/librustc_trans/debuginfo/metadata.rs index 3c87bc293b5..333f7b1c029 100644 --- a/src/librustc_trans/debuginfo/metadata.rs +++ b/src/librustc_trans/debuginfo/metadata.rs @@ -1803,7 +1803,7 @@ pub fn create_global_var_metadata(cx: &CrateContext, }; let is_local_to_unit = is_node_local_to_unit(cx, node_id); - let variable_type = common::def_ty(cx.shared(), node_def_id, Substs::empty()); + let variable_type = common::def_ty(cx.tcx(), node_def_id, Substs::empty()); let type_metadata = type_metadata(cx, variable_type, span); let var_name = tcx.item_name(node_def_id).to_string(); let linkage_name = mangled_name_of_item(cx, node_def_id, ""); diff --git a/src/librustc_trans/debuginfo/mod.rs b/src/librustc_trans/debuginfo/mod.rs index 83366c13453..7e2ac95cd84 100644 --- a/src/librustc_trans/debuginfo/mod.rs +++ b/src/librustc_trans/debuginfo/mod.rs @@ -428,7 +428,7 @@ pub fn create_function_debug_context<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, // If the method does *not* belong to a trait, proceed if cx.tcx().trait_id_of_impl(impl_def_id).is_none() { let impl_self_ty = - common::def_ty(cx.shared(), impl_def_id, instance.substs); + common::def_ty(cx.tcx(), impl_def_id, instance.substs); // Only "class" methods are generally understood by LLVM, // so avoid methods on other types (e.g. `<*mut T>::null`). diff --git a/src/librustc_trans/glue.rs b/src/librustc_trans/glue.rs index 39394979713..1572f1dc230 100644 --- a/src/librustc_trans/glue.rs +++ b/src/librustc_trans/glue.rs @@ -14,15 +14,16 @@ use std; -use llvm; -use llvm::{ValueRef}; -use rustc::ty::{self, Ty}; -use rustc::ty::layout::LayoutTyper; +use builder::Builder; use common::*; +use llvm::{ValueRef}; +use llvm; use meth; use monomorphize; +use rustc::traits; +use rustc::ty::layout::LayoutTyper; +use rustc::ty::{self, Ty, TypeFoldable, TyCtxt}; use value::Value; -use builder::Builder; pub fn size_and_align_of_dst<'a, 'tcx>(bcx: &Builder<'a, 'tcx>, t: Ty<'tcx>, info: ValueRef) -> (ValueRef, ValueRef) { diff --git a/src/librustc_trans/meth.rs b/src/librustc_trans/meth.rs index 9abfbb3279c..88407947f0e 100644 --- a/src/librustc_trans/meth.rs +++ b/src/librustc_trans/meth.rs @@ -80,7 +80,7 @@ pub fn get_vtable<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, let nullptr = C_null(Type::nil(ccx).ptr_to()); let mut components: Vec<_> = [ - callee::get_fn(ccx, monomorphize::resolve_drop_in_place(ccx.shared(), ty)), + callee::get_fn(ccx, monomorphize::resolve_drop_in_place(ccx.tcx(), ty)), C_usize(ccx, ccx.size_of(ty)), C_usize(ccx, ccx.align_of(ty) as u64) ].iter().cloned().collect(); diff --git a/src/librustc_trans/mir/block.rs b/src/librustc_trans/mir/block.rs index 1105da43618..9246822b339 100644 --- a/src/librustc_trans/mir/block.rs +++ b/src/librustc_trans/mir/block.rs @@ -265,7 +265,7 @@ impl<'a, 'tcx> MirContext<'a, 'tcx> { mir::TerminatorKind::Drop { ref location, target, unwind } => { let ty = location.ty(self.mir, bcx.tcx()).to_ty(bcx.tcx()); let ty = self.monomorphize(&ty); - let drop_fn = monomorphize::resolve_drop_in_place(bcx.ccx.shared(), ty); + let drop_fn = monomorphize::resolve_drop_in_place(bcx.ccx.tcx(), ty); if let ty::InstanceDef::DropGlue(_, None) = drop_fn.def { // we don't actually need to drop anything. @@ -429,7 +429,7 @@ impl<'a, 'tcx> MirContext<'a, 'tcx> { let (instance, mut llfn) = match callee.ty.sty { ty::TyFnDef(def_id, substs) => { - (Some(monomorphize::resolve(bcx.ccx.shared(), def_id, substs)), + (Some(monomorphize::resolve(bcx.ccx.tcx(), def_id, substs)), None) } ty::TyFnPtr(_) => { @@ -546,7 +546,7 @@ impl<'a, 'tcx> MirContext<'a, 'tcx> { }; let callee_ty = common::instance_ty( - bcx.ccx.shared(), instance.as_ref().unwrap()); + bcx.ccx.tcx(), instance.as_ref().unwrap()); trans_intrinsic_call(&bcx, callee_ty, &fn_ty, &llargs, dest, terminator.source_info.span); diff --git a/src/librustc_trans/mir/constant.rs b/src/librustc_trans/mir/constant.rs index 4c3326a466d..9232d73f832 100644 --- a/src/librustc_trans/mir/constant.rs +++ b/src/librustc_trans/mir/constant.rs @@ -261,7 +261,7 @@ impl<'a, 'tcx> MirConstContext<'a, 'tcx> { substs: &'tcx Substs<'tcx>, args: IndexVec<mir::Local, Result<Const<'tcx>, ConstEvalErr<'tcx>>>) -> Result<Const<'tcx>, ConstEvalErr<'tcx>> { - let instance = monomorphize::resolve(ccx.shared(), def_id, substs); + let instance = monomorphize::resolve(ccx.tcx(), def_id, substs); let mir = ccx.tcx().instance_mir(instance.def); MirConstContext::new(ccx, &mir, instance.substs, args).trans() } diff --git a/src/librustc_trans/mir/rvalue.rs b/src/librustc_trans/mir/rvalue.rs index 20ed4ab50a0..822431eba42 100644 --- a/src/librustc_trans/mir/rvalue.rs +++ b/src/librustc_trans/mir/rvalue.rs @@ -222,7 +222,7 @@ impl<'a, 'tcx> MirContext<'a, 'tcx> { match operand.ty.sty { ty::TyClosure(def_id, substs) => { let instance = monomorphize::resolve_closure( - bcx.ccx.shared(), def_id, substs, ty::ClosureKind::FnOnce); + bcx.ccx.tcx(), def_id, substs, ty::ClosureKind::FnOnce); OperandValue::Immediate(callee::get_fn(bcx.ccx, instance)) } _ => { diff --git a/src/librustc_trans/monomorphize.rs b/src/librustc_trans/monomorphize.rs index 309177d9ff6..e62924a54d7 100644 --- a/src/librustc_trans/monomorphize.rs +++ b/src/librustc_trans/monomorphize.rs @@ -85,27 +85,26 @@ fn needs_fn_once_adapter_shim(actual_closure_kind: ty::ClosureKind, } pub fn resolve_closure<'a, 'tcx> ( - scx: &SharedCrateContext<'a, 'tcx>, + tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId, substs: ty::ClosureSubsts<'tcx>, requested_kind: ty::ClosureKind) -> Instance<'tcx> { - let actual_kind = scx.tcx().closure_kind(def_id); + let actual_kind = tcx.closure_kind(def_id); match needs_fn_once_adapter_shim(actual_kind, requested_kind) { - Ok(true) => fn_once_adapter_instance(scx.tcx(), def_id, substs), + Ok(true) => fn_once_adapter_instance(tcx, def_id, substs), _ => Instance::new(def_id, substs.substs) } } fn resolve_associated_item<'a, 'tcx>( - scx: &SharedCrateContext<'a, 'tcx>, + tcx: TyCtxt<'a, 'tcx, 'tcx>, trait_item: &ty::AssociatedItem, trait_id: DefId, rcvr_substs: &'tcx Substs<'tcx> ) -> Instance<'tcx> { - let tcx = scx.tcx(); let def_id = trait_item.def_id; debug!("resolve_associated_item(trait_item={:?}, \ trait_id={:?}, \ @@ -132,7 +131,7 @@ fn resolve_associated_item<'a, 'tcx>( } traits::VtableClosure(closure_data) => { let trait_closure_kind = tcx.lang_items().fn_trait_kind(trait_id).unwrap(); - resolve_closure(scx, closure_data.closure_def_id, closure_data.substs, + resolve_closure(tcx, closure_data.closure_def_id, closure_data.substs, trait_closure_kind) } traits::VtableFnPointer(ref data) => { @@ -163,21 +162,21 @@ fn resolve_associated_item<'a, 'tcx>( /// The point where linking happens. Resolve a (def_id, substs) /// pair to an instance. pub fn resolve<'a, 'tcx>( - scx: &SharedCrateContext<'a, 'tcx>, + tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId, substs: &'tcx Substs<'tcx> ) -> Instance<'tcx> { debug!("resolve(def_id={:?}, substs={:?})", def_id, substs); - let result = if let Some(trait_def_id) = scx.tcx().trait_of_item(def_id) { + let result = if let Some(trait_def_id) = tcx.trait_of_item(def_id) { debug!(" => associated item, attempting to find impl"); - let item = scx.tcx().associated_item(def_id); - resolve_associated_item(scx, &item, trait_def_id, substs) + let item = tcx.associated_item(def_id); + resolve_associated_item(tcx, &item, trait_def_id, substs) } else { - let item_type = def_ty(scx, def_id, substs); + let item_type = def_ty(tcx, def_id, substs); let def = match item_type.sty { ty::TyFnDef(..) if { - let f = item_type.fn_sig(scx.tcx()); + let f = item_type.fn_sig(tcx); f.abi() == Abi::RustIntrinsic || f.abi() == Abi::PlatformIntrinsic } => @@ -186,9 +185,9 @@ pub fn resolve<'a, 'tcx>( ty::InstanceDef::Intrinsic(def_id) } _ => { - if Some(def_id) == scx.tcx().lang_items().drop_in_place_fn() { + if Some(def_id) == tcx.lang_items().drop_in_place_fn() { let ty = substs.type_at(0); - if scx.type_needs_drop(ty) { + if common::type_needs_drop(tcx, ty) { debug!(" => nontrivial drop glue"); ty::InstanceDef::DropGlue(def_id, Some(ty)) } else { @@ -209,27 +208,27 @@ pub fn resolve<'a, 'tcx>( } pub fn resolve_drop_in_place<'a, 'tcx>( - scx: &SharedCrateContext<'a, 'tcx>, + tcx: TyCtxt<'a, 'tcx, 'tcx>, ty: Ty<'tcx>) -> ty::Instance<'tcx> { - let def_id = scx.tcx().require_lang_item(DropInPlaceFnLangItem); - let substs = scx.tcx().intern_substs(&[Kind::from(ty)]); - resolve(scx, def_id, substs) + let def_id = tcx.require_lang_item(DropInPlaceFnLangItem); + let substs = tcx.intern_substs(&[Kind::from(ty)]); + resolve(tcx, def_id, substs) } -pub fn custom_coerce_unsize_info<'scx, 'tcx>(scx: &SharedCrateContext<'scx, 'tcx>, - source_ty: Ty<'tcx>, - target_ty: Ty<'tcx>) - -> CustomCoerceUnsized { +pub fn custom_coerce_unsize_info<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, + source_ty: Ty<'tcx>, + target_ty: Ty<'tcx>) + -> CustomCoerceUnsized { let trait_ref = ty::Binder(ty::TraitRef { - def_id: scx.tcx().lang_items().coerce_unsized_trait().unwrap(), - substs: scx.tcx().mk_substs_trait(source_ty, &[target_ty]) + def_id: tcx.lang_items().coerce_unsized_trait().unwrap(), + substs: tcx.mk_substs_trait(source_ty, &[target_ty]) }); - match scx.tcx().trans_fulfill_obligation(DUMMY_SP, trait_ref) { + match tcx.trans_fulfill_obligation(DUMMY_SP, trait_ref) { traits::VtableImpl(traits::VtableImplData { impl_def_id, .. }) => { - scx.tcx().coerce_unsized_info(impl_def_id).custom_kind.unwrap() + tcx.coerce_unsized_info(impl_def_id).custom_kind.unwrap() } vtable => { bug!("invalid CoerceUnsized vtable: {:?}", vtable); diff --git a/src/librustc_trans/partitioning.rs b/src/librustc_trans/partitioning.rs index 26256fa78dd..782a00648ce 100644 --- a/src/librustc_trans/partitioning.rs +++ b/src/librustc_trans/partitioning.rs @@ -621,7 +621,7 @@ fn characteristic_def_id_of_trans_item<'a, 'tcx>(scx: &SharedCrateContext<'a, 't if let Some(impl_def_id) = tcx.impl_of_method(def_id) { // This is a method within an inherent impl, find out what the // self-type is: - let impl_self_ty = common::def_ty(scx, impl_def_id, instance.substs); + let impl_self_ty = common::def_ty(scx.tcx(), impl_def_id, instance.substs); if let Some(def_id) = characteristic_def_id_of_type(impl_self_ty) { return Some(def_id); } diff --git a/src/librustc_trans/trans_item.rs b/src/librustc_trans/trans_item.rs index 1f27eb9fcb3..5a51f690c45 100644 --- a/src/librustc_trans/trans_item.rs +++ b/src/librustc_trans/trans_item.rs @@ -133,7 +133,7 @@ impl<'a, 'tcx> TransItem<'tcx> { symbol_name: &str) { let def_id = ccx.tcx().hir.local_def_id(node_id); let instance = Instance::mono(ccx.tcx(), def_id); - let ty = common::instance_ty(ccx.shared(), &instance); + let ty = common::instance_ty(ccx.tcx(), &instance); let llty = type_of::type_of(ccx, ty); let g = declare::define_global(ccx, symbol_name, llty).unwrap_or_else(|| { @@ -158,7 +158,7 @@ impl<'a, 'tcx> TransItem<'tcx> { assert!(!instance.substs.needs_infer() && !instance.substs.has_param_types()); - let mono_ty = common::instance_ty(ccx.shared(), &instance); + let mono_ty = common::instance_ty(ccx.tcx(), &instance); let attrs = instance.def.attrs(ccx.tcx()); let lldecl = declare::declare_fn(ccx, symbol_name, mono_ty); unsafe { llvm::LLVMRustSetLinkage(lldecl, linkage) }; |