I plan to put a cache on the shared context, for now at least.
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);
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);
};
let codegen_units = time(time_passes, "codegen unit partitioning", || {
- partitioning::partition(scx.tcx(),
+ partitioning::partition(scx,
items.iter().cloned(),
strategy,
&inlining_map,
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;
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;
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 {
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 => {
}
/// 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
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);
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);
// 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,
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);
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());
// 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);
// 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);
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);
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()));
};
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()));
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);
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);
}
}
-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,
// 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());
// 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())))
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);
}
}
}
-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(_,
_,
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);
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)
}
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)
}
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);
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)
}
/// 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={:?}{}",
{
tcx.normalize_associated_type(&f.ty(tcx, param_substs))
}
+
//! inlining, even when they are not marked #[inline].
use collector::InliningMap;
+use context::SharedCrateContext;
use llvm;
use monomorphize;
use rustc::dep_graph::{DepNode, WorkProductId};
// 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>,
-> 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.
// 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);
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();
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 {
}
}
-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
// 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);
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);