Move monomorphize code to its own crate.
This commit is contained in:
parent
bba4be681d
commit
81a600b6b7
13 changed files with 72 additions and 23 deletions
1412
compiler/rustc_monomorphize/src/collector.rs
Normal file
1412
compiler/rustc_monomorphize/src/collector.rs
Normal file
File diff suppressed because it is too large
Load diff
49
compiler/rustc_monomorphize/src/lib.rs
Normal file
49
compiler/rustc_monomorphize/src/lib.rs
Normal file
|
@ -0,0 +1,49 @@
|
|||
#![feature(array_windows)]
|
||||
#![feature(bool_to_option)]
|
||||
#![feature(crate_visibility_modifier)]
|
||||
#![feature(control_flow_enum)]
|
||||
#![feature(in_band_lifetimes)]
|
||||
|
||||
#[macro_use]
|
||||
extern crate tracing;
|
||||
#[macro_use]
|
||||
extern crate rustc_middle;
|
||||
|
||||
use rustc_hir::lang_items::LangItem;
|
||||
use rustc_middle::traits;
|
||||
use rustc_middle::ty::adjustment::CustomCoerceUnsized;
|
||||
use rustc_middle::ty::query::Providers;
|
||||
use rustc_middle::ty::{self, Ty, TyCtxt};
|
||||
|
||||
mod collector;
|
||||
mod partitioning;
|
||||
mod polymorphize;
|
||||
mod util;
|
||||
|
||||
fn custom_coerce_unsize_info<'tcx>(
|
||||
tcx: TyCtxt<'tcx>,
|
||||
source_ty: Ty<'tcx>,
|
||||
target_ty: Ty<'tcx>,
|
||||
) -> CustomCoerceUnsized {
|
||||
let def_id = tcx.require_lang_item(LangItem::CoerceUnsized, None);
|
||||
|
||||
let trait_ref = ty::Binder::dummy(ty::TraitRef {
|
||||
def_id,
|
||||
substs: tcx.mk_substs_trait(source_ty, &[target_ty.into()]),
|
||||
});
|
||||
|
||||
match tcx.codegen_fulfill_obligation((ty::ParamEnv::reveal_all(), trait_ref)) {
|
||||
Ok(traits::ImplSource::UserDefined(traits::ImplSourceUserDefinedData {
|
||||
impl_def_id,
|
||||
..
|
||||
})) => tcx.coerce_unsized_info(impl_def_id).custom_kind.unwrap(),
|
||||
impl_source => {
|
||||
bug!("invalid `CoerceUnsized` impl_source: {:?}", impl_source);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn provide(providers: &mut Providers) {
|
||||
partitioning::provide(providers);
|
||||
polymorphize::provide(providers);
|
||||
}
|
557
compiler/rustc_monomorphize/src/partitioning/default.rs
Normal file
557
compiler/rustc_monomorphize/src/partitioning/default.rs
Normal file
|
@ -0,0 +1,557 @@
|
|||
use std::collections::hash_map::Entry;
|
||||
|
||||
use rustc_data_structures::fx::{FxHashMap, FxHashSet};
|
||||
use rustc_hir::def::DefKind;
|
||||
use rustc_hir::def_id::{DefId, CRATE_DEF_INDEX, LOCAL_CRATE};
|
||||
use rustc_hir::definitions::DefPathDataName;
|
||||
use rustc_middle::middle::codegen_fn_attrs::CodegenFnAttrFlags;
|
||||
use rustc_middle::middle::exported_symbols::SymbolExportLevel;
|
||||
use rustc_middle::mir::mono::{CodegenUnit, CodegenUnitNameBuilder, Linkage, Visibility};
|
||||
use rustc_middle::mir::mono::{InstantiationMode, MonoItem};
|
||||
use rustc_middle::ty::print::characteristic_def_id_of_type;
|
||||
use rustc_middle::ty::{self, DefIdTree, InstanceDef, TyCtxt};
|
||||
use rustc_span::symbol::Symbol;
|
||||
|
||||
use super::PartitioningCx;
|
||||
use crate::collector::InliningMap;
|
||||
use crate::partitioning::merging;
|
||||
use crate::partitioning::{
|
||||
MonoItemPlacement, Partitioner, PostInliningPartitioning, PreInliningPartitioning,
|
||||
};
|
||||
|
||||
pub struct DefaultPartitioning;
|
||||
|
||||
impl<'tcx> Partitioner<'tcx> for DefaultPartitioning {
|
||||
fn place_root_mono_items(
|
||||
&mut self,
|
||||
cx: &PartitioningCx<'_, 'tcx>,
|
||||
mono_items: &mut dyn Iterator<Item = MonoItem<'tcx>>,
|
||||
) -> PreInliningPartitioning<'tcx> {
|
||||
let mut roots = FxHashSet::default();
|
||||
let mut codegen_units = FxHashMap::default();
|
||||
let is_incremental_build = cx.tcx.sess.opts.incremental.is_some();
|
||||
let mut internalization_candidates = FxHashSet::default();
|
||||
|
||||
// Determine if monomorphizations instantiated in this crate will be made
|
||||
// available to downstream crates. This depends on whether we are in
|
||||
// share-generics mode and whether the current crate can even have
|
||||
// downstream crates.
|
||||
let export_generics =
|
||||
cx.tcx.sess.opts.share_generics() && cx.tcx.local_crate_exports_generics();
|
||||
|
||||
let cgu_name_builder = &mut CodegenUnitNameBuilder::new(cx.tcx);
|
||||
let cgu_name_cache = &mut FxHashMap::default();
|
||||
|
||||
for mono_item in mono_items {
|
||||
match mono_item.instantiation_mode(cx.tcx) {
|
||||
InstantiationMode::GloballyShared { .. } => {}
|
||||
InstantiationMode::LocalCopy => continue,
|
||||
}
|
||||
|
||||
let characteristic_def_id = characteristic_def_id_of_mono_item(cx.tcx, mono_item);
|
||||
let is_volatile = is_incremental_build && mono_item.is_generic_fn();
|
||||
|
||||
let codegen_unit_name = match characteristic_def_id {
|
||||
Some(def_id) => compute_codegen_unit_name(
|
||||
cx.tcx,
|
||||
cgu_name_builder,
|
||||
def_id,
|
||||
is_volatile,
|
||||
cgu_name_cache,
|
||||
),
|
||||
None => fallback_cgu_name(cgu_name_builder),
|
||||
};
|
||||
|
||||
let codegen_unit = codegen_units
|
||||
.entry(codegen_unit_name)
|
||||
.or_insert_with(|| CodegenUnit::new(codegen_unit_name));
|
||||
|
||||
let mut can_be_internalized = true;
|
||||
let (linkage, visibility) = mono_item_linkage_and_visibility(
|
||||
cx.tcx,
|
||||
&mono_item,
|
||||
&mut can_be_internalized,
|
||||
export_generics,
|
||||
);
|
||||
if visibility == Visibility::Hidden && can_be_internalized {
|
||||
internalization_candidates.insert(mono_item);
|
||||
}
|
||||
|
||||
codegen_unit.items_mut().insert(mono_item, (linkage, visibility));
|
||||
roots.insert(mono_item);
|
||||
}
|
||||
|
||||
// Always ensure we have at least one CGU; otherwise, if we have a
|
||||
// crate with just types (for example), we could wind up with no CGU.
|
||||
if codegen_units.is_empty() {
|
||||
let codegen_unit_name = fallback_cgu_name(cgu_name_builder);
|
||||
codegen_units.insert(codegen_unit_name, CodegenUnit::new(codegen_unit_name));
|
||||
}
|
||||
|
||||
PreInliningPartitioning {
|
||||
codegen_units: codegen_units
|
||||
.into_iter()
|
||||
.map(|(_, codegen_unit)| codegen_unit)
|
||||
.collect(),
|
||||
roots,
|
||||
internalization_candidates,
|
||||
}
|
||||
}
|
||||
|
||||
fn merge_codegen_units(
|
||||
&mut self,
|
||||
cx: &PartitioningCx<'_, 'tcx>,
|
||||
initial_partitioning: &mut PreInliningPartitioning<'tcx>,
|
||||
) {
|
||||
merging::merge_codegen_units(cx, initial_partitioning);
|
||||
}
|
||||
|
||||
fn place_inlined_mono_items(
|
||||
&mut self,
|
||||
cx: &PartitioningCx<'_, 'tcx>,
|
||||
initial_partitioning: PreInliningPartitioning<'tcx>,
|
||||
) -> PostInliningPartitioning<'tcx> {
|
||||
let mut new_partitioning = Vec::new();
|
||||
let mut mono_item_placements = FxHashMap::default();
|
||||
|
||||
let PreInliningPartitioning {
|
||||
codegen_units: initial_cgus,
|
||||
roots,
|
||||
internalization_candidates,
|
||||
} = initial_partitioning;
|
||||
|
||||
let single_codegen_unit = initial_cgus.len() == 1;
|
||||
|
||||
for old_codegen_unit in initial_cgus {
|
||||
// Collect all items that need to be available in this codegen unit.
|
||||
let mut reachable = FxHashSet::default();
|
||||
for root in old_codegen_unit.items().keys() {
|
||||
follow_inlining(*root, cx.inlining_map, &mut reachable);
|
||||
}
|
||||
|
||||
let mut new_codegen_unit = CodegenUnit::new(old_codegen_unit.name());
|
||||
|
||||
// Add all monomorphizations that are not already there.
|
||||
for mono_item in reachable {
|
||||
if let Some(linkage) = old_codegen_unit.items().get(&mono_item) {
|
||||
// This is a root, just copy it over.
|
||||
new_codegen_unit.items_mut().insert(mono_item, *linkage);
|
||||
} else {
|
||||
if roots.contains(&mono_item) {
|
||||
bug!(
|
||||
"GloballyShared mono-item inlined into other CGU: \
|
||||
{:?}",
|
||||
mono_item
|
||||
);
|
||||
}
|
||||
|
||||
// This is a CGU-private copy.
|
||||
new_codegen_unit
|
||||
.items_mut()
|
||||
.insert(mono_item, (Linkage::Internal, Visibility::Default));
|
||||
}
|
||||
|
||||
if !single_codegen_unit {
|
||||
// If there is more than one codegen unit, we need to keep track
|
||||
// in which codegen units each monomorphization is placed.
|
||||
match mono_item_placements.entry(mono_item) {
|
||||
Entry::Occupied(e) => {
|
||||
let placement = e.into_mut();
|
||||
debug_assert!(match *placement {
|
||||
MonoItemPlacement::SingleCgu { cgu_name } => {
|
||||
cgu_name != new_codegen_unit.name()
|
||||
}
|
||||
MonoItemPlacement::MultipleCgus => true,
|
||||
});
|
||||
*placement = MonoItemPlacement::MultipleCgus;
|
||||
}
|
||||
Entry::Vacant(e) => {
|
||||
e.insert(MonoItemPlacement::SingleCgu {
|
||||
cgu_name: new_codegen_unit.name(),
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
new_partitioning.push(new_codegen_unit);
|
||||
}
|
||||
|
||||
return PostInliningPartitioning {
|
||||
codegen_units: new_partitioning,
|
||||
mono_item_placements,
|
||||
internalization_candidates,
|
||||
};
|
||||
|
||||
fn follow_inlining<'tcx>(
|
||||
mono_item: MonoItem<'tcx>,
|
||||
inlining_map: &InliningMap<'tcx>,
|
||||
visited: &mut FxHashSet<MonoItem<'tcx>>,
|
||||
) {
|
||||
if !visited.insert(mono_item) {
|
||||
return;
|
||||
}
|
||||
|
||||
inlining_map.with_inlining_candidates(mono_item, |target| {
|
||||
follow_inlining(target, inlining_map, visited);
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
fn internalize_symbols(
|
||||
&mut self,
|
||||
cx: &PartitioningCx<'_, 'tcx>,
|
||||
partitioning: &mut PostInliningPartitioning<'tcx>,
|
||||
) {
|
||||
if partitioning.codegen_units.len() == 1 {
|
||||
// Fast path for when there is only one codegen unit. In this case we
|
||||
// can internalize all candidates, since there is nowhere else they
|
||||
// could be accessed from.
|
||||
for cgu in &mut partitioning.codegen_units {
|
||||
for candidate in &partitioning.internalization_candidates {
|
||||
cgu.items_mut().insert(*candidate, (Linkage::Internal, Visibility::Default));
|
||||
}
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
// Build a map from every monomorphization to all the monomorphizations that
|
||||
// reference it.
|
||||
let mut accessor_map: FxHashMap<MonoItem<'tcx>, Vec<MonoItem<'tcx>>> = Default::default();
|
||||
cx.inlining_map.iter_accesses(|accessor, accessees| {
|
||||
for accessee in accessees {
|
||||
accessor_map.entry(*accessee).or_default().push(accessor);
|
||||
}
|
||||
});
|
||||
|
||||
let mono_item_placements = &partitioning.mono_item_placements;
|
||||
|
||||
// For each internalization candidates in each codegen unit, check if it is
|
||||
// accessed from outside its defining codegen unit.
|
||||
for cgu in &mut partitioning.codegen_units {
|
||||
let home_cgu = MonoItemPlacement::SingleCgu { cgu_name: cgu.name() };
|
||||
|
||||
for (accessee, linkage_and_visibility) in cgu.items_mut() {
|
||||
if !partitioning.internalization_candidates.contains(accessee) {
|
||||
// This item is no candidate for internalizing, so skip it.
|
||||
continue;
|
||||
}
|
||||
debug_assert_eq!(mono_item_placements[accessee], home_cgu);
|
||||
|
||||
if let Some(accessors) = accessor_map.get(accessee) {
|
||||
if accessors
|
||||
.iter()
|
||||
.filter_map(|accessor| {
|
||||
// Some accessors might not have been
|
||||
// instantiated. We can safely ignore those.
|
||||
mono_item_placements.get(accessor)
|
||||
})
|
||||
.any(|placement| *placement != home_cgu)
|
||||
{
|
||||
// Found an accessor from another CGU, so skip to the next
|
||||
// item without marking this one as internal.
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
||||
// If we got here, we did not find any accesses from other CGUs,
|
||||
// so it's fine to make this monomorphization internal.
|
||||
*linkage_and_visibility = (Linkage::Internal, Visibility::Default);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn characteristic_def_id_of_mono_item<'tcx>(
|
||||
tcx: TyCtxt<'tcx>,
|
||||
mono_item: MonoItem<'tcx>,
|
||||
) -> Option<DefId> {
|
||||
match mono_item {
|
||||
MonoItem::Fn(instance) => {
|
||||
let def_id = match instance.def {
|
||||
ty::InstanceDef::Item(def) => def.did,
|
||||
ty::InstanceDef::VtableShim(..)
|
||||
| ty::InstanceDef::ReifyShim(..)
|
||||
| ty::InstanceDef::FnPtrShim(..)
|
||||
| ty::InstanceDef::ClosureOnceShim { .. }
|
||||
| ty::InstanceDef::Intrinsic(..)
|
||||
| ty::InstanceDef::DropGlue(..)
|
||||
| ty::InstanceDef::Virtual(..)
|
||||
| ty::InstanceDef::CloneShim(..) => return None,
|
||||
};
|
||||
|
||||
// If this is a method, we want to put it into the same module as
|
||||
// its self-type. If the self-type does not provide a characteristic
|
||||
// DefId, we use the location of the impl after all.
|
||||
|
||||
if tcx.trait_of_item(def_id).is_some() {
|
||||
let self_ty = instance.substs.type_at(0);
|
||||
// This is a default implementation of a trait method.
|
||||
return characteristic_def_id_of_type(self_ty).or(Some(def_id));
|
||||
}
|
||||
|
||||
if let Some(impl_def_id) = tcx.impl_of_method(def_id) {
|
||||
if tcx.sess.opts.incremental.is_some()
|
||||
&& tcx.trait_id_of_impl(impl_def_id) == tcx.lang_items().drop_trait()
|
||||
{
|
||||
// Put `Drop::drop` into the same cgu as `drop_in_place`
|
||||
// since `drop_in_place` is the only thing that can
|
||||
// call it.
|
||||
return None;
|
||||
}
|
||||
// This is a method within an impl, find out what the self-type is:
|
||||
let impl_self_ty = tcx.subst_and_normalize_erasing_regions(
|
||||
instance.substs,
|
||||
ty::ParamEnv::reveal_all(),
|
||||
tcx.type_of(impl_def_id),
|
||||
);
|
||||
if let Some(def_id) = characteristic_def_id_of_type(impl_self_ty) {
|
||||
return Some(def_id);
|
||||
}
|
||||
}
|
||||
|
||||
Some(def_id)
|
||||
}
|
||||
MonoItem::Static(def_id) => Some(def_id),
|
||||
MonoItem::GlobalAsm(item_id) => Some(item_id.def_id.to_def_id()),
|
||||
}
|
||||
}
|
||||
|
||||
fn compute_codegen_unit_name(
|
||||
tcx: TyCtxt<'_>,
|
||||
name_builder: &mut CodegenUnitNameBuilder<'_>,
|
||||
def_id: DefId,
|
||||
volatile: bool,
|
||||
cache: &mut CguNameCache,
|
||||
) -> Symbol {
|
||||
// Find the innermost module that is not nested within a function.
|
||||
let mut current_def_id = def_id;
|
||||
let mut cgu_def_id = None;
|
||||
// Walk backwards from the item we want to find the module for.
|
||||
loop {
|
||||
if current_def_id.index == CRATE_DEF_INDEX {
|
||||
if cgu_def_id.is_none() {
|
||||
// If we have not found a module yet, take the crate root.
|
||||
cgu_def_id = Some(DefId { krate: def_id.krate, index: CRATE_DEF_INDEX });
|
||||
}
|
||||
break;
|
||||
} else if tcx.def_kind(current_def_id) == DefKind::Mod {
|
||||
if cgu_def_id.is_none() {
|
||||
cgu_def_id = Some(current_def_id);
|
||||
}
|
||||
} else {
|
||||
// If we encounter something that is not a module, throw away
|
||||
// any module that we've found so far because we now know that
|
||||
// it is nested within something else.
|
||||
cgu_def_id = None;
|
||||
}
|
||||
|
||||
current_def_id = tcx.parent(current_def_id).unwrap();
|
||||
}
|
||||
|
||||
let cgu_def_id = cgu_def_id.unwrap();
|
||||
|
||||
*cache.entry((cgu_def_id, volatile)).or_insert_with(|| {
|
||||
let def_path = tcx.def_path(cgu_def_id);
|
||||
|
||||
let components = def_path.data.iter().map(|part| match part.data.name() {
|
||||
DefPathDataName::Named(name) => name,
|
||||
DefPathDataName::Anon { .. } => unreachable!(),
|
||||
});
|
||||
|
||||
let volatile_suffix = volatile.then_some("volatile");
|
||||
|
||||
name_builder.build_cgu_name(def_path.krate, components, volatile_suffix)
|
||||
})
|
||||
}
|
||||
|
||||
// Anything we can't find a proper codegen unit for goes into this.
|
||||
fn fallback_cgu_name(name_builder: &mut CodegenUnitNameBuilder<'_>) -> Symbol {
|
||||
name_builder.build_cgu_name(LOCAL_CRATE, &["fallback"], Some("cgu"))
|
||||
}
|
||||
|
||||
fn mono_item_linkage_and_visibility(
|
||||
tcx: TyCtxt<'tcx>,
|
||||
mono_item: &MonoItem<'tcx>,
|
||||
can_be_internalized: &mut bool,
|
||||
export_generics: bool,
|
||||
) -> (Linkage, Visibility) {
|
||||
if let Some(explicit_linkage) = mono_item.explicit_linkage(tcx) {
|
||||
return (explicit_linkage, Visibility::Default);
|
||||
}
|
||||
let vis = mono_item_visibility(tcx, mono_item, can_be_internalized, export_generics);
|
||||
(Linkage::External, vis)
|
||||
}
|
||||
|
||||
type CguNameCache = FxHashMap<(DefId, bool), Symbol>;
|
||||
|
||||
fn mono_item_visibility(
|
||||
tcx: TyCtxt<'tcx>,
|
||||
mono_item: &MonoItem<'tcx>,
|
||||
can_be_internalized: &mut bool,
|
||||
export_generics: bool,
|
||||
) -> Visibility {
|
||||
let instance = match mono_item {
|
||||
// This is pretty complicated; see below.
|
||||
MonoItem::Fn(instance) => instance,
|
||||
|
||||
// Misc handling for generics and such, but otherwise:
|
||||
MonoItem::Static(def_id) => {
|
||||
return if tcx.is_reachable_non_generic(*def_id) {
|
||||
*can_be_internalized = false;
|
||||
default_visibility(tcx, *def_id, false)
|
||||
} else {
|
||||
Visibility::Hidden
|
||||
};
|
||||
}
|
||||
MonoItem::GlobalAsm(item_id) => {
|
||||
return if tcx.is_reachable_non_generic(item_id.def_id) {
|
||||
*can_be_internalized = false;
|
||||
default_visibility(tcx, item_id.def_id.to_def_id(), false)
|
||||
} else {
|
||||
Visibility::Hidden
|
||||
};
|
||||
}
|
||||
};
|
||||
|
||||
let def_id = match instance.def {
|
||||
InstanceDef::Item(def) => def.did,
|
||||
InstanceDef::DropGlue(def_id, Some(_)) => def_id,
|
||||
|
||||
// These are all compiler glue and such, never exported, always hidden.
|
||||
InstanceDef::VtableShim(..)
|
||||
| InstanceDef::ReifyShim(..)
|
||||
| InstanceDef::FnPtrShim(..)
|
||||
| InstanceDef::Virtual(..)
|
||||
| InstanceDef::Intrinsic(..)
|
||||
| InstanceDef::ClosureOnceShim { .. }
|
||||
| InstanceDef::DropGlue(..)
|
||||
| InstanceDef::CloneShim(..) => return Visibility::Hidden,
|
||||
};
|
||||
|
||||
// The `start_fn` lang item is actually a monomorphized instance of a
|
||||
// function in the standard library, used for the `main` function. We don't
|
||||
// want to export it so we tag it with `Hidden` visibility but this symbol
|
||||
// is only referenced from the actual `main` symbol which we unfortunately
|
||||
// don't know anything about during partitioning/collection. As a result we
|
||||
// forcibly keep this symbol out of the `internalization_candidates` set.
|
||||
//
|
||||
// FIXME: eventually we don't want to always force this symbol to have
|
||||
// hidden visibility, it should indeed be a candidate for
|
||||
// internalization, but we have to understand that it's referenced
|
||||
// from the `main` symbol we'll generate later.
|
||||
//
|
||||
// This may be fixable with a new `InstanceDef` perhaps? Unsure!
|
||||
if tcx.lang_items().start_fn() == Some(def_id) {
|
||||
*can_be_internalized = false;
|
||||
return Visibility::Hidden;
|
||||
}
|
||||
|
||||
let is_generic = instance.substs.non_erasable_generics().next().is_some();
|
||||
|
||||
// Upstream `DefId` instances get different handling than local ones.
|
||||
let def_id = if let Some(def_id) = def_id.as_local() {
|
||||
def_id
|
||||
} else {
|
||||
return if export_generics && is_generic {
|
||||
// If it is an upstream monomorphization and we export generics, we must make
|
||||
// it available to downstream crates.
|
||||
*can_be_internalized = false;
|
||||
default_visibility(tcx, def_id, true)
|
||||
} else {
|
||||
Visibility::Hidden
|
||||
};
|
||||
};
|
||||
|
||||
if is_generic {
|
||||
if export_generics {
|
||||
if tcx.is_unreachable_local_definition(def_id) {
|
||||
// This instance cannot be used from another crate.
|
||||
Visibility::Hidden
|
||||
} else {
|
||||
// This instance might be useful in a downstream crate.
|
||||
*can_be_internalized = false;
|
||||
default_visibility(tcx, def_id.to_def_id(), true)
|
||||
}
|
||||
} else {
|
||||
// We are not exporting generics or the definition is not reachable
|
||||
// for downstream crates, we can internalize its instantiations.
|
||||
Visibility::Hidden
|
||||
}
|
||||
} else {
|
||||
// If this isn't a generic function then we mark this a `Default` if
|
||||
// this is a reachable item, meaning that it's a symbol other crates may
|
||||
// access when they link to us.
|
||||
if tcx.is_reachable_non_generic(def_id.to_def_id()) {
|
||||
*can_be_internalized = false;
|
||||
debug_assert!(!is_generic);
|
||||
return default_visibility(tcx, def_id.to_def_id(), false);
|
||||
}
|
||||
|
||||
// If this isn't reachable then we're gonna tag this with `Hidden`
|
||||
// visibility. In some situations though we'll want to prevent this
|
||||
// symbol from being internalized.
|
||||
//
|
||||
// There's two categories of items here:
|
||||
//
|
||||
// * First is weak lang items. These are basically mechanisms for
|
||||
// libcore to forward-reference symbols defined later in crates like
|
||||
// the standard library or `#[panic_handler]` definitions. The
|
||||
// definition of these weak lang items needs to be referenceable by
|
||||
// libcore, so we're no longer a candidate for internalization.
|
||||
// Removal of these functions can't be done by LLVM but rather must be
|
||||
// done by the linker as it's a non-local decision.
|
||||
//
|
||||
// * Second is "std internal symbols". Currently this is primarily used
|
||||
// for allocator symbols. Allocators are a little weird in their
|
||||
// implementation, but the idea is that the compiler, at the last
|
||||
// minute, defines an allocator with an injected object file. The
|
||||
// `alloc` crate references these symbols (`__rust_alloc`) and the
|
||||
// definition doesn't get hooked up until a linked crate artifact is
|
||||
// generated.
|
||||
//
|
||||
// The symbols synthesized by the compiler (`__rust_alloc`) are thin
|
||||
// veneers around the actual implementation, some other symbol which
|
||||
// implements the same ABI. These symbols (things like `__rg_alloc`,
|
||||
// `__rdl_alloc`, `__rde_alloc`, etc), are all tagged with "std
|
||||
// internal symbols".
|
||||
//
|
||||
// The std-internal symbols here **should not show up in a dll as an
|
||||
// exported interface**, so they return `false` from
|
||||
// `is_reachable_non_generic` above and we'll give them `Hidden`
|
||||
// visibility below. Like the weak lang items, though, we can't let
|
||||
// LLVM internalize them as this decision is left up to the linker to
|
||||
// omit them, so prevent them from being internalized.
|
||||
let attrs = tcx.codegen_fn_attrs(def_id);
|
||||
if attrs.flags.contains(CodegenFnAttrFlags::RUSTC_STD_INTERNAL_SYMBOL) {
|
||||
*can_be_internalized = false;
|
||||
}
|
||||
|
||||
Visibility::Hidden
|
||||
}
|
||||
}
|
||||
|
||||
fn default_visibility(tcx: TyCtxt<'_>, id: DefId, is_generic: bool) -> Visibility {
|
||||
if !tcx.sess.target.default_hidden_visibility {
|
||||
return Visibility::Default;
|
||||
}
|
||||
|
||||
// Generic functions never have export-level C.
|
||||
if is_generic {
|
||||
return Visibility::Hidden;
|
||||
}
|
||||
|
||||
// Things with export level C don't get instantiated in
|
||||
// downstream crates.
|
||||
if !id.is_local() {
|
||||
return Visibility::Hidden;
|
||||
}
|
||||
|
||||
// C-export level items remain at `Default`, all other internal
|
||||
// items become `Hidden`.
|
||||
match tcx.reachable_non_generics(id.krate).get(&id) {
|
||||
Some(SymbolExportLevel::C) => Visibility::Default,
|
||||
_ => Visibility::Hidden,
|
||||
}
|
||||
}
|
111
compiler/rustc_monomorphize/src/partitioning/merging.rs
Normal file
111
compiler/rustc_monomorphize/src/partitioning/merging.rs
Normal file
|
@ -0,0 +1,111 @@
|
|||
use std::cmp;
|
||||
|
||||
use rustc_data_structures::fx::FxHashMap;
|
||||
use rustc_hir::def_id::LOCAL_CRATE;
|
||||
use rustc_middle::mir::mono::{CodegenUnit, CodegenUnitNameBuilder};
|
||||
use rustc_span::symbol::{Symbol, SymbolStr};
|
||||
|
||||
use super::PartitioningCx;
|
||||
use crate::partitioning::PreInliningPartitioning;
|
||||
|
||||
pub fn merge_codegen_units<'tcx>(
|
||||
cx: &PartitioningCx<'_, 'tcx>,
|
||||
initial_partitioning: &mut PreInliningPartitioning<'tcx>,
|
||||
) {
|
||||
assert!(cx.target_cgu_count >= 1);
|
||||
let codegen_units = &mut initial_partitioning.codegen_units;
|
||||
|
||||
// Note that at this point in time the `codegen_units` here may not be in a
|
||||
// deterministic order (but we know they're deterministically the same set).
|
||||
// We want this merging to produce a deterministic ordering of codegen units
|
||||
// from the input.
|
||||
//
|
||||
// Due to basically how we've implemented the merging below (merge the two
|
||||
// smallest into each other) we're sure to start off with a deterministic
|
||||
// order (sorted by name). This'll mean that if two cgus have the same size
|
||||
// the stable sort below will keep everything nice and deterministic.
|
||||
codegen_units.sort_by_cached_key(|cgu| cgu.name().as_str());
|
||||
|
||||
// This map keeps track of what got merged into what.
|
||||
let mut cgu_contents: FxHashMap<Symbol, Vec<SymbolStr>> =
|
||||
codegen_units.iter().map(|cgu| (cgu.name(), vec![cgu.name().as_str()])).collect();
|
||||
|
||||
// Merge the two smallest codegen units until the target size is reached.
|
||||
while codegen_units.len() > cx.target_cgu_count {
|
||||
// Sort small cgus to the back
|
||||
codegen_units.sort_by_cached_key(|cgu| cmp::Reverse(cgu.size_estimate()));
|
||||
let mut smallest = codegen_units.pop().unwrap();
|
||||
let second_smallest = codegen_units.last_mut().unwrap();
|
||||
|
||||
// Move the mono-items from `smallest` to `second_smallest`
|
||||
second_smallest.modify_size_estimate(smallest.size_estimate());
|
||||
for (k, v) in smallest.items_mut().drain() {
|
||||
second_smallest.items_mut().insert(k, v);
|
||||
}
|
||||
|
||||
// Record that `second_smallest` now contains all the stuff that was in
|
||||
// `smallest` before.
|
||||
let mut consumed_cgu_names = cgu_contents.remove(&smallest.name()).unwrap();
|
||||
cgu_contents.get_mut(&second_smallest.name()).unwrap().append(&mut consumed_cgu_names);
|
||||
|
||||
debug!(
|
||||
"CodegenUnit {} merged into CodegenUnit {}",
|
||||
smallest.name(),
|
||||
second_smallest.name()
|
||||
);
|
||||
}
|
||||
|
||||
let cgu_name_builder = &mut CodegenUnitNameBuilder::new(cx.tcx);
|
||||
|
||||
if cx.tcx.sess.opts.incremental.is_some() {
|
||||
// If we are doing incremental compilation, we want CGU names to
|
||||
// reflect the path of the source level module they correspond to.
|
||||
// For CGUs that contain the code of multiple modules because of the
|
||||
// merging done above, we use a concatenation of the names of
|
||||
// all contained CGUs.
|
||||
let new_cgu_names: FxHashMap<Symbol, String> = cgu_contents
|
||||
.into_iter()
|
||||
// This `filter` makes sure we only update the name of CGUs that
|
||||
// were actually modified by merging.
|
||||
.filter(|(_, cgu_contents)| cgu_contents.len() > 1)
|
||||
.map(|(current_cgu_name, cgu_contents)| {
|
||||
let mut cgu_contents: Vec<&str> = cgu_contents.iter().map(|s| &s[..]).collect();
|
||||
|
||||
// Sort the names, so things are deterministic and easy to
|
||||
// predict.
|
||||
|
||||
// We are sorting primitive &strs here so we can use unstable sort
|
||||
cgu_contents.sort_unstable();
|
||||
|
||||
(current_cgu_name, cgu_contents.join("--"))
|
||||
})
|
||||
.collect();
|
||||
|
||||
for cgu in codegen_units.iter_mut() {
|
||||
if let Some(new_cgu_name) = new_cgu_names.get(&cgu.name()) {
|
||||
if cx.tcx.sess.opts.debugging_opts.human_readable_cgu_names {
|
||||
cgu.set_name(Symbol::intern(&new_cgu_name));
|
||||
} else {
|
||||
// If we don't require CGU names to be human-readable, we
|
||||
// use a fixed length hash of the composite CGU name
|
||||
// instead.
|
||||
let new_cgu_name = CodegenUnit::mangle_name(&new_cgu_name);
|
||||
cgu.set_name(Symbol::intern(&new_cgu_name));
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
// If we are compiling non-incrementally we just generate simple CGU
|
||||
// names containing an index.
|
||||
for (index, cgu) in codegen_units.iter_mut().enumerate() {
|
||||
cgu.set_name(numbered_codegen_unit_name(cgu_name_builder, index));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn numbered_codegen_unit_name(
|
||||
name_builder: &mut CodegenUnitNameBuilder<'_>,
|
||||
index: usize,
|
||||
) -> Symbol {
|
||||
name_builder.build_cgu_name_no_mangle(LOCAL_CRATE, &["cgu"], Some(index))
|
||||
}
|
466
compiler/rustc_monomorphize/src/partitioning/mod.rs
Normal file
466
compiler/rustc_monomorphize/src/partitioning/mod.rs
Normal file
|
@ -0,0 +1,466 @@
|
|||
//! Partitioning Codegen Units for Incremental Compilation
|
||||
//! ======================================================
|
||||
//!
|
||||
//! The task of this module is to take the complete set of monomorphizations of
|
||||
//! a crate and produce a set of codegen units from it, where a codegen unit
|
||||
//! is a named set of (mono-item, linkage) pairs. That is, this module
|
||||
//! decides which monomorphization appears in which codegen units with which
|
||||
//! linkage. The following paragraphs describe some of the background on the
|
||||
//! partitioning scheme.
|
||||
//!
|
||||
//! The most important opportunity for saving on compilation time with
|
||||
//! incremental compilation is to avoid re-codegenning and re-optimizing code.
|
||||
//! Since the unit of codegen and optimization for LLVM is "modules" or, how
|
||||
//! we call them "codegen units", the particulars of how much time can be saved
|
||||
//! by incremental compilation are tightly linked to how the output program is
|
||||
//! partitioned into these codegen units prior to passing it to LLVM --
|
||||
//! especially because we have to treat codegen units as opaque entities once
|
||||
//! they are created: There is no way for us to incrementally update an existing
|
||||
//! LLVM module and so we have to build any such module from scratch if it was
|
||||
//! affected by some change in the source code.
|
||||
//!
|
||||
//! From that point of view it would make sense to maximize the number of
|
||||
//! codegen units by, for example, putting each function into its own module.
|
||||
//! That way only those modules would have to be re-compiled that were actually
|
||||
//! affected by some change, minimizing the number of functions that could have
|
||||
//! been re-used but just happened to be located in a module that is
|
||||
//! re-compiled.
|
||||
//!
|
||||
//! However, since LLVM optimization does not work across module boundaries,
|
||||
//! using such a highly granular partitioning would lead to very slow runtime
|
||||
//! code since it would effectively prohibit inlining and other inter-procedure
|
||||
//! optimizations. We want to avoid that as much as possible.
|
||||
//!
|
||||
//! Thus we end up with a trade-off: The bigger the codegen units, the better
|
||||
//! LLVM's optimizer can do its work, but also the smaller the compilation time
|
||||
//! reduction we get from incremental compilation.
|
||||
//!
|
||||
//! Ideally, we would create a partitioning such that there are few big codegen
|
||||
//! units with few interdependencies between them. For now though, we use the
|
||||
//! following heuristic to determine the partitioning:
|
||||
//!
|
||||
//! - There are two codegen units for every source-level module:
|
||||
//! - One for "stable", that is non-generic, code
|
||||
//! - One for more "volatile" code, i.e., monomorphized instances of functions
|
||||
//! defined in that module
|
||||
//!
|
||||
//! In order to see why this heuristic makes sense, let's take a look at when a
|
||||
//! codegen unit can get invalidated:
|
||||
//!
|
||||
//! 1. The most straightforward case is when the BODY of a function or global
|
||||
//! changes. Then any codegen unit containing the code for that item has to be
|
||||
//! re-compiled. Note that this includes all codegen units where the function
|
||||
//! has been inlined.
|
||||
//!
|
||||
//! 2. The next case is when the SIGNATURE of a function or global changes. In
|
||||
//! this case, all codegen units containing a REFERENCE to that item have to be
|
||||
//! re-compiled. This is a superset of case 1.
|
||||
//!
|
||||
//! 3. The final and most subtle case is when a REFERENCE to a generic function
|
||||
//! is added or removed somewhere. Even though the definition of the function
|
||||
//! might be unchanged, a new REFERENCE might introduce a new monomorphized
|
||||
//! instance of this function which has to be placed and compiled somewhere.
|
||||
//! Conversely, when removing a REFERENCE, it might have been the last one with
|
||||
//! that particular set of generic arguments and thus we have to remove it.
|
||||
//!
|
||||
//! From the above we see that just using one codegen unit per source-level
|
||||
//! module is not such a good idea, since just adding a REFERENCE to some
|
||||
//! generic item somewhere else would invalidate everything within the module
|
||||
//! containing the generic item. The heuristic above reduces this detrimental
|
||||
//! side-effect of references a little by at least not touching the non-generic
|
||||
//! code of the module.
|
||||
//!
|
||||
//! A Note on Inlining
|
||||
//! ------------------
|
||||
//! As briefly mentioned above, in order for LLVM to be able to inline a
|
||||
//! function call, the body of the function has to be available in the LLVM
|
||||
//! module where the call is made. This has a few consequences for partitioning:
|
||||
//!
|
||||
//! - The partitioning algorithm has to take care of placing functions into all
|
||||
//! codegen units where they should be available for inlining. It also has to
|
||||
//! decide on the correct linkage for these functions.
|
||||
//!
|
||||
//! - The partitioning algorithm has to know which functions are likely to get
|
||||
//! inlined, so it can distribute function instantiations accordingly. Since
|
||||
//! there is no way of knowing for sure which functions LLVM will decide to
|
||||
//! inline in the end, we apply a heuristic here: Only functions marked with
|
||||
//! `#[inline]` are considered for inlining by the partitioner. The current
|
||||
//! implementation will not try to determine if a function is likely to be
|
||||
//! inlined by looking at the functions definition.
|
||||
//!
|
||||
//! Note though that as a side-effect of creating a codegen units per
|
||||
//! source-level module, functions from the same module will be available for
|
||||
//! inlining, even when they are not marked `#[inline]`.
|
||||
|
||||
mod default;
|
||||
mod merging;
|
||||
|
||||
use rustc_data_structures::fx::{FxHashMap, FxHashSet};
|
||||
use rustc_data_structures::sync;
|
||||
use rustc_hir::def_id::DefIdSet;
|
||||
use rustc_middle::mir::mono::MonoItem;
|
||||
use rustc_middle::mir::mono::{CodegenUnit, Linkage};
|
||||
use rustc_middle::ty::print::with_no_trimmed_paths;
|
||||
use rustc_middle::ty::query::Providers;
|
||||
use rustc_middle::ty::TyCtxt;
|
||||
use rustc_span::symbol::Symbol;
|
||||
|
||||
use crate::collector::InliningMap;
|
||||
use crate::collector::{self, MonoItemCollectionMode};
|
||||
|
||||
pub struct PartitioningCx<'a, 'tcx> {
|
||||
tcx: TyCtxt<'tcx>,
|
||||
target_cgu_count: usize,
|
||||
inlining_map: &'a InliningMap<'tcx>,
|
||||
}
|
||||
|
||||
trait Partitioner<'tcx> {
|
||||
fn place_root_mono_items(
|
||||
&mut self,
|
||||
cx: &PartitioningCx<'_, 'tcx>,
|
||||
mono_items: &mut dyn Iterator<Item = MonoItem<'tcx>>,
|
||||
) -> PreInliningPartitioning<'tcx>;
|
||||
|
||||
fn merge_codegen_units(
|
||||
&mut self,
|
||||
cx: &PartitioningCx<'_, 'tcx>,
|
||||
initial_partitioning: &mut PreInliningPartitioning<'tcx>,
|
||||
);
|
||||
|
||||
fn place_inlined_mono_items(
|
||||
&mut self,
|
||||
cx: &PartitioningCx<'_, 'tcx>,
|
||||
initial_partitioning: PreInliningPartitioning<'tcx>,
|
||||
) -> PostInliningPartitioning<'tcx>;
|
||||
|
||||
fn internalize_symbols(
|
||||
&mut self,
|
||||
cx: &PartitioningCx<'_, 'tcx>,
|
||||
partitioning: &mut PostInliningPartitioning<'tcx>,
|
||||
);
|
||||
}
|
||||
|
||||
fn get_partitioner<'tcx>(tcx: TyCtxt<'tcx>) -> Box<dyn Partitioner<'tcx>> {
|
||||
let strategy = match &tcx.sess.opts.debugging_opts.cgu_partitioning_strategy {
|
||||
None => "default",
|
||||
Some(s) => &s[..],
|
||||
};
|
||||
|
||||
match strategy {
|
||||
"default" => Box::new(default::DefaultPartitioning),
|
||||
_ => tcx.sess.fatal("unknown partitioning strategy"),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn partition<'tcx>(
|
||||
tcx: TyCtxt<'tcx>,
|
||||
mono_items: &mut dyn Iterator<Item = MonoItem<'tcx>>,
|
||||
max_cgu_count: usize,
|
||||
inlining_map: &InliningMap<'tcx>,
|
||||
) -> Vec<CodegenUnit<'tcx>> {
|
||||
let _prof_timer = tcx.prof.generic_activity("cgu_partitioning");
|
||||
|
||||
let mut partitioner = get_partitioner(tcx);
|
||||
let cx = &PartitioningCx { tcx, target_cgu_count: max_cgu_count, inlining_map };
|
||||
// In the first step, we place all regular monomorphizations into their
|
||||
// respective 'home' codegen unit. Regular monomorphizations are all
|
||||
// functions and statics defined in the local crate.
|
||||
let mut initial_partitioning = {
|
||||
let _prof_timer = tcx.prof.generic_activity("cgu_partitioning_place_roots");
|
||||
partitioner.place_root_mono_items(cx, mono_items)
|
||||
};
|
||||
|
||||
initial_partitioning.codegen_units.iter_mut().for_each(|cgu| cgu.estimate_size(tcx));
|
||||
|
||||
debug_dump(tcx, "INITIAL PARTITIONING:", initial_partitioning.codegen_units.iter());
|
||||
|
||||
// Merge until we have at most `max_cgu_count` codegen units.
|
||||
{
|
||||
let _prof_timer = tcx.prof.generic_activity("cgu_partitioning_merge_cgus");
|
||||
partitioner.merge_codegen_units(cx, &mut initial_partitioning);
|
||||
debug_dump(tcx, "POST MERGING:", initial_partitioning.codegen_units.iter());
|
||||
}
|
||||
|
||||
// In the next step, we use the inlining map to determine which additional
|
||||
// monomorphizations have to go into each codegen unit. These additional
|
||||
// monomorphizations can be drop-glue, functions from external crates, and
|
||||
// local functions the definition of which is marked with `#[inline]`.
|
||||
let mut post_inlining = {
|
||||
let _prof_timer = tcx.prof.generic_activity("cgu_partitioning_place_inline_items");
|
||||
partitioner.place_inlined_mono_items(cx, initial_partitioning)
|
||||
};
|
||||
|
||||
post_inlining.codegen_units.iter_mut().for_each(|cgu| cgu.estimate_size(tcx));
|
||||
|
||||
debug_dump(tcx, "POST INLINING:", post_inlining.codegen_units.iter());
|
||||
|
||||
// Next we try to make as many symbols "internal" as possible, so LLVM has
|
||||
// more freedom to optimize.
|
||||
if !tcx.sess.link_dead_code() {
|
||||
let _prof_timer = tcx.prof.generic_activity("cgu_partitioning_internalize_symbols");
|
||||
partitioner.internalize_symbols(cx, &mut post_inlining);
|
||||
}
|
||||
|
||||
// Finally, sort by codegen unit name, so that we get deterministic results.
|
||||
let PostInliningPartitioning {
|
||||
codegen_units: mut result,
|
||||
mono_item_placements: _,
|
||||
internalization_candidates: _,
|
||||
} = post_inlining;
|
||||
|
||||
result.sort_by_cached_key(|cgu| cgu.name().as_str());
|
||||
|
||||
result
|
||||
}
|
||||
|
||||
pub struct PreInliningPartitioning<'tcx> {
|
||||
codegen_units: Vec<CodegenUnit<'tcx>>,
|
||||
roots: FxHashSet<MonoItem<'tcx>>,
|
||||
internalization_candidates: FxHashSet<MonoItem<'tcx>>,
|
||||
}
|
||||
|
||||
/// For symbol internalization, we need to know whether a symbol/mono-item is
|
||||
/// accessed from outside the codegen unit it is defined in. This type is used
|
||||
/// to keep track of that.
|
||||
#[derive(Clone, PartialEq, Eq, Debug)]
|
||||
enum MonoItemPlacement {
|
||||
SingleCgu { cgu_name: Symbol },
|
||||
MultipleCgus,
|
||||
}
|
||||
|
||||
struct PostInliningPartitioning<'tcx> {
|
||||
codegen_units: Vec<CodegenUnit<'tcx>>,
|
||||
mono_item_placements: FxHashMap<MonoItem<'tcx>, MonoItemPlacement>,
|
||||
internalization_candidates: FxHashSet<MonoItem<'tcx>>,
|
||||
}
|
||||
|
||||
fn debug_dump<'a, 'tcx, I>(tcx: TyCtxt<'tcx>, label: &str, cgus: I)
|
||||
where
|
||||
I: Iterator<Item = &'a CodegenUnit<'tcx>>,
|
||||
'tcx: 'a,
|
||||
{
|
||||
let dump = move || {
|
||||
use std::fmt::Write;
|
||||
|
||||
let s = &mut String::new();
|
||||
let _ = writeln!(s, "{}", label);
|
||||
for cgu in cgus {
|
||||
let _ =
|
||||
writeln!(s, "CodegenUnit {} estimated size {} :", cgu.name(), cgu.size_estimate());
|
||||
|
||||
for (mono_item, linkage) in cgu.items() {
|
||||
let symbol_name = mono_item.symbol_name(tcx).name;
|
||||
let symbol_hash_start = symbol_name.rfind('h');
|
||||
let symbol_hash = symbol_hash_start.map_or("<no hash>", |i| &symbol_name[i..]);
|
||||
|
||||
let _ = writeln!(
|
||||
s,
|
||||
" - {} [{:?}] [{}] estimated size {}",
|
||||
mono_item,
|
||||
linkage,
|
||||
symbol_hash,
|
||||
mono_item.size_estimate(tcx)
|
||||
);
|
||||
}
|
||||
|
||||
let _ = writeln!(s, "");
|
||||
}
|
||||
|
||||
std::mem::take(s)
|
||||
};
|
||||
|
||||
debug!("{}", dump());
|
||||
}
|
||||
|
||||
#[inline(never)] // give this a place in the profiler
|
||||
fn assert_symbols_are_distinct<'a, 'tcx, I>(tcx: TyCtxt<'tcx>, mono_items: I)
|
||||
where
|
||||
I: Iterator<Item = &'a MonoItem<'tcx>>,
|
||||
'tcx: 'a,
|
||||
{
|
||||
let _prof_timer = tcx.prof.generic_activity("assert_symbols_are_distinct");
|
||||
|
||||
let mut symbols: Vec<_> =
|
||||
mono_items.map(|mono_item| (mono_item, mono_item.symbol_name(tcx))).collect();
|
||||
|
||||
symbols.sort_by_key(|sym| sym.1);
|
||||
|
||||
for &[(mono_item1, ref sym1), (mono_item2, ref sym2)] in symbols.array_windows() {
|
||||
if sym1 == sym2 {
|
||||
let span1 = mono_item1.local_span(tcx);
|
||||
let span2 = mono_item2.local_span(tcx);
|
||||
|
||||
// Deterministically select one of the spans for error reporting
|
||||
let span = match (span1, span2) {
|
||||
(Some(span1), Some(span2)) => {
|
||||
Some(if span1.lo().0 > span2.lo().0 { span1 } else { span2 })
|
||||
}
|
||||
(span1, span2) => span1.or(span2),
|
||||
};
|
||||
|
||||
let error_message = format!("symbol `{}` is already defined", sym1);
|
||||
|
||||
if let Some(span) = span {
|
||||
tcx.sess.span_fatal(span, &error_message)
|
||||
} else {
|
||||
tcx.sess.fatal(&error_message)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn collect_and_partition_mono_items<'tcx>(
|
||||
tcx: TyCtxt<'tcx>,
|
||||
(): (),
|
||||
) -> (&'tcx DefIdSet, &'tcx [CodegenUnit<'tcx>]) {
|
||||
let collection_mode = match tcx.sess.opts.debugging_opts.print_mono_items {
|
||||
Some(ref s) => {
|
||||
let mode_string = s.to_lowercase();
|
||||
let mode_string = mode_string.trim();
|
||||
if mode_string == "eager" {
|
||||
MonoItemCollectionMode::Eager
|
||||
} else {
|
||||
if mode_string != "lazy" {
|
||||
let message = format!(
|
||||
"Unknown codegen-item collection mode '{}'. \
|
||||
Falling back to 'lazy' mode.",
|
||||
mode_string
|
||||
);
|
||||
tcx.sess.warn(&message);
|
||||
}
|
||||
|
||||
MonoItemCollectionMode::Lazy
|
||||
}
|
||||
}
|
||||
None => {
|
||||
if tcx.sess.link_dead_code() {
|
||||
MonoItemCollectionMode::Eager
|
||||
} else {
|
||||
MonoItemCollectionMode::Lazy
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
let (items, inlining_map) = collector::collect_crate_mono_items(tcx, collection_mode);
|
||||
|
||||
tcx.sess.abort_if_errors();
|
||||
|
||||
let (codegen_units, _) = tcx.sess.time("partition_and_assert_distinct_symbols", || {
|
||||
sync::join(
|
||||
|| {
|
||||
let mut codegen_units = partition(
|
||||
tcx,
|
||||
&mut items.iter().cloned(),
|
||||
tcx.sess.codegen_units(),
|
||||
&inlining_map,
|
||||
);
|
||||
codegen_units[0].make_primary();
|
||||
&*tcx.arena.alloc_from_iter(codegen_units)
|
||||
},
|
||||
|| assert_symbols_are_distinct(tcx, items.iter()),
|
||||
)
|
||||
});
|
||||
|
||||
let mono_items: DefIdSet = items
|
||||
.iter()
|
||||
.filter_map(|mono_item| match *mono_item {
|
||||
MonoItem::Fn(ref instance) => Some(instance.def_id()),
|
||||
MonoItem::Static(def_id) => Some(def_id),
|
||||
_ => None,
|
||||
})
|
||||
.collect();
|
||||
|
||||
if tcx.sess.opts.debugging_opts.print_mono_items.is_some() {
|
||||
let mut item_to_cgus: FxHashMap<_, Vec<_>> = Default::default();
|
||||
|
||||
for cgu in codegen_units {
|
||||
for (&mono_item, &linkage) in cgu.items() {
|
||||
item_to_cgus.entry(mono_item).or_default().push((cgu.name(), linkage));
|
||||
}
|
||||
}
|
||||
|
||||
let mut item_keys: Vec<_> = items
|
||||
.iter()
|
||||
.map(|i| {
|
||||
let mut output = with_no_trimmed_paths(|| i.to_string());
|
||||
output.push_str(" @@");
|
||||
let mut empty = Vec::new();
|
||||
let cgus = item_to_cgus.get_mut(i).unwrap_or(&mut empty);
|
||||
cgus.sort_by_key(|(name, _)| *name);
|
||||
cgus.dedup();
|
||||
for &(ref cgu_name, (linkage, _)) in cgus.iter() {
|
||||
output.push(' ');
|
||||
output.push_str(&cgu_name.as_str());
|
||||
|
||||
let linkage_abbrev = match linkage {
|
||||
Linkage::External => "External",
|
||||
Linkage::AvailableExternally => "Available",
|
||||
Linkage::LinkOnceAny => "OnceAny",
|
||||
Linkage::LinkOnceODR => "OnceODR",
|
||||
Linkage::WeakAny => "WeakAny",
|
||||
Linkage::WeakODR => "WeakODR",
|
||||
Linkage::Appending => "Appending",
|
||||
Linkage::Internal => "Internal",
|
||||
Linkage::Private => "Private",
|
||||
Linkage::ExternalWeak => "ExternalWeak",
|
||||
Linkage::Common => "Common",
|
||||
};
|
||||
|
||||
output.push('[');
|
||||
output.push_str(linkage_abbrev);
|
||||
output.push(']');
|
||||
}
|
||||
output
|
||||
})
|
||||
.collect();
|
||||
|
||||
item_keys.sort();
|
||||
|
||||
for item in item_keys {
|
||||
println!("MONO_ITEM {}", item);
|
||||
}
|
||||
}
|
||||
|
||||
(tcx.arena.alloc(mono_items), codegen_units)
|
||||
}
|
||||
|
||||
fn codegened_and_inlined_items<'tcx>(tcx: TyCtxt<'tcx>, (): ()) -> &'tcx DefIdSet {
|
||||
let (items, cgus) = tcx.collect_and_partition_mono_items(());
|
||||
let mut visited = DefIdSet::default();
|
||||
let mut result = items.clone();
|
||||
|
||||
for cgu in cgus {
|
||||
for (item, _) in cgu.items() {
|
||||
if let MonoItem::Fn(ref instance) = item {
|
||||
let did = instance.def_id();
|
||||
if !visited.insert(did) {
|
||||
continue;
|
||||
}
|
||||
for scope in &tcx.instance_mir(instance.def).source_scopes {
|
||||
if let Some((ref inlined, _)) = scope.inlined {
|
||||
result.insert(inlined.def_id());
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
tcx.arena.alloc(result)
|
||||
}
|
||||
|
||||
pub fn provide(providers: &mut Providers) {
|
||||
providers.collect_and_partition_mono_items = collect_and_partition_mono_items;
|
||||
providers.codegened_and_inlined_items = codegened_and_inlined_items;
|
||||
|
||||
providers.is_codegened_item = |tcx, def_id| {
|
||||
let (all_mono_items, _) = tcx.collect_and_partition_mono_items(());
|
||||
all_mono_items.contains(&def_id)
|
||||
};
|
||||
|
||||
providers.codegen_unit = |tcx, name| {
|
||||
let (_, all) = tcx.collect_and_partition_mono_items(());
|
||||
all.iter()
|
||||
.find(|cgu| cgu.name() == name)
|
||||
.unwrap_or_else(|| panic!("failed to find cgu with name {:?}", name))
|
||||
};
|
||||
}
|
399
compiler/rustc_monomorphize/src/polymorphize.rs
Normal file
399
compiler/rustc_monomorphize/src/polymorphize.rs
Normal file
|
@ -0,0 +1,399 @@
|
|||
//! Polymorphization Analysis
|
||||
//! =========================
|
||||
//!
|
||||
//! This module implements an analysis of functions, methods and closures to determine which
|
||||
//! generic parameters are unused (and eventually, in what ways generic parameters are used - only
|
||||
//! for their size, offset of a field, etc.).
|
||||
|
||||
use rustc_hir::{def::DefKind, def_id::DefId, ConstContext};
|
||||
use rustc_index::bit_set::FiniteBitSet;
|
||||
use rustc_middle::mir::{
|
||||
visit::{TyContext, Visitor},
|
||||
Local, LocalDecl, Location,
|
||||
};
|
||||
use rustc_middle::ty::{
|
||||
self,
|
||||
fold::{TypeFoldable, TypeVisitor},
|
||||
query::Providers,
|
||||
subst::SubstsRef,
|
||||
Const, Ty, TyCtxt,
|
||||
};
|
||||
use rustc_span::symbol::sym;
|
||||
use std::convert::TryInto;
|
||||
use std::ops::ControlFlow;
|
||||
|
||||
/// Provide implementations of queries relating to polymorphization analysis.
|
||||
pub fn provide(providers: &mut Providers) {
|
||||
providers.unused_generic_params = unused_generic_params;
|
||||
}
|
||||
|
||||
/// Determine which generic parameters are used by the function/method/closure represented by
|
||||
/// `def_id`. Returns a bitset where bits representing unused parameters are set (`is_empty`
|
||||
/// indicates all parameters are used).
|
||||
#[instrument(skip(tcx))]
|
||||
fn unused_generic_params(tcx: TyCtxt<'_>, def_id: DefId) -> FiniteBitSet<u32> {
|
||||
if !tcx.sess.opts.debugging_opts.polymorphize {
|
||||
// If polymorphization disabled, then all parameters are used.
|
||||
return FiniteBitSet::new_empty();
|
||||
}
|
||||
|
||||
// Polymorphization results are stored in cross-crate metadata only when there are unused
|
||||
// parameters, so assume that non-local items must have only used parameters (else this query
|
||||
// would not be invoked, and the cross-crate metadata used instead).
|
||||
if !def_id.is_local() {
|
||||
return FiniteBitSet::new_empty();
|
||||
}
|
||||
|
||||
let generics = tcx.generics_of(def_id);
|
||||
debug!(?generics);
|
||||
|
||||
// Exit early when there are no parameters to be unused.
|
||||
if generics.count() == 0 {
|
||||
return FiniteBitSet::new_empty();
|
||||
}
|
||||
|
||||
// Exit early when there is no MIR available.
|
||||
let context = tcx.hir().body_const_context(def_id.expect_local());
|
||||
match context {
|
||||
Some(ConstContext::ConstFn) | None if !tcx.is_mir_available(def_id) => {
|
||||
debug!("no mir available");
|
||||
return FiniteBitSet::new_empty();
|
||||
}
|
||||
Some(_) if !tcx.is_ctfe_mir_available(def_id) => {
|
||||
debug!("no ctfe mir available");
|
||||
return FiniteBitSet::new_empty();
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
|
||||
// Create a bitset with N rightmost ones for each parameter.
|
||||
let generics_count: u32 =
|
||||
generics.count().try_into().expect("more generic parameters than can fit into a `u32`");
|
||||
let mut unused_parameters = FiniteBitSet::<u32>::new_empty();
|
||||
unused_parameters.set_range(0..generics_count);
|
||||
debug!(?unused_parameters, "(start)");
|
||||
mark_used_by_default_parameters(tcx, def_id, generics, &mut unused_parameters);
|
||||
debug!(?unused_parameters, "(after default)");
|
||||
|
||||
// Visit MIR and accumululate used generic parameters.
|
||||
let body = match context {
|
||||
// Const functions are actually called and should thus be considered for polymorphization
|
||||
// via their runtime MIR
|
||||
Some(ConstContext::ConstFn) | None => tcx.optimized_mir(def_id),
|
||||
Some(_) => tcx.mir_for_ctfe(def_id),
|
||||
};
|
||||
let mut vis = MarkUsedGenericParams { tcx, def_id, unused_parameters: &mut unused_parameters };
|
||||
vis.visit_body(body);
|
||||
debug!(?unused_parameters, "(after visitor)");
|
||||
|
||||
mark_used_by_predicates(tcx, def_id, &mut unused_parameters);
|
||||
debug!(?unused_parameters, "(end)");
|
||||
|
||||
// Emit errors for debugging and testing if enabled.
|
||||
if !unused_parameters.is_empty() {
|
||||
emit_unused_generic_params_error(tcx, def_id, generics, &unused_parameters);
|
||||
}
|
||||
|
||||
unused_parameters
|
||||
}
|
||||
|
||||
/// Some parameters are considered used-by-default, such as non-generic parameters and the dummy
|
||||
/// generic parameters from closures, this function marks them as used. `leaf_is_closure` should
|
||||
/// be `true` if the item that `unused_generic_params` was invoked on is a closure.
|
||||
#[instrument(skip(tcx, def_id, generics, unused_parameters))]
|
||||
fn mark_used_by_default_parameters<'tcx>(
|
||||
tcx: TyCtxt<'tcx>,
|
||||
def_id: DefId,
|
||||
generics: &'tcx ty::Generics,
|
||||
unused_parameters: &mut FiniteBitSet<u32>,
|
||||
) {
|
||||
match tcx.def_kind(def_id) {
|
||||
DefKind::Closure | DefKind::Generator => {
|
||||
for param in &generics.params {
|
||||
debug!(?param, "(closure/gen)");
|
||||
unused_parameters.clear(param.index);
|
||||
}
|
||||
}
|
||||
DefKind::Mod
|
||||
| DefKind::Struct
|
||||
| DefKind::Union
|
||||
| DefKind::Enum
|
||||
| DefKind::Variant
|
||||
| DefKind::Trait
|
||||
| DefKind::TyAlias
|
||||
| DefKind::ForeignTy
|
||||
| DefKind::TraitAlias
|
||||
| DefKind::AssocTy
|
||||
| DefKind::TyParam
|
||||
| DefKind::Fn
|
||||
| DefKind::Const
|
||||
| DefKind::ConstParam
|
||||
| DefKind::Static
|
||||
| DefKind::Ctor(_, _)
|
||||
| DefKind::AssocFn
|
||||
| DefKind::AssocConst
|
||||
| DefKind::Macro(_)
|
||||
| DefKind::ExternCrate
|
||||
| DefKind::Use
|
||||
| DefKind::ForeignMod
|
||||
| DefKind::AnonConst
|
||||
| DefKind::OpaqueTy
|
||||
| DefKind::Field
|
||||
| DefKind::LifetimeParam
|
||||
| DefKind::GlobalAsm
|
||||
| DefKind::Impl => {
|
||||
for param in &generics.params {
|
||||
debug!(?param, "(other)");
|
||||
if let ty::GenericParamDefKind::Lifetime = param.kind {
|
||||
unused_parameters.clear(param.index);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if let Some(parent) = generics.parent {
|
||||
mark_used_by_default_parameters(tcx, parent, tcx.generics_of(parent), unused_parameters);
|
||||
}
|
||||
}
|
||||
|
||||
/// Search the predicates on used generic parameters for any unused generic parameters, and mark
|
||||
/// those as used.
|
||||
#[instrument(skip(tcx, def_id))]
|
||||
fn mark_used_by_predicates<'tcx>(
|
||||
tcx: TyCtxt<'tcx>,
|
||||
def_id: DefId,
|
||||
unused_parameters: &mut FiniteBitSet<u32>,
|
||||
) {
|
||||
let def_id = tcx.closure_base_def_id(def_id);
|
||||
let predicates = tcx.explicit_predicates_of(def_id);
|
||||
|
||||
let mut current_unused_parameters = FiniteBitSet::new_empty();
|
||||
// Run to a fixed point to support `where T: Trait<U>, U: Trait<V>`, starting with an empty
|
||||
// bit set so that this is skipped if all parameters are already used.
|
||||
while current_unused_parameters != *unused_parameters {
|
||||
debug!(?current_unused_parameters, ?unused_parameters);
|
||||
current_unused_parameters = *unused_parameters;
|
||||
|
||||
for (predicate, _) in predicates.predicates {
|
||||
// Consider all generic params in a predicate as used if any other parameter in the
|
||||
// predicate is used.
|
||||
let any_param_used = {
|
||||
let mut vis = HasUsedGenericParams { tcx, unused_parameters };
|
||||
predicate.visit_with(&mut vis).is_break()
|
||||
};
|
||||
|
||||
if any_param_used {
|
||||
let mut vis = MarkUsedGenericParams { tcx, def_id, unused_parameters };
|
||||
predicate.visit_with(&mut vis);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if let Some(parent) = predicates.parent {
|
||||
mark_used_by_predicates(tcx, parent, unused_parameters);
|
||||
}
|
||||
}
|
||||
|
||||
/// Emit errors for the function annotated by `#[rustc_polymorphize_error]`, labelling each generic
|
||||
/// parameter which was unused.
|
||||
#[instrument(skip(tcx, generics))]
|
||||
fn emit_unused_generic_params_error<'tcx>(
|
||||
tcx: TyCtxt<'tcx>,
|
||||
def_id: DefId,
|
||||
generics: &'tcx ty::Generics,
|
||||
unused_parameters: &FiniteBitSet<u32>,
|
||||
) {
|
||||
let base_def_id = tcx.closure_base_def_id(def_id);
|
||||
if !tcx.get_attrs(base_def_id).iter().any(|a| a.has_name(sym::rustc_polymorphize_error)) {
|
||||
return;
|
||||
}
|
||||
|
||||
let fn_span = match tcx.opt_item_name(def_id) {
|
||||
Some(ident) => ident.span,
|
||||
_ => tcx.def_span(def_id),
|
||||
};
|
||||
|
||||
let mut err = tcx.sess.struct_span_err(fn_span, "item has unused generic parameters");
|
||||
|
||||
let mut next_generics = Some(generics);
|
||||
while let Some(generics) = next_generics {
|
||||
for param in &generics.params {
|
||||
if unused_parameters.contains(param.index).unwrap_or(false) {
|
||||
debug!(?param);
|
||||
let def_span = tcx.def_span(param.def_id);
|
||||
err.span_label(def_span, &format!("generic parameter `{}` is unused", param.name));
|
||||
}
|
||||
}
|
||||
|
||||
next_generics = generics.parent.map(|did| tcx.generics_of(did));
|
||||
}
|
||||
|
||||
err.emit();
|
||||
}
|
||||
|
||||
/// Visitor used to aggregate generic parameter uses.
|
||||
struct MarkUsedGenericParams<'a, 'tcx> {
|
||||
tcx: TyCtxt<'tcx>,
|
||||
def_id: DefId,
|
||||
unused_parameters: &'a mut FiniteBitSet<u32>,
|
||||
}
|
||||
|
||||
impl<'a, 'tcx> MarkUsedGenericParams<'a, 'tcx> {
|
||||
/// Invoke `unused_generic_params` on a body contained within the current item (e.g.
|
||||
/// a closure, generator or constant).
|
||||
#[instrument(skip(self, def_id, substs))]
|
||||
fn visit_child_body(&mut self, def_id: DefId, substs: SubstsRef<'tcx>) {
|
||||
let unused = self.tcx.unused_generic_params(def_id);
|
||||
debug!(?self.unused_parameters, ?unused);
|
||||
for (i, arg) in substs.iter().enumerate() {
|
||||
let i = i.try_into().unwrap();
|
||||
if !unused.contains(i).unwrap_or(false) {
|
||||
arg.visit_with(self);
|
||||
}
|
||||
}
|
||||
debug!(?self.unused_parameters);
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a, 'tcx> Visitor<'tcx> for MarkUsedGenericParams<'a, 'tcx> {
|
||||
#[instrument(skip(self, local))]
|
||||
fn visit_local_decl(&mut self, local: Local, local_decl: &LocalDecl<'tcx>) {
|
||||
if local == Local::from_usize(1) {
|
||||
let def_kind = self.tcx.def_kind(self.def_id);
|
||||
if matches!(def_kind, DefKind::Closure | DefKind::Generator) {
|
||||
// Skip visiting the closure/generator that is currently being processed. This only
|
||||
// happens because the first argument to the closure is a reference to itself and
|
||||
// that will call `visit_substs`, resulting in each generic parameter captured being
|
||||
// considered used by default.
|
||||
debug!("skipping closure substs");
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
self.super_local_decl(local, local_decl);
|
||||
}
|
||||
|
||||
fn visit_const(&mut self, c: &&'tcx Const<'tcx>, _: Location) {
|
||||
c.visit_with(self);
|
||||
}
|
||||
|
||||
fn visit_ty(&mut self, ty: Ty<'tcx>, _: TyContext) {
|
||||
ty.visit_with(self);
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a, 'tcx> TypeVisitor<'tcx> for MarkUsedGenericParams<'a, 'tcx> {
|
||||
fn tcx_for_anon_const_substs(&self) -> Option<TyCtxt<'tcx>> {
|
||||
Some(self.tcx)
|
||||
}
|
||||
#[instrument(skip(self))]
|
||||
fn visit_const(&mut self, c: &'tcx Const<'tcx>) -> ControlFlow<Self::BreakTy> {
|
||||
if !c.potentially_has_param_types_or_consts() {
|
||||
return ControlFlow::CONTINUE;
|
||||
}
|
||||
|
||||
match c.val {
|
||||
ty::ConstKind::Param(param) => {
|
||||
debug!(?param);
|
||||
self.unused_parameters.clear(param.index);
|
||||
ControlFlow::CONTINUE
|
||||
}
|
||||
ty::ConstKind::Unevaluated(ty::Unevaluated { def, substs_: _, promoted: Some(p)})
|
||||
// Avoid considering `T` unused when constants are of the form:
|
||||
// `<Self as Foo<T>>::foo::promoted[p]`
|
||||
if self.def_id == def.did && !self.tcx.generics_of(def.did).has_self =>
|
||||
{
|
||||
// If there is a promoted, don't look at the substs - since it will always contain
|
||||
// the generic parameters, instead, traverse the promoted MIR.
|
||||
let promoted = self.tcx.promoted_mir(def.did);
|
||||
self.visit_body(&promoted[p]);
|
||||
ControlFlow::CONTINUE
|
||||
}
|
||||
ty::ConstKind::Unevaluated(uv)
|
||||
if self.tcx.def_kind(uv.def.did) == DefKind::AnonConst =>
|
||||
{
|
||||
self.visit_child_body(uv.def.did, uv.substs(self.tcx));
|
||||
ControlFlow::CONTINUE
|
||||
}
|
||||
_ => c.super_visit_with(self),
|
||||
}
|
||||
}
|
||||
|
||||
#[instrument(skip(self))]
|
||||
fn visit_ty(&mut self, ty: Ty<'tcx>) -> ControlFlow<Self::BreakTy> {
|
||||
if !ty.potentially_has_param_types_or_consts() {
|
||||
return ControlFlow::CONTINUE;
|
||||
}
|
||||
|
||||
match *ty.kind() {
|
||||
ty::Closure(def_id, substs) | ty::Generator(def_id, substs, ..) => {
|
||||
debug!(?def_id);
|
||||
// Avoid cycle errors with generators.
|
||||
if def_id == self.def_id {
|
||||
return ControlFlow::CONTINUE;
|
||||
}
|
||||
|
||||
// Consider any generic parameters used by any closures/generators as used in the
|
||||
// parent.
|
||||
self.visit_child_body(def_id, substs);
|
||||
ControlFlow::CONTINUE
|
||||
}
|
||||
ty::Param(param) => {
|
||||
debug!(?param);
|
||||
self.unused_parameters.clear(param.index);
|
||||
ControlFlow::CONTINUE
|
||||
}
|
||||
_ => ty.super_visit_with(self),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Visitor used to check if a generic parameter is used.
|
||||
struct HasUsedGenericParams<'a, 'tcx> {
|
||||
tcx: TyCtxt<'tcx>,
|
||||
unused_parameters: &'a FiniteBitSet<u32>,
|
||||
}
|
||||
|
||||
impl<'a, 'tcx> TypeVisitor<'tcx> for HasUsedGenericParams<'a, 'tcx> {
|
||||
type BreakTy = ();
|
||||
|
||||
fn tcx_for_anon_const_substs(&self) -> Option<TyCtxt<'tcx>> {
|
||||
Some(self.tcx)
|
||||
}
|
||||
|
||||
#[instrument(skip(self))]
|
||||
fn visit_const(&mut self, c: &'tcx Const<'tcx>) -> ControlFlow<Self::BreakTy> {
|
||||
if !c.potentially_has_param_types_or_consts() {
|
||||
return ControlFlow::CONTINUE;
|
||||
}
|
||||
|
||||
match c.val {
|
||||
ty::ConstKind::Param(param) => {
|
||||
if self.unused_parameters.contains(param.index).unwrap_or(false) {
|
||||
ControlFlow::CONTINUE
|
||||
} else {
|
||||
ControlFlow::BREAK
|
||||
}
|
||||
}
|
||||
_ => c.super_visit_with(self),
|
||||
}
|
||||
}
|
||||
|
||||
#[instrument(skip(self))]
|
||||
fn visit_ty(&mut self, ty: Ty<'tcx>) -> ControlFlow<Self::BreakTy> {
|
||||
if !ty.potentially_has_param_types_or_consts() {
|
||||
return ControlFlow::CONTINUE;
|
||||
}
|
||||
|
||||
match ty.kind() {
|
||||
ty::Param(param) => {
|
||||
if self.unused_parameters.contains(param.index).unwrap_or(false) {
|
||||
ControlFlow::CONTINUE
|
||||
} else {
|
||||
ControlFlow::BREAK
|
||||
}
|
||||
}
|
||||
_ => ty.super_visit_with(self),
|
||||
}
|
||||
}
|
||||
}
|
73
compiler/rustc_monomorphize/src/util.rs
Normal file
73
compiler/rustc_monomorphize/src/util.rs
Normal file
|
@ -0,0 +1,73 @@
|
|||
use rustc_middle::ty::{self, ClosureSizeProfileData, Instance, TyCtxt};
|
||||
use std::fs::OpenOptions;
|
||||
use std::io::prelude::*;
|
||||
|
||||
/// For a given closure, writes out the data for the profiling the impact of RFC 2229 on
|
||||
/// closure size into a CSV.
|
||||
///
|
||||
/// During the same compile all closures dump the information in the same file
|
||||
/// "closure_profile_XXXXX.csv", which is created in the directory where the compiler is invoked.
|
||||
crate fn dump_closure_profile(tcx: TyCtxt<'tcx>, closure_instance: Instance<'tcx>) {
|
||||
let mut file = if let Ok(file) = OpenOptions::new()
|
||||
.create(true)
|
||||
.append(true)
|
||||
.open(&format!("closure_profile_{}.csv", std::process::id()))
|
||||
{
|
||||
file
|
||||
} else {
|
||||
eprintln!("Cound't open file for writing closure profile");
|
||||
return;
|
||||
};
|
||||
|
||||
let closure_def_id = closure_instance.def_id();
|
||||
let typeck_results = tcx.typeck(closure_def_id.expect_local());
|
||||
|
||||
if typeck_results.closure_size_eval.contains_key(&closure_def_id) {
|
||||
let param_env = ty::ParamEnv::reveal_all();
|
||||
|
||||
let ClosureSizeProfileData { before_feature_tys, after_feature_tys } =
|
||||
typeck_results.closure_size_eval[&closure_def_id];
|
||||
|
||||
let before_feature_tys = tcx.subst_and_normalize_erasing_regions(
|
||||
closure_instance.substs,
|
||||
param_env,
|
||||
before_feature_tys,
|
||||
);
|
||||
let after_feature_tys = tcx.subst_and_normalize_erasing_regions(
|
||||
closure_instance.substs,
|
||||
param_env,
|
||||
after_feature_tys,
|
||||
);
|
||||
|
||||
let new_size = tcx
|
||||
.layout_of(param_env.and(after_feature_tys))
|
||||
.map(|l| format!("{:?}", l.size.bytes()))
|
||||
.unwrap_or_else(|e| format!("Failed {:?}", e));
|
||||
|
||||
let old_size = tcx
|
||||
.layout_of(param_env.and(before_feature_tys))
|
||||
.map(|l| format!("{:?}", l.size.bytes()))
|
||||
.unwrap_or_else(|e| format!("Failed {:?}", e));
|
||||
|
||||
let closure_hir_id = tcx.hir().local_def_id_to_hir_id(closure_def_id.expect_local());
|
||||
let closure_span = tcx.hir().span(closure_hir_id);
|
||||
let src_file = tcx.sess.source_map().span_to_filename(closure_span);
|
||||
let line_nos = tcx
|
||||
.sess
|
||||
.source_map()
|
||||
.span_to_lines(closure_span)
|
||||
.map(|l| format!("{:?} {:?}", l.lines.first(), l.lines.last()))
|
||||
.unwrap_or_else(|e| format!("{:?}", e));
|
||||
|
||||
if let Err(e) = writeln!(
|
||||
file,
|
||||
"{}, {}, {}, {:?}",
|
||||
old_size,
|
||||
new_size,
|
||||
src_file.prefer_local(),
|
||||
line_nos
|
||||
) {
|
||||
eprintln!("Error writting to file {}", e.to_string())
|
||||
}
|
||||
}
|
||||
}
|
Loading…
Add table
Add a link
Reference in a new issue