mathieu/granite-rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

give apply_param_substs a SharedCrateContext

Browse source 
I plan to put a cache on the shared context, for now at least.
This commit is contained in:
Niko Matsakis 2016-08-08 20:50:19 -04:00
parent 4eb7362c2c
commit 72694d5829
9 changed files with 53 additions and 44 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
src/librustc_trans/base.rs
View file

@ -1128,7 +1128,7 @@ pub fn trans_instance<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, instance: Instance
let fn_ty = ccx.tcx().lookup_item_type(instance.def).ty;
let fn_ty = ccx.tcx().erase_regions(&fn_ty);
let fn_ty = monomorphize::apply_param_substs(ccx.tcx(), instance.substs, &fn_ty);
let fn_ty = monomorphize::apply_param_substs(ccx.shared(), instance.substs, &fn_ty);
let sig = ccx.tcx().erase_late_bound_regions(fn_ty.fn_sig());
let sig = ccx.tcx().normalize_associated_type(&sig);
@ -1151,7 +1151,7 @@ pub fn trans_ctor_shim<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
attributes::set_frame_pointer_elimination(ccx, llfndecl);
let ctor_ty = ccx.tcx().lookup_item_type(def_id).ty;
let ctor_ty = monomorphize::apply_param_substs(ccx.tcx(), substs, &ctor_ty);
let ctor_ty = monomorphize::apply_param_substs(ccx.shared(), substs, &ctor_ty);
let sig = ccx.tcx().erase_late_bound_regions(&ctor_ty.fn_sig());
let sig = ccx.tcx().normalize_associated_type(&sig);
@ -1894,7 +1894,7 @@ fn collect_and_partition_translation_items<'a, 'tcx>(scx: &SharedCrateContext<'a
};
let codegen_units = time(time_passes, "codegen unit partitioning", || {
partitioning::partition(scx.tcx(),
partitioning::partition(scx,
items.iter().cloned(),
strategy,
&inlining_map,

20
src/librustc_trans/callee.rs
View file

@ -28,7 +28,7 @@ use base;
use base::*;
use build::*;
use closure;
use common::{self, Block, Result, CrateContext, FunctionContext};
use common::{self, Block, Result, CrateContext, FunctionContext, SharedCrateContext};
use consts;
use debuginfo::DebugLoc;
use declare;
@ -37,7 +37,7 @@ use monomorphize::{self, Instance};
use trans_item::TransItem;
use type_of;
use Disr;
use rustc::ty::{self, Ty, TyCtxt, TypeFoldable};
use rustc::ty::{self, Ty, TypeFoldable};
use rustc::hir;
use syntax_pos::DUMMY_SP;
@ -97,7 +97,7 @@ impl<'tcx> Callee<'tcx> {
return Callee::trait_method(ccx, trait_id, def_id, substs);
}
let fn_ty = def_ty(tcx, def_id, substs);
let fn_ty = def_ty(ccx.shared(), def_id, substs);
if let ty::TyFnDef(_, _, f) = fn_ty.sty {
if f.abi == Abi::RustIntrinsic || f.abi == Abi::PlatformIntrinsic {
return Callee {
@ -155,20 +155,20 @@ impl<'tcx> Callee<'tcx> {
vtable_closure.substs,
trait_closure_kind);
let method_ty = def_ty(tcx, def_id, substs);
let method_ty = def_ty(ccx.shared(), def_id, substs);
Callee::ptr(llfn, method_ty)
}
traits::VtableFnPointer(vtable_fn_pointer) => {
let trait_closure_kind = tcx.lang_items.fn_trait_kind(trait_id).unwrap();
let llfn = trans_fn_pointer_shim(ccx, trait_closure_kind, vtable_fn_pointer.fn_ty);
let method_ty = def_ty(tcx, def_id, substs);
let method_ty = def_ty(ccx.shared(), def_id, substs);
Callee::ptr(llfn, method_ty)
}
traits::VtableObject(ref data) => {
Callee {
data: Virtual(tcx.get_vtable_index_of_object_method(data, def_id)),
ty: def_ty(tcx, def_id, substs)
ty: def_ty(ccx.shared(), def_id, substs)
}
}
vtable => {
@ -244,12 +244,12 @@ impl<'tcx> Callee<'tcx> {
}
/// Given a DefId and some Substs, produces the monomorphic item type.
fn def_ty<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
fn def_ty<'a, 'tcx>(shared: &SharedCrateContext<'a, 'tcx>,
def_id: DefId,
substs: &'tcx Substs<'tcx>)
-> Ty<'tcx> {
let ty = tcx.lookup_item_type(def_id).ty;
monomorphize::apply_param_substs(tcx, substs, &ty)
let ty = shared.tcx().lookup_item_type(def_id).ty;
monomorphize::apply_param_substs(shared, substs, &ty)
}
/// Translates an adapter that implements the `Fn` trait for a fn
@ -407,7 +407,7 @@ fn get_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
let substs = tcx.normalize_associated_type(&substs);
let instance = Instance::new(def_id, substs);
let item_ty = ccx.tcx().lookup_item_type(def_id).ty;
let fn_ty = monomorphize::apply_param_substs(ccx.tcx(), substs, &item_ty);
let fn_ty = monomorphize::apply_param_substs(ccx.shared(), substs, &item_ty);
if let Some(&llfn) = ccx.instances().borrow().get(&instance) {
return (llfn, fn_ty);

40
src/librustc_trans/collector.rs
View file

@ -459,7 +459,7 @@ impl<'a, 'tcx> MirVisitor<'tcx> for MirNeighborCollector<'a, 'tcx> {
format!("Could not find MIR for closure: {:?}", def_id)
});
let concrete_substs = monomorphize::apply_param_substs(self.scx.tcx(),
let concrete_substs = monomorphize::apply_param_substs(self.scx,
self.param_substs,
&substs.func_substs);
let concrete_substs = self.scx.tcx().erase_regions(&concrete_substs);
@ -477,11 +477,11 @@ 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 = monomorphize::apply_param_substs(self.scx.tcx(),
let target_ty = monomorphize::apply_param_substs(self.scx,
self.param_substs,
&target_ty);
let source_ty = operand.ty(self.mir, self.scx.tcx());
let source_ty = monomorphize::apply_param_substs(self.scx.tcx(),
let source_ty = monomorphize::apply_param_substs(self.scx,
self.param_substs,
&source_ty);
let (source_ty, target_ty) = find_vtable_types_for_unsizing(self.scx,
@ -508,7 +508,7 @@ impl<'a, 'tcx> MirVisitor<'tcx> for MirNeighborCollector<'a, 'tcx> {
assert!(can_have_local_instance(self.scx.tcx(), exchange_malloc_fn_def_id));
let empty_substs = self.scx.empty_substs_for_def_id(exchange_malloc_fn_def_id);
let exchange_malloc_fn_trans_item =
create_fn_trans_item(self.scx.tcx(),
create_fn_trans_item(self.scx,
exchange_malloc_fn_def_id,
empty_substs,
self.param_substs);
@ -531,7 +531,7 @@ impl<'a, 'tcx> MirVisitor<'tcx> for MirNeighborCollector<'a, 'tcx> {
let ty = lvalue.ty(self.mir, self.scx.tcx())
.to_ty(self.scx.tcx());
let ty = monomorphize::apply_param_substs(self.scx.tcx(),
let ty = monomorphize::apply_param_substs(self.scx,
self.param_substs,
&ty);
assert!(ty.is_normalized_for_trans());
@ -555,7 +555,7 @@ impl<'a, 'tcx> MirVisitor<'tcx> for MirNeighborCollector<'a, 'tcx> {
// references to `const` items
if let mir::Literal::Item { def_id, substs } = constant.literal {
let tcx = self.scx.tcx();
let substs = monomorphize::apply_param_substs(tcx,
let substs = monomorphize::apply_param_substs(self.scx,
self.param_substs,
&substs);
@ -613,7 +613,7 @@ impl<'a, 'tcx> MirVisitor<'tcx> for MirNeighborCollector<'a, 'tcx> {
// result in a translation item ...
if can_result_in_trans_item(self.scx.tcx(), callee_def_id) {
// ... and create one if it does.
let trans_item = create_fn_trans_item(self.scx.tcx(),
let trans_item = create_fn_trans_item(self.scx,
callee_def_id,
callee_substs,
self.param_substs);
@ -670,7 +670,7 @@ impl<'a, 'tcx> MirVisitor<'tcx> for MirNeighborCollector<'a, 'tcx> {
if is_drop_in_place_intrinsic(tcx, def_id, bare_fn_ty) => {
let operand_ty = args[0].ty(self.mir, tcx);
if let ty::TyRawPtr(mt) = operand_ty.sty {
let operand_ty = monomorphize::apply_param_substs(tcx,
let operand_ty = monomorphize::apply_param_substs(self.scx,
self.param_substs,
&mt.ty);
let ty = glue::get_drop_glue_type(tcx, operand_ty);
@ -732,7 +732,7 @@ fn find_drop_glue_neighbors<'a, 'tcx>(scx: &SharedCrateContext<'a, 'tcx>,
assert!(can_have_local_instance(scx.tcx(), exchange_free_fn_def_id));
let fn_substs = scx.empty_substs_for_def_id(exchange_free_fn_def_id);
let exchange_free_fn_trans_item =
create_fn_trans_item(scx.tcx(),
create_fn_trans_item(scx,
exchange_free_fn_def_id,
fn_substs,
Substs::empty(scx.tcx()));
@ -769,7 +769,7 @@ fn find_drop_glue_neighbors<'a, 'tcx>(scx: &SharedCrateContext<'a, 'tcx>,
};
if can_have_local_instance(scx.tcx(), destructor_did) {
let trans_item = create_fn_trans_item(scx.tcx(),
let trans_item = create_fn_trans_item(scx,
destructor_did,
substs,
Substs::empty(scx.tcx()));
@ -800,7 +800,7 @@ fn find_drop_glue_neighbors<'a, 'tcx>(scx: &SharedCrateContext<'a, 'tcx>,
ty::TyStruct(ref adt_def, substs) |
ty::TyEnum(ref adt_def, substs) => {
for field in adt_def.all_fields() {
let field_type = monomorphize::apply_param_substs(scx.tcx(),
let field_type = monomorphize::apply_param_substs(scx,
substs,
&field.unsubst_ty());
let field_type = glue::get_drop_glue_type(scx.tcx(), field_type);
@ -894,8 +894,7 @@ fn do_static_trait_method_dispatch<'a, 'tcx>(scx: &SharedCrateContext<'a, 'tcx>,
callee_substs,
param_substs);
let rcvr_substs = monomorphize::apply_param_substs(tcx,
let rcvr_substs = monomorphize::apply_param_substs(scx,
param_substs,
&callee_substs);
let trait_ref = ty::TraitRef::from_method(tcx, trait_id, rcvr_substs);
@ -1016,11 +1015,13 @@ fn find_vtable_types_for_unsizing<'a, 'tcx>(scx: &SharedCrateContext<'a, 'tcx>,
}
}
fn create_fn_trans_item<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
fn create_fn_trans_item<'a, 'tcx>(scx: &SharedCrateContext<'a, 'tcx>,
def_id: DefId,
fn_substs: &'tcx Substs<'tcx>,
param_substs: &'tcx Substs<'tcx>)
-> TransItem<'tcx> {
let tcx = scx.tcx();
debug!("create_fn_trans_item(def_id={}, fn_substs={:?}, param_substs={:?})",
def_id_to_string(tcx, def_id),
fn_substs,
@ -1029,7 +1030,7 @@ fn create_fn_trans_item<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
// We only get here, if fn_def_id either designates a local item or
// an inlineable external item. Non-inlineable external items are
// ignored because we don't want to generate any code for them.
let concrete_substs = monomorphize::apply_param_substs(tcx,
let concrete_substs = monomorphize::apply_param_substs(scx,
param_substs,
&fn_substs);
assert!(concrete_substs.is_normalized_for_trans());
@ -1063,7 +1064,7 @@ fn create_trans_items_for_vtable_methods<'a, 'tcx>(scx: &SharedCrateContext<'a,
// create translation items
.filter_map(|impl_method| {
if can_have_local_instance(scx.tcx(), impl_method.method.def_id) {
Some(create_fn_trans_item(scx.tcx(),
Some(create_fn_trans_item(scx,
impl_method.method.def_id,
impl_method.substs,
Substs::empty(scx.tcx())))
@ -1114,7 +1115,7 @@ impl<'b, 'a, 'v> hir_visit::Visitor<'v> for RootCollector<'b, 'a, 'v> {
hir::ItemImpl(..) => {
if self.mode == TransItemCollectionMode::Eager {
create_trans_items_for_default_impls(self.scx.tcx(),
create_trans_items_for_default_impls(self.scx,
item,
self.output);
}
@ -1202,9 +1203,10 @@ impl<'b, 'a, 'v> hir_visit::Visitor<'v> for RootCollector<'b, 'a, 'v> {
}
}
fn create_trans_items_for_default_impls<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
fn create_trans_items_for_default_impls<'a, 'tcx>(scx: &SharedCrateContext<'a, 'tcx>,
item: &'tcx hir::Item,
output: &mut Vec<TransItem<'tcx>>) {
let tcx = scx.tcx();
match item.node {
hir::ItemImpl(_,
_,
@ -1255,7 +1257,7 @@ fn create_trans_items_for_default_impls<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
if can_have_local_instance(tcx, method.def_id) {
let empty_substs = tcx.erase_regions(&mth.substs);
let item = create_fn_trans_item(tcx,
let item = create_fn_trans_item(scx,
method.def_id,
callee_substs,
empty_substs);

4
src/librustc_trans/common.rs
View file

@ -350,7 +350,7 @@ impl<'a, 'tcx> FunctionContext<'a, 'tcx> {
pub fn monomorphize<T>(&self, value: &T) -> T
where T: TransNormalize<'tcx>
{
monomorphize::apply_param_substs(self.ccx.tcx(),
monomorphize::apply_param_substs(self.ccx.shared(),
self.param_substs,
value)
}
@ -519,7 +519,7 @@ impl<'blk, 'tcx> BlockS<'blk, 'tcx> {
pub fn monomorphize<T>(&self, value: &T) -> T
where T: TransNormalize<'tcx>
{
monomorphize::apply_param_substs(self.tcx(),
monomorphize::apply_param_substs(self.fcx.ccx.shared(),
self.fcx.param_substs,
value)
}

2
src/librustc_trans/debuginfo/mod.rs
View file

@ -414,7 +414,7 @@ pub fn create_function_debug_context<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
if cx.tcx().trait_id_of_impl(impl_def_id).is_none() {
let impl_self_ty = cx.tcx().lookup_item_type(impl_def_id).ty;
let impl_self_ty = cx.tcx().erase_regions(&impl_self_ty);
let impl_self_ty = monomorphize::apply_param_substs(cx.tcx(),
let impl_self_ty = monomorphize::apply_param_substs(cx.shared(),
instance.substs,
&impl_self_ty);

2
src/librustc_trans/mir/constant.rs
View file

@ -258,7 +258,7 @@ impl<'a, 'tcx> MirConstContext<'a, 'tcx> {
fn monomorphize<T>(&self, value: &T) -> T
where T: TransNormalize<'tcx>
{
monomorphize::apply_param_substs(self.ccx.tcx(),
monomorphize::apply_param_substs(self.ccx.shared(),
self.substs,
value)
}

4
src/librustc_trans/monomorphize.rs
View file

@ -42,12 +42,13 @@ impl<'tcx> Instance<'tcx> {
/// Monomorphizes a type from the AST by first applying the in-scope
/// substitutions and then normalizing any associated types.
pub fn apply_param_substs<'a, 'tcx, T>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
pub fn apply_param_substs<'a, 'tcx, T>(scx: &SharedCrateContext<'a, 'tcx>,
param_substs: &Substs<'tcx>,
value: &T)
-> T
where T: TransNormalize<'tcx>
{
let tcx = scx.tcx();
debug!("apply_param_substs(param_substs={:?}, value={:?})", param_substs, value);
let substituted = value.subst(tcx, param_substs);
debug!("apply_param_substs: substituted={:?}{}",
@ -65,3 +66,4 @@ pub fn field_ty<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
{
tcx.normalize_associated_type(&f.ty(tcx, param_substs))
}

17
src/librustc_trans/partitioning.rs
View file

@ -117,6 +117,7 @@
//! inlining, even when they are not marked #[inline].
use collector::InliningMap;
use context::SharedCrateContext;
use llvm;
use monomorphize;
use rustc::dep_graph::{DepNode, WorkProductId};
@ -250,7 +251,7 @@ impl<'tcx> CodegenUnit<'tcx> {
// Anything we can't find a proper codegen unit for goes into this.
const FALLBACK_CODEGEN_UNIT: &'static str = "__rustc_fallback_codegen_unit";
pub fn partition<'a, 'tcx, I>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
pub fn partition<'a, 'tcx, I>(scx: &SharedCrateContext<'a, 'tcx>,
trans_items: I,
strategy: PartitioningStrategy,
inlining_map: &InliningMap<'tcx>,
@ -258,6 +259,8 @@ pub fn partition<'a, 'tcx, I>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
-> Vec<CodegenUnit<'tcx>>
where I: Iterator<Item = TransItem<'tcx>>
{
let tcx = scx.tcx();
if let PartitioningStrategy::FixedUnitCount(1) = strategy {
// If there is only a single codegen-unit, we can use a very simple
// scheme and don't have to bother with doing much analysis.
@ -267,7 +270,7 @@ pub fn partition<'a, 'tcx, I>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
// In the first step, we place all regular translation items into their
// respective 'home' codegen unit. Regular translation items are all
// functions and statics defined in the local crate.
let mut initial_partitioning = place_root_translation_items(tcx,
let mut initial_partitioning = place_root_translation_items(scx,
trans_items,
reachable);
@ -306,12 +309,13 @@ struct PreInliningPartitioning<'tcx> {
struct PostInliningPartitioning<'tcx>(Vec<CodegenUnit<'tcx>>);
fn place_root_translation_items<'a, 'tcx, I>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
fn place_root_translation_items<'a, 'tcx, I>(scx: &SharedCrateContext<'a, 'tcx>,
trans_items: I,
_reachable: &NodeSet)
-> PreInliningPartitioning<'tcx>
where I: Iterator<Item = TransItem<'tcx>>
{
let tcx = scx.tcx();
let mut roots = FnvHashSet();
let mut codegen_units = FnvHashMap();
@ -319,7 +323,7 @@ fn place_root_translation_items<'a, 'tcx, I>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
let is_root = !trans_item.is_instantiated_only_on_demand();
if is_root {
let characteristic_def_id = characteristic_def_id_of_trans_item(tcx, trans_item);
let characteristic_def_id = characteristic_def_id_of_trans_item(scx, trans_item);
let is_volatile = trans_item.is_generic_fn();
let codegen_unit_name = match characteristic_def_id {
@ -477,9 +481,10 @@ fn place_inlined_translation_items<'tcx>(initial_partitioning: PreInliningPartit
}
}
fn characteristic_def_id_of_trans_item<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
fn characteristic_def_id_of_trans_item<'a, 'tcx>(scx: &SharedCrateContext<'a, 'tcx>,
trans_item: TransItem<'tcx>)
-> Option<DefId> {
let tcx = scx.tcx();
match trans_item {
TransItem::Fn(instance) => {
// If this is a method, we want to put it into the same module as
@ -497,7 +502,7 @@ fn characteristic_def_id_of_trans_item<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
// self-type is:
let impl_self_ty = tcx.lookup_item_type(impl_def_id).ty;
let impl_self_ty = tcx.erase_regions(&impl_self_ty);
let impl_self_ty = monomorphize::apply_param_substs(tcx,
let impl_self_ty = monomorphize::apply_param_substs(scx,
instance.substs,
&impl_self_ty);

2
src/librustc_trans/trans_item.rs
View file

@ -176,7 +176,7 @@ impl<'a, 'tcx> TransItem<'tcx> {
let item_ty = ccx.tcx().lookup_item_type(instance.def).ty;
let item_ty = ccx.tcx().erase_regions(&item_ty);
let mono_ty = monomorphize::apply_param_substs(ccx.tcx(), instance.substs, &item_ty);
let mono_ty = monomorphize::apply_param_substs(ccx.shared(), instance.substs, &item_ty);
let attrs = ccx.tcx().get_attrs(instance.def);
let lldecl = declare::declare_fn(ccx, symbol_name, mono_ty);