summaryrefslogtreecommitdiffstats
path: root/compiler/rustc_monomorphize/src
diff options
context:
space:
mode:
Diffstat (limited to 'compiler/rustc_monomorphize/src')
-rw-r--r--compiler/rustc_monomorphize/src/collector.rs248
-rw-r--r--compiler/rustc_monomorphize/src/lib.rs5
-rw-r--r--compiler/rustc_monomorphize/src/partitioning.rs1274
-rw-r--r--compiler/rustc_monomorphize/src/partitioning/default.rs644
-rw-r--r--compiler/rustc_monomorphize/src/partitioning/mod.rs673
-rw-r--r--compiler/rustc_monomorphize/src/util.rs4
6 files changed, 1365 insertions, 1483 deletions
diff --git a/compiler/rustc_monomorphize/src/collector.rs b/compiler/rustc_monomorphize/src/collector.rs
index 35b154b7b..242269e9d 100644
--- a/compiler/rustc_monomorphize/src/collector.rs
+++ b/compiler/rustc_monomorphize/src/collector.rs
@@ -35,15 +35,15 @@
//!
//! - A "mono item" is something that results in a function or global in
//! the LLVM IR of a codegen unit. Mono items do not stand on their
-//! own, they can reference other mono items. For example, if function
+//! own, they can use other mono items. For example, if function
//! `foo()` calls function `bar()` then the mono item for `foo()`
-//! references the mono item for function `bar()`. In general, the
-//! definition for mono item A referencing a mono item B is that
-//! the LLVM artifact produced for A references the LLVM artifact produced
+//! uses the mono item for function `bar()`. In general, the
+//! definition for mono item A using a mono item B is that
+//! the LLVM artifact produced for A uses the LLVM artifact produced
//! for B.
//!
-//! - Mono items and the references between them form a directed graph,
-//! where the mono items are the nodes and references form the edges.
+//! - Mono items and the uses between them form a directed graph,
+//! where the mono items are the nodes and uses form the edges.
//! Let's call this graph the "mono item graph".
//!
//! - The mono item graph for a program contains all mono items
@@ -53,12 +53,11 @@
//! mono item graph for the current crate. It runs in two phases:
//!
//! 1. Discover the roots of the graph by traversing the HIR of the crate.
-//! 2. Starting from the roots, find neighboring nodes by inspecting the MIR
+//! 2. Starting from the roots, find uses by inspecting the MIR
//! representation of the item corresponding to a given node, until no more
//! new nodes are found.
//!
//! ### Discovering roots
-//!
//! The roots of the mono item graph correspond to the public non-generic
//! syntactic items in the source code. We find them by walking the HIR of the
//! crate, and whenever we hit upon a public function, method, or static item,
@@ -69,25 +68,23 @@
//! specified. Functions marked `#[no_mangle]` and functions called by inlinable
//! functions also always act as roots.)
//!
-//! ### Finding neighbor nodes
-//! Given a mono item node, we can discover neighbors by inspecting its
-//! MIR. We walk the MIR and any time we hit upon something that signifies a
-//! reference to another mono item, we have found a neighbor. Since the
-//! mono item we are currently at is always monomorphic, we also know the
-//! concrete type arguments of its neighbors, and so all neighbors again will be
-//! monomorphic. The specific forms a reference to a neighboring node can take
-//! in MIR are quite diverse. Here is an overview:
+//! ### Finding uses
+//! Given a mono item node, we can discover uses by inspecting its MIR. We walk
+//! the MIR to find other mono items used by each mono item. Since the mono
+//! item we are currently at is always monomorphic, we also know the concrete
+//! type arguments of its used mono items. The specific forms a use can take in
+//! MIR are quite diverse. Here is an overview:
//!
//! #### Calling Functions/Methods
-//! The most obvious form of one mono item referencing another is a
+//! The most obvious way for one mono item to use another is a
//! function or method call (represented by a CALL terminator in MIR). But
-//! calls are not the only thing that might introduce a reference between two
+//! calls are not the only thing that might introduce a use between two
//! function mono items, and as we will see below, they are just a
//! specialization of the form described next, and consequently will not get any
//! special treatment in the algorithm.
//!
//! #### Taking a reference to a function or method
-//! A function does not need to actually be called in order to be a neighbor of
+//! A function does not need to actually be called in order to be used by
//! another function. It suffices to just take a reference in order to introduce
//! an edge. Consider the following example:
//!
@@ -109,29 +106,23 @@
//! The MIR of none of these functions will contain an explicit call to
//! `print_val::<i32>`. Nonetheless, in order to mono this program, we need
//! an instance of this function. Thus, whenever we encounter a function or
-//! method in operand position, we treat it as a neighbor of the current
+//! method in operand position, we treat it as a use of the current
//! mono item. Calls are just a special case of that.
//!
//! #### Drop glue
//! Drop glue mono items are introduced by MIR drop-statements. The
-//! generated mono item will again have drop-glue item neighbors if the
+//! generated mono item will have additional drop-glue item uses if the
//! type to be dropped contains nested values that also need to be dropped. It
-//! might also have a function item neighbor for the explicit `Drop::drop`
+//! might also have a function item use for the explicit `Drop::drop`
//! implementation of its type.
//!
//! #### Unsizing Casts
-//! A subtle way of introducing neighbor edges is by casting to a trait object.
+//! A subtle way of introducing use edges is by casting to a trait object.
//! Since the resulting fat-pointer contains a reference to a vtable, we need to
//! instantiate all object-safe methods of the trait, as we need to store
//! pointers to these functions even if they never get called anywhere. This can
//! be seen as a special case of taking a function reference.
//!
-//! #### Boxes
-//! Since `Box` expression have special compiler support, no explicit calls to
-//! `exchange_malloc()` and `box_free()` may show up in MIR, even if the
-//! compiler will generate them. We have to observe `Rvalue::Box` expressions
-//! and Box-typed drop-statements for that purpose.
-//!
//!
//! Interaction with Cross-Crate Inlining
//! -------------------------------------
@@ -151,7 +142,7 @@
//! Mono item collection can be performed in one of two modes:
//!
//! - Lazy mode means that items will only be instantiated when actually
-//! referenced. The goal is to produce the least amount of machine code
+//! used. The goal is to produce the least amount of machine code
//! possible.
//!
//! - Eager mode is meant to be used in conjunction with incremental compilation
@@ -179,14 +170,13 @@ use rustc_hir as hir;
use rustc_hir::def::DefKind;
use rustc_hir::def_id::{DefId, DefIdMap, LocalDefId};
use rustc_hir::lang_items::LangItem;
-use rustc_index::bit_set::GrowableBitSet;
use rustc_middle::mir::interpret::{AllocId, ConstValue};
use rustc_middle::mir::interpret::{ErrorHandled, GlobalAlloc, Scalar};
use rustc_middle::mir::mono::{InstantiationMode, MonoItem};
use rustc_middle::mir::visit::Visitor as MirVisitor;
use rustc_middle::mir::{self, Local, Location};
use rustc_middle::query::TyCtxtAt;
-use rustc_middle::ty::adjustment::{CustomCoerceUnsized, PointerCast};
+use rustc_middle::ty::adjustment::{CustomCoerceUnsized, PointerCoercion};
use rustc_middle::ty::print::with_no_trimmed_paths;
use rustc_middle::ty::subst::{GenericArgKind, InternalSubsts};
use rustc_middle::ty::{
@@ -199,7 +189,6 @@ use rustc_session::lint::builtin::LARGE_ASSIGNMENTS;
use rustc_session::Limit;
use rustc_span::source_map::{dummy_spanned, respan, Span, Spanned, DUMMY_SP};
use rustc_target::abi::Size;
-use std::ops::Range;
use std::path::PathBuf;
use crate::errors::{
@@ -212,114 +201,51 @@ pub enum MonoItemCollectionMode {
Lazy,
}
-/// Maps every mono item to all mono items it references in its
-/// body.
-pub struct InliningMap<'tcx> {
- // Maps a source mono item to the range of mono items
- // accessed by it.
- // The range selects elements within the `targets` vecs.
- index: FxHashMap<MonoItem<'tcx>, Range<usize>>,
- targets: Vec<MonoItem<'tcx>>,
-
- // Contains one bit per mono item in the `targets` field. That bit
- // is true if that mono item needs to be inlined into every CGU.
- inlines: GrowableBitSet<usize>,
-}
-
-/// Struct to store mono items in each collecting and if they should
-/// be inlined. We call `instantiation_mode` to get their inlining
-/// status when inserting new elements, which avoids calling it in
-/// `inlining_map.lock_mut()`. See the `collect_items_rec` implementation
-/// below.
-struct MonoItems<'tcx> {
- // If this is false, we do not need to compute whether items
- // will need to be inlined.
- compute_inlining: bool,
-
- // The TyCtxt used to determine whether the a item should
- // be inlined.
- tcx: TyCtxt<'tcx>,
+pub struct UsageMap<'tcx> {
+ // Maps every mono item to the mono items used by it.
+ used_map: FxHashMap<MonoItem<'tcx>, Vec<MonoItem<'tcx>>>,
- // The collected mono items. The bool field in each element
- // indicates whether this element should be inlined.
- items: Vec<(Spanned<MonoItem<'tcx>>, bool /*inlined*/)>,
+ // Maps every mono item to the mono items that use it.
+ user_map: FxHashMap<MonoItem<'tcx>, Vec<MonoItem<'tcx>>>,
}
-impl<'tcx> MonoItems<'tcx> {
- #[inline]
- fn push(&mut self, item: Spanned<MonoItem<'tcx>>) {
- self.extend([item]);
- }
-
- #[inline]
- fn extend<T: IntoIterator<Item = Spanned<MonoItem<'tcx>>>>(&mut self, iter: T) {
- self.items.extend(iter.into_iter().map(|mono_item| {
- let inlined = if !self.compute_inlining {
- false
- } else {
- mono_item.node.instantiation_mode(self.tcx) == InstantiationMode::LocalCopy
- };
- (mono_item, inlined)
- }))
- }
-}
+type MonoItems<'tcx> = Vec<Spanned<MonoItem<'tcx>>>;
-impl<'tcx> InliningMap<'tcx> {
- fn new() -> InliningMap<'tcx> {
- InliningMap {
- index: FxHashMap::default(),
- targets: Vec::new(),
- inlines: GrowableBitSet::with_capacity(1024),
- }
+impl<'tcx> UsageMap<'tcx> {
+ fn new() -> UsageMap<'tcx> {
+ UsageMap { used_map: FxHashMap::default(), user_map: FxHashMap::default() }
}
- fn record_accesses<'a>(
+ fn record_used<'a>(
&mut self,
- source: MonoItem<'tcx>,
- new_targets: &'a [(Spanned<MonoItem<'tcx>>, bool)],
+ user_item: MonoItem<'tcx>,
+ used_items: &'a [Spanned<MonoItem<'tcx>>],
) where
'tcx: 'a,
{
- let start_index = self.targets.len();
- let new_items_count = new_targets.len();
- let new_items_count_total = new_items_count + self.targets.len();
-
- self.targets.reserve(new_items_count);
- self.inlines.ensure(new_items_count_total);
-
- for (i, (Spanned { node: mono_item, .. }, inlined)) in new_targets.into_iter().enumerate() {
- self.targets.push(*mono_item);
- if *inlined {
- self.inlines.insert(i + start_index);
- }
+ let used_items: Vec<_> = used_items.iter().map(|item| item.node).collect();
+ for &used_item in used_items.iter() {
+ self.user_map.entry(used_item).or_default().push(user_item);
}
- let end_index = self.targets.len();
- assert!(self.index.insert(source, start_index..end_index).is_none());
+ assert!(self.used_map.insert(user_item, used_items).is_none());
}
- /// Internally iterate over all items referenced by `source` which will be
- /// made available for inlining.
- pub fn with_inlining_candidates<F>(&self, source: MonoItem<'tcx>, mut f: F)
- where
- F: FnMut(MonoItem<'tcx>),
- {
- if let Some(range) = self.index.get(&source) {
- for (i, candidate) in self.targets[range.clone()].iter().enumerate() {
- if self.inlines.contains(range.start + i) {
- f(*candidate);
- }
- }
- }
+ pub fn get_user_items(&self, item: MonoItem<'tcx>) -> &[MonoItem<'tcx>] {
+ self.user_map.get(&item).map(|items| items.as_slice()).unwrap_or(&[])
}
- /// Internally iterate over all items and the things each accesses.
- pub fn iter_accesses<F>(&self, mut f: F)
+ /// Internally iterate over all inlined items used by `item`.
+ pub fn for_each_inlined_used_item<F>(&self, tcx: TyCtxt<'tcx>, item: MonoItem<'tcx>, mut f: F)
where
- F: FnMut(MonoItem<'tcx>, &[MonoItem<'tcx>]),
+ F: FnMut(MonoItem<'tcx>),
{
- for (&accessor, range) in &self.index {
- f(accessor, &self.targets[range.clone()])
+ let used_items = self.used_map.get(&item).unwrap();
+ for used_item in used_items.iter() {
+ let is_inlined = used_item.instantiation_mode(tcx) == InstantiationMode::LocalCopy;
+ if is_inlined {
+ f(*used_item);
+ }
}
}
}
@@ -328,7 +254,7 @@ impl<'tcx> InliningMap<'tcx> {
pub fn collect_crate_mono_items(
tcx: TyCtxt<'_>,
mode: MonoItemCollectionMode,
-) -> (FxHashSet<MonoItem<'_>>, InliningMap<'_>) {
+) -> (FxHashSet<MonoItem<'_>>, UsageMap<'_>) {
let _prof_timer = tcx.prof.generic_activity("monomorphization_collector");
let roots =
@@ -337,12 +263,12 @@ pub fn collect_crate_mono_items(
debug!("building mono item graph, beginning at roots");
let mut visited = MTLock::new(FxHashSet::default());
- let mut inlining_map = MTLock::new(InliningMap::new());
+ let mut usage_map = MTLock::new(UsageMap::new());
let recursion_limit = tcx.recursion_limit();
{
let visited: MTLockRef<'_, _> = &mut visited;
- let inlining_map: MTLockRef<'_, _> = &mut inlining_map;
+ let usage_map: MTLockRef<'_, _> = &mut usage_map;
tcx.sess.time("monomorphization_collector_graph_walk", || {
par_for_each_in(roots, |root| {
@@ -353,13 +279,13 @@ pub fn collect_crate_mono_items(
visited,
&mut recursion_depths,
recursion_limit,
- inlining_map,
+ usage_map,
);
});
});
}
- (visited.into_inner(), inlining_map.into_inner())
+ (visited.into_inner(), usage_map.into_inner())
}
// Find all non-generic items by walking the HIR. These items serve as roots to
@@ -367,7 +293,7 @@ pub fn collect_crate_mono_items(
#[instrument(skip(tcx, mode), level = "debug")]
fn collect_roots(tcx: TyCtxt<'_>, mode: MonoItemCollectionMode) -> Vec<MonoItem<'_>> {
debug!("collecting roots");
- let mut roots = MonoItems { compute_inlining: false, tcx, items: Vec::new() };
+ let mut roots = Vec::new();
{
let entry_fn = tcx.entry_fn(());
@@ -393,9 +319,8 @@ fn collect_roots(tcx: TyCtxt<'_>, mode: MonoItemCollectionMode) -> Vec<MonoItem<
// whose predicates hold. Luckily, items that aren't instantiable
// can't actually be used, so we can just skip codegenning them.
roots
- .items
.into_iter()
- .filter_map(|(Spanned { node: mono_item, .. }, _)| {
+ .filter_map(|Spanned { node: mono_item, .. }| {
mono_item.is_instantiable(tcx).then_some(mono_item)
})
.collect()
@@ -403,24 +328,23 @@ fn collect_roots(tcx: TyCtxt<'_>, mode: MonoItemCollectionMode) -> Vec<MonoItem<
/// Collect all monomorphized items reachable from `starting_point`, and emit a note diagnostic if a
/// post-monomorphization error is encountered during a collection step.
-#[instrument(skip(tcx, visited, recursion_depths, recursion_limit, inlining_map), level = "debug")]
+#[instrument(skip(tcx, visited, recursion_depths, recursion_limit, usage_map), level = "debug")]
fn collect_items_rec<'tcx>(
tcx: TyCtxt<'tcx>,
- starting_point: Spanned<MonoItem<'tcx>>,
+ starting_item: Spanned<MonoItem<'tcx>>,
visited: MTLockRef<'_, FxHashSet<MonoItem<'tcx>>>,
recursion_depths: &mut DefIdMap<usize>,
recursion_limit: Limit,
- inlining_map: MTLockRef<'_, InliningMap<'tcx>>,
+ usage_map: MTLockRef<'_, UsageMap<'tcx>>,
) {
- if !visited.lock_mut().insert(starting_point.node) {
+ if !visited.lock_mut().insert(starting_item.node) {
// We've been here already, no need to search again.
return;
}
- let mut neighbors = MonoItems { compute_inlining: true, tcx, items: Vec::new() };
+ let mut used_items = Vec::new();
let recursion_depth_reset;
- //
// Post-monomorphization errors MVP
//
// We can encounter errors while monomorphizing an item, but we don't have a good way of
@@ -446,7 +370,7 @@ fn collect_items_rec<'tcx>(
// FIXME: don't rely on global state, instead bubble up errors. Note: this is very hard to do.
let error_count = tcx.sess.diagnostic().err_count();
- match starting_point.node {
+ match starting_item.node {
MonoItem::Static(def_id) => {
let instance = Instance::mono(tcx, def_id);
@@ -454,19 +378,19 @@ fn collect_items_rec<'tcx>(
debug_assert!(should_codegen_locally(tcx, &instance));
let ty = instance.ty(tcx, ty::ParamEnv::reveal_all());
- visit_drop_use(tcx, ty, true, starting_point.span, &mut neighbors);
+ visit_drop_use(tcx, ty, true, starting_item.span, &mut used_items);
recursion_depth_reset = None;
if let Ok(alloc) = tcx.eval_static_initializer(def_id) {
for &id in alloc.inner().provenance().ptrs().values() {
- collect_miri(tcx, id, &mut neighbors);
+ collect_miri(tcx, id, &mut used_items);
}
}
if tcx.needs_thread_local_shim(def_id) {
- neighbors.push(respan(
- starting_point.span,
+ used_items.push(respan(
+ starting_item.span,
MonoItem::Fn(Instance {
def: InstanceDef::ThreadLocalShim(def_id),
substs: InternalSubsts::empty(),
@@ -482,14 +406,14 @@ fn collect_items_rec<'tcx>(
recursion_depth_reset = Some(check_recursion_limit(
tcx,
instance,
- starting_point.span,
+ starting_item.span,
recursion_depths,
recursion_limit,
));
check_type_length_limit(tcx, instance);
rustc_data_structures::stack::ensure_sufficient_stack(|| {
- collect_neighbours(tcx, instance, &mut neighbors);
+ collect_used_items(tcx, instance, &mut used_items);
});
}
MonoItem::GlobalAsm(item_id) => {
@@ -507,13 +431,13 @@ fn collect_items_rec<'tcx>(
hir::InlineAsmOperand::SymFn { anon_const } => {
let fn_ty =
tcx.typeck_body(anon_const.body).node_type(anon_const.hir_id);
- visit_fn_use(tcx, fn_ty, false, *op_sp, &mut neighbors);
+ visit_fn_use(tcx, fn_ty, false, *op_sp, &mut used_items);
}
hir::InlineAsmOperand::SymStatic { path: _, def_id } => {
let instance = Instance::mono(tcx, *def_id);
if should_codegen_locally(tcx, &instance) {
trace!("collecting static {:?}", def_id);
- neighbors.push(dummy_spanned(MonoItem::Static(*def_id)));
+ used_items.push(dummy_spanned(MonoItem::Static(*def_id)));
}
}
hir::InlineAsmOperand::In { .. }
@@ -533,19 +457,19 @@ fn collect_items_rec<'tcx>(
// Check for PMEs and emit a diagnostic if one happened. To try to show relevant edges of the
// mono item graph.
if tcx.sess.diagnostic().err_count() > error_count
- && starting_point.node.is_generic_fn()
- && starting_point.node.is_user_defined()
+ && starting_item.node.is_generic_fn()
+ && starting_item.node.is_user_defined()
{
- let formatted_item = with_no_trimmed_paths!(starting_point.node.to_string());
+ let formatted_item = with_no_trimmed_paths!(starting_item.node.to_string());
tcx.sess.emit_note(EncounteredErrorWhileInstantiating {
- span: starting_point.span,
+ span: starting_item.span,
formatted_item,
});
}
- inlining_map.lock_mut().record_accesses(starting_point.node, &neighbors.items);
+ usage_map.lock_mut().record_used(starting_item.node, &used_items);
- for (neighbour, _) in neighbors.items {
- collect_items_rec(tcx, neighbour, visited, recursion_depths, recursion_limit, inlining_map);
+ for used_item in used_items {
+ collect_items_rec(tcx, used_item, visited, recursion_depths, recursion_limit, usage_map);
}
if let Some((def_id, depth)) = recursion_depth_reset {
@@ -661,14 +585,14 @@ fn check_type_length_limit<'tcx>(tcx: TyCtxt<'tcx>, instance: Instance<'tcx>) {
}
}
-struct MirNeighborCollector<'a, 'tcx> {
+struct MirUsedCollector<'a, 'tcx> {
tcx: TyCtxt<'tcx>,
body: &'a mir::Body<'tcx>,
output: &'a mut MonoItems<'tcx>,
instance: Instance<'tcx>,
}
-impl<'a, 'tcx> MirNeighborCollector<'a, 'tcx> {
+impl<'a, 'tcx> MirUsedCollector<'a, 'tcx> {
pub fn monomorphize<T>(&self, value: T) -> T
where
T: TypeFoldable<TyCtxt<'tcx>>,
@@ -677,12 +601,12 @@ impl<'a, 'tcx> MirNeighborCollector<'a, 'tcx> {
self.instance.subst_mir_and_normalize_erasing_regions(
self.tcx,
ty::ParamEnv::reveal_all(),
- ty::EarlyBinder(value),
+ ty::EarlyBinder::bind(value),
)
}
}
-impl<'a, 'tcx> MirVisitor<'tcx> for MirNeighborCollector<'a, 'tcx> {
+impl<'a, 'tcx> MirVisitor<'tcx> for MirUsedCollector<'a, 'tcx> {
fn visit_rvalue(&mut self, rvalue: &mir::Rvalue<'tcx>, location: Location) {
debug!("visiting rvalue {:?}", *rvalue);
@@ -693,7 +617,7 @@ 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::Pointer(PointerCast::Unsize),
+ mir::CastKind::PointerCoercion(PointerCoercion::Unsize),
ref operand,
target_ty,
)
@@ -719,7 +643,7 @@ impl<'a, 'tcx> MirVisitor<'tcx> for MirNeighborCollector<'a, 'tcx> {
}
}
mir::Rvalue::Cast(
- mir::CastKind::Pointer(PointerCast::ReifyFnPointer),
+ mir::CastKind::PointerCoercion(PointerCoercion::ReifyFnPointer),
ref operand,
_,
) => {
@@ -728,7 +652,7 @@ impl<'a, 'tcx> MirVisitor<'tcx> for MirNeighborCollector<'a, 'tcx> {
visit_fn_use(self.tcx, fn_ty, false, span, &mut self.output);
}
mir::Rvalue::Cast(
- mir::CastKind::Pointer(PointerCast::ClosureFnPointer(_)),
+ mir::CastKind::PointerCoercion(PointerCoercion::ClosureFnPointer(_)),
ref operand,
_,
) => {
@@ -1442,13 +1366,13 @@ fn collect_miri<'tcx>(tcx: TyCtxt<'tcx>, alloc_id: AllocId, output: &mut MonoIte
/// Scans the MIR in order to find function calls, closures, and drop-glue.
#[instrument(skip(tcx, output), level = "debug")]
-fn collect_neighbours<'tcx>(
+fn collect_used_items<'tcx>(
tcx: TyCtxt<'tcx>,
instance: Instance<'tcx>,
output: &mut MonoItems<'tcx>,
) {
let body = tcx.instance_mir(instance.def);
- MirNeighborCollector { tcx, body: &body, output, instance }.visit_body(&body);
+ MirUsedCollector { tcx, body: &body, output, instance }.visit_body(&body);
}
#[instrument(skip(tcx, output), level = "debug")]
diff --git a/compiler/rustc_monomorphize/src/lib.rs b/compiler/rustc_monomorphize/src/lib.rs
index ecc50c3f6..5f05020ac 100644
--- a/compiler/rustc_monomorphize/src/lib.rs
+++ b/compiler/rustc_monomorphize/src/lib.rs
@@ -1,4 +1,5 @@
#![feature(array_windows)]
+#![feature(is_sorted)]
#![recursion_limit = "256"]
#![allow(rustc::potential_query_instability)]
#![deny(rustc::untranslatable_diagnostic)]
@@ -30,12 +31,12 @@ fn custom_coerce_unsize_info<'tcx>(
source_ty: Ty<'tcx>,
target_ty: Ty<'tcx>,
) -> CustomCoerceUnsized {
- let trait_ref = ty::Binder::dummy(ty::TraitRef::from_lang_item(
+ let trait_ref = ty::TraitRef::from_lang_item(
tcx.tcx,
LangItem::CoerceUnsized,
tcx.span,
[source_ty, target_ty],
- ));
+ );
match tcx.codegen_select_candidate((ty::ParamEnv::reveal_all(), trait_ref)) {
Ok(traits::ImplSource::UserDefined(traits::ImplSourceUserDefinedData {
diff --git a/compiler/rustc_monomorphize/src/partitioning.rs b/compiler/rustc_monomorphize/src/partitioning.rs
new file mode 100644
index 000000000..da76cf223
--- /dev/null
+++ b/compiler/rustc_monomorphize/src/partitioning.rs
@@ -0,0 +1,1274 @@
+//! 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]`.
+
+use std::cmp;
+use std::collections::hash_map::Entry;
+use std::fs::{self, File};
+use std::io::{BufWriter, Write};
+use std::path::{Path, PathBuf};
+
+use rustc_data_structures::fx::{FxHashMap, FxHashSet};
+use rustc_data_structures::sync;
+use rustc_hir::def::DefKind;
+use rustc_hir::def_id::{DefId, DefIdSet, LOCAL_CRATE};
+use rustc_hir::definitions::DefPathDataName;
+use rustc_middle::middle::codegen_fn_attrs::CodegenFnAttrFlags;
+use rustc_middle::middle::exported_symbols::{SymbolExportInfo, SymbolExportLevel};
+use rustc_middle::mir;
+use rustc_middle::mir::mono::{
+ CodegenUnit, CodegenUnitNameBuilder, InstantiationMode, Linkage, MonoItem, Visibility,
+};
+use rustc_middle::query::Providers;
+use rustc_middle::ty::print::{characteristic_def_id_of_type, with_no_trimmed_paths};
+use rustc_middle::ty::{self, visit::TypeVisitableExt, InstanceDef, TyCtxt};
+use rustc_session::config::{DumpMonoStatsFormat, SwitchWithOptPath};
+use rustc_session::CodegenUnits;
+use rustc_span::symbol::Symbol;
+
+use crate::collector::UsageMap;
+use crate::collector::{self, MonoItemCollectionMode};
+use crate::errors::{CouldntDumpMonoStats, SymbolAlreadyDefined, UnknownCguCollectionMode};
+
+struct PartitioningCx<'a, 'tcx> {
+ tcx: TyCtxt<'tcx>,
+ usage_map: &'a UsageMap<'tcx>,
+}
+
+struct PlacedMonoItems<'tcx> {
+ /// The codegen units, sorted by name to make things deterministic.
+ codegen_units: Vec<CodegenUnit<'tcx>>,
+
+ internalization_candidates: FxHashSet<MonoItem<'tcx>>,
+
+ /// These must be obtained when the iterator in `partition` runs. They
+ /// can't be obtained later because some inlined functions might not be
+ /// reachable.
+ unique_inlined_stats: (usize, usize),
+}
+
+// The output CGUs are sorted by name.
+fn partition<'tcx, I>(
+ tcx: TyCtxt<'tcx>,
+ mono_items: I,
+ usage_map: &UsageMap<'tcx>,
+) -> Vec<CodegenUnit<'tcx>>
+where
+ I: Iterator<Item = MonoItem<'tcx>>,
+{
+ let _prof_timer = tcx.prof.generic_activity("cgu_partitioning");
+
+ let cx = &PartitioningCx { tcx, usage_map };
+
+ // Place all mono items into a codegen unit. `place_mono_items` is
+ // responsible for initializing the CGU size estimates.
+ let PlacedMonoItems { mut codegen_units, internalization_candidates, unique_inlined_stats } = {
+ let _prof_timer = tcx.prof.generic_activity("cgu_partitioning_place_items");
+ let placed = place_mono_items(cx, mono_items);
+
+ debug_dump(tcx, "PLACE", &placed.codegen_units, placed.unique_inlined_stats);
+
+ placed
+ };
+
+ // Merge until we have at most `max_cgu_count` codegen units.
+ // `merge_codegen_units` is responsible for updating the CGU size
+ // estimates.
+ {
+ let _prof_timer = tcx.prof.generic_activity("cgu_partitioning_merge_cgus");
+ merge_codegen_units(cx, &mut codegen_units);
+ debug_dump(tcx, "MERGE", &codegen_units, unique_inlined_stats);
+ }
+
+ // 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");
+ internalize_symbols(cx, &mut codegen_units, internalization_candidates);
+
+ debug_dump(tcx, "INTERNALIZE", &codegen_units, unique_inlined_stats);
+ }
+
+ // Mark one CGU for dead code, if necessary.
+ let instrument_dead_code =
+ tcx.sess.instrument_coverage() && !tcx.sess.instrument_coverage_except_unused_functions();
+ if instrument_dead_code {
+ mark_code_coverage_dead_code_cgu(&mut codegen_units);
+ }
+
+ // Ensure CGUs are sorted by name, so that we get deterministic results.
+ if !codegen_units.is_sorted_by(|a, b| Some(a.name().as_str().cmp(b.name().as_str()))) {
+ let mut names = String::new();
+ for cgu in codegen_units.iter() {
+ names += &format!("- {}\n", cgu.name());
+ }
+ bug!("unsorted CGUs:\n{names}");
+ }
+
+ codegen_units
+}
+
+fn place_mono_items<'tcx, I>(cx: &PartitioningCx<'_, 'tcx>, mono_items: I) -> PlacedMonoItems<'tcx>
+where
+ I: Iterator<Item = MonoItem<'tcx>>,
+{
+ 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();
+
+ let mut num_unique_inlined_items = 0;
+ let mut unique_inlined_items_size = 0;
+ for mono_item in mono_items {
+ // Handle only root items directly here. Inlined items are handled at
+ // the bottom of the loop based on reachability.
+ match mono_item.instantiation_mode(cx.tcx) {
+ InstantiationMode::GloballyShared { .. } => {}
+ InstantiationMode::LocalCopy => {
+ num_unique_inlined_items += 1;
+ unique_inlined_items_size += mono_item.size_estimate(cx.tcx);
+ 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 cgu_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 cgu = codegen_units.entry(cgu_name).or_insert_with(|| CodegenUnit::new(cgu_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);
+ }
+
+ cgu.items_mut().insert(mono_item, (linkage, visibility));
+
+ // Get all inlined items that are reachable from `mono_item` without
+ // going via another root item. This includes drop-glue, functions from
+ // external crates, and local functions the definition of which is
+ // marked with `#[inline]`.
+ let mut reachable_inlined_items = FxHashSet::default();
+ get_reachable_inlined_items(cx.tcx, mono_item, cx.usage_map, &mut reachable_inlined_items);
+
+ // Add those inlined items. It's possible an inlined item is reachable
+ // from multiple root items within a CGU, which is fine, it just means
+ // the `insert` will be a no-op.
+ for inlined_item in reachable_inlined_items {
+ // This is a CGU-private copy.
+ cgu.items_mut().insert(inlined_item, (Linkage::Internal, Visibility::Default));
+ }
+ }
+
+ // 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 cgu_name = fallback_cgu_name(cgu_name_builder);
+ codegen_units.insert(cgu_name, CodegenUnit::new(cgu_name));
+ }
+
+ let mut codegen_units: Vec<_> = codegen_units.into_values().collect();
+ codegen_units.sort_by(|a, b| a.name().as_str().cmp(b.name().as_str()));
+
+ for cgu in codegen_units.iter_mut() {
+ cgu.compute_size_estimate(cx.tcx);
+ }
+
+ return PlacedMonoItems {
+ codegen_units,
+ internalization_candidates,
+ unique_inlined_stats: (num_unique_inlined_items, unique_inlined_items_size),
+ };
+
+ fn get_reachable_inlined_items<'tcx>(
+ tcx: TyCtxt<'tcx>,
+ item: MonoItem<'tcx>,
+ usage_map: &UsageMap<'tcx>,
+ visited: &mut FxHashSet<MonoItem<'tcx>>,
+ ) {
+ usage_map.for_each_inlined_used_item(tcx, item, |inlined_item| {
+ let is_new = visited.insert(inlined_item);
+ if is_new {
+ get_reachable_inlined_items(tcx, inlined_item, usage_map, visited);
+ }
+ });
+ }
+}
+
+// This function requires the CGUs to be sorted by name on input, and ensures
+// they are sorted by name on return, for deterministic behaviour.
+fn merge_codegen_units<'tcx>(
+ cx: &PartitioningCx<'_, 'tcx>,
+ codegen_units: &mut Vec<CodegenUnit<'tcx>>,
+) {
+ assert!(cx.tcx.sess.codegen_units().as_usize() >= 1);
+
+ // A sorted order here ensures merging is deterministic.
+ assert!(codegen_units.is_sorted_by(|a, b| Some(a.name().as_str().cmp(b.name().as_str()))));
+
+ // This map keeps track of what got merged into what.
+ let mut cgu_contents: FxHashMap<Symbol, Vec<Symbol>> =
+ codegen_units.iter().map(|cgu| (cgu.name(), vec![cgu.name()])).collect();
+
+ // Having multiple CGUs can drastically speed up compilation. But for
+ // non-incremental builds, tiny CGUs slow down compilation *and* result in
+ // worse generated code. So we don't allow CGUs smaller than this (unless
+ // there is just one CGU, of course). Note that CGU sizes of 100,000+ are
+ // common in larger programs, so this isn't all that large.
+ const NON_INCR_MIN_CGU_SIZE: usize = 1800;
+
+ // Repeatedly merge the two smallest codegen units as long as:
+ // - we have more CGUs than the upper limit, or
+ // - (Non-incremental builds only) the user didn't specify a CGU count, and
+ // there are multiple CGUs, and some are below the minimum size.
+ //
+ // The "didn't specify a CGU count" condition is because when an explicit
+ // count is requested we observe it as closely as possible. For example,
+ // the `compiler_builtins` crate sets `codegen-units = 10000` and it's
+ // critical they aren't merged. Also, some tests use explicit small values
+ // and likewise won't work if small CGUs are merged.
+ while codegen_units.len() > cx.tcx.sess.codegen_units().as_usize()
+ || (cx.tcx.sess.opts.incremental.is_none()
+ && matches!(cx.tcx.sess.codegen_units(), CodegenUnits::Default(_))
+ && codegen_units.len() > 1
+ && codegen_units.iter().any(|cgu| cgu.size_estimate() < NON_INCR_MIN_CGU_SIZE))
+ {
+ // 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 items from `smallest` to `second_smallest`. Some of them
+ // may be duplicate inlined items, in which case the destination CGU is
+ // unaffected. Recalculate size estimates afterwards.
+ second_smallest.items_mut().extend(smallest.items_mut().drain());
+ second_smallest.compute_size_estimate(cx.tcx);
+
+ // 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);
+
+ // Rename the newly merged CGUs.
+ 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.as_str()).collect();
+
+ // Sort the names, so things are deterministic and easy to
+ // predict. We are sorting primitive `&str`s 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.unstable_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));
+ }
+ }
+ }
+
+ // A sorted order here ensures what follows can be deterministic.
+ codegen_units.sort_by(|a, b| a.name().as_str().cmp(b.name().as_str()));
+ } else {
+ // When compiling non-incrementally, we rename the CGUS so they have
+ // identical names except for the numeric suffix, something like
+ // `regex.f10ba03eb5ec7975-cgu.N`, where `N` varies.
+ //
+ // It is useful for debugging and profiling purposes if the resulting
+ // CGUs are sorted by name *and* reverse sorted by size. (CGU 0 is the
+ // biggest, CGU 1 is the second biggest, etc.)
+ //
+ // So first we reverse sort by size. Then we generate the names with
+ // zero-padded suffixes, which means they are automatically sorted by
+ // names. The numeric suffix width depends on the number of CGUs, which
+ // is always greater than zero:
+ // - [1,9] CGUs: `0`, `1`, `2`, ...
+ // - [10,99] CGUs: `00`, `01`, `02`, ...
+ // - [100,999] CGUs: `000`, `001`, `002`, ...
+ // - etc.
+ //
+ // If we didn't zero-pad the sorted-by-name order would be `XYZ-cgu.0`,
+ // `XYZ-cgu.1`, `XYZ-cgu.10`, `XYZ-cgu.11`, ..., `XYZ-cgu.2`, etc.
+ codegen_units.sort_by_key(|cgu| cmp::Reverse(cgu.size_estimate()));
+ let num_digits = codegen_units.len().ilog10() as usize + 1;
+ for (index, cgu) in codegen_units.iter_mut().enumerate() {
+ // Note: `WorkItem::short_description` depends on this name ending
+ // with `-cgu.` followed by a numeric suffix. Please keep it in
+ // sync with this code.
+ let suffix = format!("{index:0num_digits$}");
+ let numbered_codegen_unit_name =
+ cgu_name_builder.build_cgu_name_no_mangle(LOCAL_CRATE, &["cgu"], Some(suffix));
+ cgu.set_name(numbered_codegen_unit_name);
+ }
+ }
+}
+
+fn internalize_symbols<'tcx>(
+ cx: &PartitioningCx<'_, 'tcx>,
+ codegen_units: &mut [CodegenUnit<'tcx>],
+ internalization_candidates: FxHashSet<MonoItem<'tcx>>,
+) {
+ /// For symbol internalization, we need to know whether a symbol/mono-item
+ /// is used 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(Symbol),
+ MultipleCgus,
+ }
+
+ let mut mono_item_placements = FxHashMap::default();
+ let single_codegen_unit = codegen_units.len() == 1;
+
+ if !single_codegen_unit {
+ for cgu in codegen_units.iter() {
+ for item in cgu.items().keys() {
+ // 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(*item) {
+ Entry::Occupied(e) => {
+ let placement = e.into_mut();
+ debug_assert!(match *placement {
+ MonoItemPlacement::SingleCgu(cgu_name) => cgu_name != cgu.name(),
+ MonoItemPlacement::MultipleCgus => true,
+ });
+ *placement = MonoItemPlacement::MultipleCgus;
+ }
+ Entry::Vacant(e) => {
+ e.insert(MonoItemPlacement::SingleCgu(cgu.name()));
+ }
+ }
+ }
+ }
+ }
+
+ // For each internalization candidates in each codegen unit, check if it is
+ // used from outside its defining codegen unit.
+ for cgu in codegen_units {
+ let home_cgu = MonoItemPlacement::SingleCgu(cgu.name());
+
+ for (item, linkage_and_visibility) in cgu.items_mut() {
+ if !internalization_candidates.contains(item) {
+ // This item is no candidate for internalizing, so skip it.
+ continue;
+ }
+
+ if !single_codegen_unit {
+ debug_assert_eq!(mono_item_placements[item], home_cgu);
+
+ if cx
+ .usage_map
+ .get_user_items(*item)
+ .iter()
+ .filter_map(|user_item| {
+ // Some user mono items might not have been
+ // instantiated. We can safely ignore those.
+ mono_item_placements.get(user_item)
+ })
+ .any(|placement| *placement != home_cgu)
+ {
+ // Found a user 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 uses from other CGUs, so
+ // it's fine to make this monomorphization internal.
+ *linkage_and_visibility = (Linkage::Internal, Visibility::Default);
+ }
+ }
+}
+
+fn mark_code_coverage_dead_code_cgu<'tcx>(codegen_units: &mut [CodegenUnit<'tcx>]) {
+ assert!(!codegen_units.is_empty());
+
+ // Find the smallest CGU that has exported symbols and put the dead
+ // function stubs in that CGU. We look for exported symbols to increase
+ // the likelihood the linker won't throw away the dead functions.
+ // FIXME(#92165): In order to truly resolve this, we need to make sure
+ // the object file (CGU) containing the dead function stubs is included
+ // in the final binary. This will probably require forcing these
+ // function symbols to be included via `-u` or `/include` linker args.
+ let dead_code_cgu = codegen_units
+ .iter_mut()
+ .filter(|cgu| cgu.items().iter().any(|(_, (linkage, _))| *linkage == Linkage::External))
+ .min_by_key(|cgu| cgu.size_estimate());
+
+ // If there are no CGUs that have externally linked items, then we just
+ // pick the first CGU as a fallback.
+ let dead_code_cgu = if let Some(cgu) = dead_code_cgu { cgu } else { &mut codegen_units[0] };
+
+ dead_code_cgu.make_code_coverage_dead_code_cgu();
+}
+
+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,
+ ty::InstanceDef::VTableShim(..)
+ | ty::InstanceDef::ReifyShim(..)
+ | ty::InstanceDef::FnPtrShim(..)
+ | ty::InstanceDef::ClosureOnceShim { .. }
+ | ty::InstanceDef::Intrinsic(..)
+ | ty::InstanceDef::DropGlue(..)
+ | ty::InstanceDef::Virtual(..)
+ | ty::InstanceDef::CloneShim(..)
+ | ty::InstanceDef::ThreadLocalShim(..)
+ | ty::InstanceDef::FnPtrAddrShim(..) => 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;
+ }
+
+ // When polymorphization is enabled, methods which do not depend on their generic
+ // parameters, but the self-type of their impl block do will fail to normalize.
+ if !tcx.sess.opts.unstable_opts.polymorphize || !instance.has_param() {
+ // 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.owner_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.is_crate_root() {
+ if cgu_def_id.is_none() {
+ // If we have not found a module yet, take the crate root.
+ cgu_def_id = Some(def_id.krate.as_def_id());
+ }
+ 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);
+ }
+
+ 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>(
+ 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 static_visibility<'tcx>(
+ tcx: TyCtxt<'tcx>,
+ can_be_internalized: &mut bool,
+ def_id: DefId,
+) -> Visibility {
+ if tcx.is_reachable_non_generic(def_id) {
+ *can_be_internalized = false;
+ default_visibility(tcx, def_id, false)
+ } else {
+ Visibility::Hidden
+ }
+}
+
+fn mono_item_visibility<'tcx>(
+ 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 static_visibility(tcx, can_be_internalized, *def_id),
+ MonoItem::GlobalAsm(item_id) => {
+ return static_visibility(tcx, can_be_internalized, item_id.owner_id.to_def_id());
+ }
+ };
+
+ let def_id = match instance.def {
+ InstanceDef::Item(def_id) | InstanceDef::DropGlue(def_id, Some(_)) => def_id,
+
+ // We match the visibility of statics here
+ InstanceDef::ThreadLocalShim(def_id) => {
+ return static_visibility(tcx, can_be_internalized, 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(..)
+ | InstanceDef::FnPtrAddrShim(..) => 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 Some(def_id) = def_id.as_local() 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
+ // use 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 referencable 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(SymbolExportInfo { level: SymbolExportLevel::C, .. }) => Visibility::Default,
+ _ => Visibility::Hidden,
+ }
+}
+
+fn debug_dump<'a, 'tcx: 'a>(
+ tcx: TyCtxt<'tcx>,
+ label: &str,
+ cgus: &[CodegenUnit<'tcx>],
+ (unique_inlined_items, unique_inlined_size): (usize, usize),
+) {
+ let dump = move || {
+ use std::fmt::Write;
+
+ let mut num_cgus = 0;
+ let mut all_cgu_sizes = Vec::new();
+
+ // Note: every unique root item is placed exactly once, so the number
+ // of unique root items always equals the number of placed root items.
+
+ let mut root_items = 0;
+ // unique_inlined_items is passed in above.
+ let mut placed_inlined_items = 0;
+
+ let mut root_size = 0;
+ // unique_inlined_size is passed in above.
+ let mut placed_inlined_size = 0;
+
+ for cgu in cgus.iter() {
+ num_cgus += 1;
+ all_cgu_sizes.push(cgu.size_estimate());
+
+ for (item, _) in cgu.items() {
+ match item.instantiation_mode(tcx) {
+ InstantiationMode::GloballyShared { .. } => {
+ root_items += 1;
+ root_size += item.size_estimate(tcx);
+ }
+ InstantiationMode::LocalCopy => {
+ placed_inlined_items += 1;
+ placed_inlined_size += item.size_estimate(tcx);
+ }
+ }
+ }
+ }
+
+ all_cgu_sizes.sort_unstable_by_key(|&n| cmp::Reverse(n));
+
+ let unique_items = root_items + unique_inlined_items;
+ let placed_items = root_items + placed_inlined_items;
+ let items_ratio = placed_items as f64 / unique_items as f64;
+
+ let unique_size = root_size + unique_inlined_size;
+ let placed_size = root_size + placed_inlined_size;
+ let size_ratio = placed_size as f64 / unique_size as f64;
+
+ let mean_cgu_size = placed_size as f64 / num_cgus as f64;
+
+ assert_eq!(placed_size, all_cgu_sizes.iter().sum::<usize>());
+
+ let s = &mut String::new();
+ let _ = writeln!(s, "{label}");
+ let _ = writeln!(
+ s,
+ "- unique items: {unique_items} ({root_items} root + {unique_inlined_items} inlined), \
+ unique size: {unique_size} ({root_size} root + {unique_inlined_size} inlined)\n\
+ - placed items: {placed_items} ({root_items} root + {placed_inlined_items} inlined), \
+ placed size: {placed_size} ({root_size} root + {placed_inlined_size} inlined)\n\
+ - placed/unique items ratio: {items_ratio:.2}, \
+ placed/unique size ratio: {size_ratio:.2}\n\
+ - CGUs: {num_cgus}, mean size: {mean_cgu_size:.1}, sizes: {}",
+ list(&all_cgu_sizes),
+ );
+ let _ = writeln!(s);
+
+ for (i, cgu) in cgus.iter().enumerate() {
+ let name = cgu.name();
+ let size = cgu.size_estimate();
+ let num_items = cgu.items().len();
+ let mean_size = size as f64 / num_items as f64;
+
+ let mut placed_item_sizes: Vec<_> =
+ cgu.items().iter().map(|(item, _)| item.size_estimate(tcx)).collect();
+ placed_item_sizes.sort_unstable_by_key(|&n| cmp::Reverse(n));
+ let sizes = list(&placed_item_sizes);
+
+ let _ = writeln!(s, "- CGU[{i}]");
+ let _ = writeln!(s, " - {name}, size: {size}");
+ let _ =
+ writeln!(s, " - items: {num_items}, mean size: {mean_size:.1}, sizes: {sizes}",);
+
+ for (item, linkage) in cgu.items_in_deterministic_order(tcx) {
+ let symbol_name = 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 size = item.size_estimate(tcx);
+ let kind = match item.instantiation_mode(tcx) {
+ InstantiationMode::GloballyShared { .. } => "root",
+ InstantiationMode::LocalCopy => "inlined",
+ };
+ let _ = with_no_trimmed_paths!(writeln!(
+ s,
+ " - {item} [{linkage:?}] [{symbol_hash}] ({kind}, size: {size})"
+ ));
+ }
+
+ let _ = writeln!(s);
+ }
+
+ return std::mem::take(s);
+
+ // Converts a slice to a string, capturing repetitions to save space.
+ // E.g. `[4, 4, 4, 3, 2, 1, 1, 1, 1, 1]` -> "[4 (x3), 3, 2, 1 (x5)]".
+ fn list(ns: &[usize]) -> String {
+ let mut v = Vec::new();
+ if ns.is_empty() {
+ return "[]".to_string();
+ }
+
+ let mut elem = |curr, curr_count| {
+ if curr_count == 1 {
+ v.push(format!("{curr}"));
+ } else {
+ v.push(format!("{curr} (x{curr_count})"));
+ }
+ };
+
+ let mut curr = ns[0];
+ let mut curr_count = 1;
+
+ for &n in &ns[1..] {
+ if n != curr {
+ elem(curr, curr_count);
+ curr = n;
+ curr_count = 1;
+ } else {
+ curr_count += 1;
+ }
+ }
+ elem(curr, curr_count);
+
+ let mut s = "[".to_string();
+ s.push_str(&v.join(", "));
+ s.push_str("]");
+ 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),
+ };
+
+ tcx.sess.emit_fatal(SymbolAlreadyDefined { span, symbol: sym1.to_string() });
+ }
+ }
+}
+
+fn collect_and_partition_mono_items(tcx: TyCtxt<'_>, (): ()) -> (&DefIdSet, &[CodegenUnit<'_>]) {
+ let collection_mode = match tcx.sess.opts.unstable_opts.print_mono_items {
+ Some(ref s) => {
+ let mode = s.to_lowercase();
+ let mode = mode.trim();
+ if mode == "eager" {
+ MonoItemCollectionMode::Eager
+ } else {
+ if mode != "lazy" {
+ tcx.sess.emit_warning(UnknownCguCollectionMode { mode });
+ }
+
+ MonoItemCollectionMode::Lazy
+ }
+ }
+ None => {
+ if tcx.sess.link_dead_code() {
+ MonoItemCollectionMode::Eager
+ } else {
+ MonoItemCollectionMode::Lazy
+ }
+ }
+ };
+
+ let (items, usage_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, items.iter().copied(), &usage_map);
+ codegen_units[0].make_primary();
+ &*tcx.arena.alloc_from_iter(codegen_units)
+ },
+ || assert_symbols_are_distinct(tcx, items.iter()),
+ )
+ });
+
+ if tcx.prof.enabled() {
+ // Record CGU size estimates for self-profiling.
+ for cgu in codegen_units {
+ tcx.prof.artifact_size(
+ "codegen_unit_size_estimate",
+ cgu.name().as_str(),
+ cgu.size_estimate() as u64,
+ );
+ }
+ }
+
+ 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();
+
+ // Output monomorphization stats per def_id
+ if let SwitchWithOptPath::Enabled(ref path) = tcx.sess.opts.unstable_opts.dump_mono_stats {
+ if let Err(err) =
+ dump_mono_items_stats(tcx, &codegen_units, path, tcx.crate_name(LOCAL_CRATE))
+ {
+ tcx.sess.emit_fatal(CouldntDumpMonoStats { error: err.to_string() });
+ }
+ }
+
+ if tcx.sess.opts.unstable_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)
+}
+
+/// Outputs stats about instantiation counts and estimated size, per `MonoItem`'s
+/// def, to a file in the given output directory.
+fn dump_mono_items_stats<'tcx>(
+ tcx: TyCtxt<'tcx>,
+ codegen_units: &[CodegenUnit<'tcx>],
+ output_directory: &Option<PathBuf>,
+ crate_name: Symbol,
+) -> Result<(), Box<dyn std::error::Error>> {
+ let output_directory = if let Some(ref directory) = output_directory {
+ fs::create_dir_all(directory)?;
+ directory
+ } else {
+ Path::new(".")
+ };
+
+ let format = tcx.sess.opts.unstable_opts.dump_mono_stats_format;
+ let ext = format.extension();
+ let filename = format!("{crate_name}.mono_items.{ext}");
+ let output_path = output_directory.join(&filename);
+ let file = File::create(&output_path)?;
+ let mut file = BufWriter::new(file);
+
+ // Gather instantiated mono items grouped by def_id
+ let mut items_per_def_id: FxHashMap<_, Vec<_>> = Default::default();
+ for cgu in codegen_units {
+ for (&mono_item, _) in cgu.items() {
+ // Avoid variable-sized compiler-generated shims
+ if mono_item.is_user_defined() {
+ items_per_def_id.entry(mono_item.def_id()).or_default().push(mono_item);
+ }
+ }
+ }
+
+ #[derive(serde::Serialize)]
+ struct MonoItem {
+ name: String,
+ instantiation_count: usize,
+ size_estimate: usize,
+ total_estimate: usize,
+ }
+
+ // Output stats sorted by total instantiated size, from heaviest to lightest
+ let mut stats: Vec<_> = items_per_def_id
+ .into_iter()
+ .map(|(def_id, items)| {
+ let name = with_no_trimmed_paths!(tcx.def_path_str(def_id));
+ let instantiation_count = items.len();
+ let size_estimate = items[0].size_estimate(tcx);
+ let total_estimate = instantiation_count * size_estimate;
+ MonoItem { name, instantiation_count, size_estimate, total_estimate }
+ })
+ .collect();
+ stats.sort_unstable_by_key(|item| cmp::Reverse(item.total_estimate));
+
+ if !stats.is_empty() {
+ match format {
+ DumpMonoStatsFormat::Json => serde_json::to_writer(file, &stats)?,
+ DumpMonoStatsFormat::Markdown => {
+ writeln!(
+ file,
+ "| Item | Instantiation count | Estimated Cost Per Instantiation | Total Estimated Cost |"
+ )?;
+ writeln!(file, "| --- | ---: | ---: | ---: |")?;
+
+ for MonoItem { name, instantiation_count, size_estimate, total_estimate } in stats {
+ writeln!(
+ file,
+ "| `{name}` | {instantiation_count} | {size_estimate} | {total_estimate} |"
+ )?;
+ }
+ }
+ }
+ }
+
+ Ok(())
+}
+
+fn codegened_and_inlined_items(tcx: TyCtxt<'_>, (): ()) -> &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;
+ }
+ let body = tcx.instance_mir(instance.def);
+ for block in body.basic_blocks.iter() {
+ for statement in &block.statements {
+ let mir::StatementKind::Coverage(_) = statement.kind else { continue };
+ let scope = statement.source_info.scope;
+ if let Some(inlined) = scope.inlined_instance(&body.source_scopes) {
+ 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:?}"))
+ };
+}
diff --git a/compiler/rustc_monomorphize/src/partitioning/default.rs b/compiler/rustc_monomorphize/src/partitioning/default.rs
deleted file mode 100644
index 603b3ddc1..000000000
--- a/compiler/rustc_monomorphize/src/partitioning/default.rs
+++ /dev/null
@@ -1,644 +0,0 @@
-use std::cmp;
-use std::collections::hash_map::Entry;
-
-use rustc_data_structures::fx::{FxHashMap, FxHashSet};
-use rustc_hir::def::DefKind;
-use rustc_hir::def_id::{DefId, LOCAL_CRATE};
-use rustc_hir::definitions::DefPathDataName;
-use rustc_middle::middle::codegen_fn_attrs::CodegenFnAttrFlags;
-use rustc_middle::middle::exported_symbols::{SymbolExportInfo, 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, visit::TypeVisitableExt, InstanceDef, TyCtxt};
-use rustc_span::symbol::Symbol;
-
-use super::PartitioningCx;
-use crate::collector::InliningMap;
-use crate::partitioning::{MonoItemPlacement, Partition, PlacedRootMonoItems};
-
-pub struct DefaultPartitioning;
-
-impl<'tcx> Partition<'tcx> for DefaultPartitioning {
- fn place_root_mono_items<I>(
- &mut self,
- cx: &PartitioningCx<'_, 'tcx>,
- mono_items: &mut I,
- ) -> PlacedRootMonoItems<'tcx>
- where
- I: Iterator<Item = MonoItem<'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));
- }
-
- let codegen_units = codegen_units.into_values().collect();
- PlacedRootMonoItems { codegen_units, roots, internalization_candidates }
- }
-
- fn merge_codegen_units(
- &mut self,
- cx: &PartitioningCx<'_, 'tcx>,
- codegen_units: &mut Vec<CodegenUnit<'tcx>>,
- ) {
- assert!(cx.target_cgu_count >= 1);
-
- // 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(|a, b| a.name().as_str().cmp(b.name().as_str()));
-
- // This map keeps track of what got merged into what.
- let mut cgu_contents: FxHashMap<Symbol, Vec<Symbol>> =
- codegen_units.iter().map(|cgu| (cgu.name(), vec![cgu.name()])).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.as_str()).collect();
-
- // Sort the names, so things are deterministic and easy to
- // predict. We are sorting primitive `&str`s 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.unstable_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() {
- let numbered_codegen_unit_name =
- cgu_name_builder.build_cgu_name_no_mangle(LOCAL_CRATE, &["cgu"], Some(index));
- cgu.set_name(numbered_codegen_unit_name);
- }
- }
- }
-
- fn place_inlined_mono_items(
- &mut self,
- cx: &PartitioningCx<'_, 'tcx>,
- codegen_units: &mut [CodegenUnit<'tcx>],
- roots: FxHashSet<MonoItem<'tcx>>,
- ) -> FxHashMap<MonoItem<'tcx>, MonoItemPlacement> {
- let mut mono_item_placements = FxHashMap::default();
-
- let single_codegen_unit = codegen_units.len() == 1;
-
- for old_codegen_unit in codegen_units.iter_mut() {
- // 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(),
- });
- }
- }
- }
- }
-
- *old_codegen_unit = new_codegen_unit;
- }
-
- return mono_item_placements;
-
- 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>,
- codegen_units: &mut [CodegenUnit<'tcx>],
- mono_item_placements: FxHashMap<MonoItem<'tcx>, MonoItemPlacement>,
- internalization_candidates: FxHashSet<MonoItem<'tcx>>,
- ) {
- if 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 codegen_units {
- for candidate in &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);
- }
- });
-
- // For each internalization candidates in each codegen unit, check if it is
- // accessed from outside its defining codegen unit.
- for cgu in codegen_units {
- let home_cgu = MonoItemPlacement::SingleCgu { cgu_name: cgu.name() };
-
- for (accessee, linkage_and_visibility) in cgu.items_mut() {
- if !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,
- ty::InstanceDef::VTableShim(..)
- | ty::InstanceDef::ReifyShim(..)
- | ty::InstanceDef::FnPtrShim(..)
- | ty::InstanceDef::ClosureOnceShim { .. }
- | ty::InstanceDef::Intrinsic(..)
- | ty::InstanceDef::DropGlue(..)
- | ty::InstanceDef::Virtual(..)
- | ty::InstanceDef::CloneShim(..)
- | ty::InstanceDef::ThreadLocalShim(..)
- | ty::InstanceDef::FnPtrAddrShim(..) => 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;
- }
-
- // When polymorphization is enabled, methods which do not depend on their generic
- // parameters, but the self-type of their impl block do will fail to normalize.
- if !tcx.sess.opts.unstable_opts.polymorphize || !instance.has_param() {
- // 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.owner_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.is_crate_root() {
- if cgu_def_id.is_none() {
- // If we have not found a module yet, take the crate root.
- cgu_def_id = Some(def_id.krate.as_def_id());
- }
- 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);
- }
-
- 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>(
- 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 static_visibility<'tcx>(
- tcx: TyCtxt<'tcx>,
- can_be_internalized: &mut bool,
- def_id: DefId,
-) -> Visibility {
- if tcx.is_reachable_non_generic(def_id) {
- *can_be_internalized = false;
- default_visibility(tcx, def_id, false)
- } else {
- Visibility::Hidden
- }
-}
-
-fn mono_item_visibility<'tcx>(
- 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 static_visibility(tcx, can_be_internalized, *def_id),
- MonoItem::GlobalAsm(item_id) => {
- return static_visibility(tcx, can_be_internalized, item_id.owner_id.to_def_id());
- }
- };
-
- let def_id = match instance.def {
- InstanceDef::Item(def_id) | InstanceDef::DropGlue(def_id, Some(_)) => def_id,
-
- // We match the visibility of statics here
- InstanceDef::ThreadLocalShim(def_id) => {
- return static_visibility(tcx, can_be_internalized, 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(..)
- | InstanceDef::FnPtrAddrShim(..) => 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 Some(def_id) = def_id.as_local() 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 referencable 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(SymbolExportInfo { level: SymbolExportLevel::C, .. }) => Visibility::Default,
- _ => Visibility::Hidden,
- }
-}
diff --git a/compiler/rustc_monomorphize/src/partitioning/mod.rs b/compiler/rustc_monomorphize/src/partitioning/mod.rs
deleted file mode 100644
index d0b23ca9e..000000000
--- a/compiler/rustc_monomorphize/src/partitioning/mod.rs
+++ /dev/null
@@ -1,673 +0,0 @@
-//! 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;
-
-use std::cmp;
-use std::fs::{self, File};
-use std::io::{BufWriter, Write};
-use std::path::{Path, PathBuf};
-
-use rustc_data_structures::fx::{FxHashMap, FxHashSet};
-use rustc_data_structures::sync;
-use rustc_hir::def_id::{DefIdSet, LOCAL_CRATE};
-use rustc_middle::mir;
-use rustc_middle::mir::mono::MonoItem;
-use rustc_middle::mir::mono::{CodegenUnit, Linkage};
-use rustc_middle::query::Providers;
-use rustc_middle::ty::print::with_no_trimmed_paths;
-use rustc_middle::ty::TyCtxt;
-use rustc_session::config::{DumpMonoStatsFormat, SwitchWithOptPath};
-use rustc_span::symbol::Symbol;
-
-use crate::collector::InliningMap;
-use crate::collector::{self, MonoItemCollectionMode};
-use crate::errors::{
- CouldntDumpMonoStats, SymbolAlreadyDefined, UnknownCguCollectionMode, UnknownPartitionStrategy,
-};
-
-enum Partitioner {
- Default(default::DefaultPartitioning),
- // Other partitioning strategies can go here.
- Unknown,
-}
-
-impl<'tcx> Partition<'tcx> for Partitioner {
- fn place_root_mono_items<I>(
- &mut self,
- cx: &PartitioningCx<'_, 'tcx>,
- mono_items: &mut I,
- ) -> PlacedRootMonoItems<'tcx>
- where
- I: Iterator<Item = MonoItem<'tcx>>,
- {
- match self {
- Partitioner::Default(partitioner) => partitioner.place_root_mono_items(cx, mono_items),
- Partitioner::Unknown => cx.tcx.sess.emit_fatal(UnknownPartitionStrategy),
- }
- }
-
- fn merge_codegen_units(
- &mut self,
- cx: &PartitioningCx<'_, 'tcx>,
- codegen_units: &mut Vec<CodegenUnit<'tcx>>,
- ) {
- match self {
- Partitioner::Default(partitioner) => partitioner.merge_codegen_units(cx, codegen_units),
- Partitioner::Unknown => cx.tcx.sess.emit_fatal(UnknownPartitionStrategy),
- }
- }
-
- fn place_inlined_mono_items(
- &mut self,
- cx: &PartitioningCx<'_, 'tcx>,
- codegen_units: &mut [CodegenUnit<'tcx>],
- roots: FxHashSet<MonoItem<'tcx>>,
- ) -> FxHashMap<MonoItem<'tcx>, MonoItemPlacement> {
- match self {
- Partitioner::Default(partitioner) => {
- partitioner.place_inlined_mono_items(cx, codegen_units, roots)
- }
- Partitioner::Unknown => cx.tcx.sess.emit_fatal(UnknownPartitionStrategy),
- }
- }
-
- fn internalize_symbols(
- &mut self,
- cx: &PartitioningCx<'_, 'tcx>,
- codegen_units: &mut [CodegenUnit<'tcx>],
- mono_item_placements: FxHashMap<MonoItem<'tcx>, MonoItemPlacement>,
- internalization_candidates: FxHashSet<MonoItem<'tcx>>,
- ) {
- match self {
- Partitioner::Default(partitioner) => partitioner.internalize_symbols(
- cx,
- codegen_units,
- mono_item_placements,
- internalization_candidates,
- ),
- Partitioner::Unknown => cx.tcx.sess.emit_fatal(UnknownPartitionStrategy),
- }
- }
-}
-
-struct PartitioningCx<'a, 'tcx> {
- tcx: TyCtxt<'tcx>,
- target_cgu_count: usize,
- inlining_map: &'a InliningMap<'tcx>,
-}
-
-pub struct PlacedRootMonoItems<'tcx> {
- codegen_units: Vec<CodegenUnit<'tcx>>,
- roots: FxHashSet<MonoItem<'tcx>>,
- internalization_candidates: FxHashSet<MonoItem<'tcx>>,
-}
-
-trait Partition<'tcx> {
- fn place_root_mono_items<I>(
- &mut self,
- cx: &PartitioningCx<'_, 'tcx>,
- mono_items: &mut I,
- ) -> PlacedRootMonoItems<'tcx>
- where
- I: Iterator<Item = MonoItem<'tcx>>;
-
- fn merge_codegen_units(
- &mut self,
- cx: &PartitioningCx<'_, 'tcx>,
- codegen_units: &mut Vec<CodegenUnit<'tcx>>,
- );
-
- fn place_inlined_mono_items(
- &mut self,
- cx: &PartitioningCx<'_, 'tcx>,
- codegen_units: &mut [CodegenUnit<'tcx>],
- roots: FxHashSet<MonoItem<'tcx>>,
- ) -> FxHashMap<MonoItem<'tcx>, MonoItemPlacement>;
-
- fn internalize_symbols(
- &mut self,
- cx: &PartitioningCx<'_, 'tcx>,
- codegen_units: &mut [CodegenUnit<'tcx>],
- mono_item_placements: FxHashMap<MonoItem<'tcx>, MonoItemPlacement>,
- internalization_candidates: FxHashSet<MonoItem<'tcx>>,
- );
-}
-
-fn get_partitioner(tcx: TyCtxt<'_>) -> Partitioner {
- let strategy = match &tcx.sess.opts.unstable_opts.cgu_partitioning_strategy {
- None => "default",
- Some(s) => &s[..],
- };
-
- match strategy {
- "default" => Partitioner::Default(default::DefaultPartitioning),
- _ => Partitioner::Unknown,
- }
-}
-
-fn partition<'tcx, I>(
- tcx: TyCtxt<'tcx>,
- mono_items: &mut I,
- max_cgu_count: usize,
- inlining_map: &InliningMap<'tcx>,
-) -> Vec<CodegenUnit<'tcx>>
-where
- I: Iterator<Item = MonoItem<'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 PlacedRootMonoItems { mut codegen_units, roots, internalization_candidates } = {
- let _prof_timer = tcx.prof.generic_activity("cgu_partitioning_place_roots");
- partitioner.place_root_mono_items(cx, mono_items)
- };
-
- for cgu in &mut codegen_units {
- cgu.create_size_estimate(tcx);
- }
-
- debug_dump(tcx, "INITIAL PARTITIONING", &codegen_units);
-
- // Merge until we have at most `max_cgu_count` codegen units.
- // `merge_codegen_units` is responsible for updating the CGU size
- // estimates.
- {
- let _prof_timer = tcx.prof.generic_activity("cgu_partitioning_merge_cgus");
- partitioner.merge_codegen_units(cx, &mut codegen_units);
- debug_dump(tcx, "POST MERGING", &codegen_units);
- }
-
- // 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 mono_item_placements = {
- let _prof_timer = tcx.prof.generic_activity("cgu_partitioning_place_inline_items");
- partitioner.place_inlined_mono_items(cx, &mut codegen_units, roots)
- };
-
- for cgu in &mut codegen_units {
- cgu.create_size_estimate(tcx);
- }
-
- debug_dump(tcx, "POST INLINING", &codegen_units);
-
- // 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 codegen_units,
- mono_item_placements,
- internalization_candidates,
- );
- }
-
- let instrument_dead_code =
- tcx.sess.instrument_coverage() && !tcx.sess.instrument_coverage_except_unused_functions();
-
- if instrument_dead_code {
- assert!(
- codegen_units.len() > 0,
- "There must be at least one CGU that code coverage data can be generated in."
- );
-
- // Find the smallest CGU that has exported symbols and put the dead
- // function stubs in that CGU. We look for exported symbols to increase
- // the likelihood the linker won't throw away the dead functions.
- // FIXME(#92165): In order to truly resolve this, we need to make sure
- // the object file (CGU) containing the dead function stubs is included
- // in the final binary. This will probably require forcing these
- // function symbols to be included via `-u` or `/include` linker args.
- let mut cgus: Vec<_> = codegen_units.iter_mut().collect();
- cgus.sort_by_key(|cgu| cgu.size_estimate());
-
- let dead_code_cgu =
- if let Some(cgu) = cgus.into_iter().rev().find(|cgu| {
- cgu.items().iter().any(|(_, (linkage, _))| *linkage == Linkage::External)
- }) {
- cgu
- } else {
- // If there are no CGUs that have externally linked items,
- // then we just pick the first CGU as a fallback.
- &mut codegen_units[0]
- };
- dead_code_cgu.make_code_coverage_dead_code_cgu();
- }
-
- // Finally, sort by codegen unit name, so that we get deterministic results.
- codegen_units.sort_by(|a, b| a.name().as_str().cmp(b.name().as_str()));
-
- debug_dump(tcx, "FINAL", &codegen_units);
-
- codegen_units
-}
-
-/// 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,
-}
-
-fn debug_dump<'a, 'tcx: 'a>(tcx: TyCtxt<'tcx>, label: &str, cgus: &[CodegenUnit<'tcx>]) {
- let dump = move || {
- use std::fmt::Write;
-
- let num_cgus = cgus.len();
- let max = cgus.iter().map(|cgu| cgu.size_estimate()).max().unwrap();
- let min = cgus.iter().map(|cgu| cgu.size_estimate()).min().unwrap();
- let ratio = max as f64 / min as f64;
-
- let s = &mut String::new();
- let _ = writeln!(
- s,
- "{label} ({num_cgus} CodegenUnits, max={max}, min={min}, max/min={ratio:.1}):"
- );
- 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 _ = with_no_trimmed_paths!(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),
- };
-
- tcx.sess.emit_fatal(SymbolAlreadyDefined { span, symbol: sym1.to_string() });
- }
- }
-}
-
-fn collect_and_partition_mono_items(tcx: TyCtxt<'_>, (): ()) -> (&DefIdSet, &[CodegenUnit<'_>]) {
- let collection_mode = match tcx.sess.opts.unstable_opts.print_mono_items {
- Some(ref s) => {
- let mode = s.to_lowercase();
- let mode = mode.trim();
- if mode == "eager" {
- MonoItemCollectionMode::Eager
- } else {
- if mode != "lazy" {
- tcx.sess.emit_warning(UnknownCguCollectionMode { mode });
- }
-
- 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().copied(),
- 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()),
- )
- });
-
- if tcx.prof.enabled() {
- // Record CGU size estimates for self-profiling.
- for cgu in codegen_units {
- tcx.prof.artifact_size(
- "codegen_unit_size_estimate",
- cgu.name().as_str(),
- cgu.size_estimate() as u64,
- );
- }
- }
-
- 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();
-
- // Output monomorphization stats per def_id
- if let SwitchWithOptPath::Enabled(ref path) = tcx.sess.opts.unstable_opts.dump_mono_stats {
- if let Err(err) =
- dump_mono_items_stats(tcx, &codegen_units, path, tcx.crate_name(LOCAL_CRATE))
- {
- tcx.sess.emit_fatal(CouldntDumpMonoStats { error: err.to_string() });
- }
- }
-
- if tcx.sess.opts.unstable_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)
-}
-
-/// Outputs stats about instantiation counts and estimated size, per `MonoItem`'s
-/// def, to a file in the given output directory.
-fn dump_mono_items_stats<'tcx>(
- tcx: TyCtxt<'tcx>,
- codegen_units: &[CodegenUnit<'tcx>],
- output_directory: &Option<PathBuf>,
- crate_name: Symbol,
-) -> Result<(), Box<dyn std::error::Error>> {
- let output_directory = if let Some(ref directory) = output_directory {
- fs::create_dir_all(directory)?;
- directory
- } else {
- Path::new(".")
- };
-
- let format = tcx.sess.opts.unstable_opts.dump_mono_stats_format;
- let ext = format.extension();
- let filename = format!("{crate_name}.mono_items.{ext}");
- let output_path = output_directory.join(&filename);
- let file = File::create(&output_path)?;
- let mut file = BufWriter::new(file);
-
- // Gather instantiated mono items grouped by def_id
- let mut items_per_def_id: FxHashMap<_, Vec<_>> = Default::default();
- for cgu in codegen_units {
- for (&mono_item, _) in cgu.items() {
- // Avoid variable-sized compiler-generated shims
- if mono_item.is_user_defined() {
- items_per_def_id.entry(mono_item.def_id()).or_default().push(mono_item);
- }
- }
- }
-
- #[derive(serde::Serialize)]
- struct MonoItem {
- name: String,
- instantiation_count: usize,
- size_estimate: usize,
- total_estimate: usize,
- }
-
- // Output stats sorted by total instantiated size, from heaviest to lightest
- let mut stats: Vec<_> = items_per_def_id
- .into_iter()
- .map(|(def_id, items)| {
- let name = with_no_trimmed_paths!(tcx.def_path_str(def_id));
- let instantiation_count = items.len();
- let size_estimate = items[0].size_estimate(tcx);
- let total_estimate = instantiation_count * size_estimate;
- MonoItem { name, instantiation_count, size_estimate, total_estimate }
- })
- .collect();
- stats.sort_unstable_by_key(|item| cmp::Reverse(item.total_estimate));
-
- if !stats.is_empty() {
- match format {
- DumpMonoStatsFormat::Json => serde_json::to_writer(file, &stats)?,
- DumpMonoStatsFormat::Markdown => {
- writeln!(
- file,
- "| Item | Instantiation count | Estimated Cost Per Instantiation | Total Estimated Cost |"
- )?;
- writeln!(file, "| --- | ---: | ---: | ---: |")?;
-
- for MonoItem { name, instantiation_count, size_estimate, total_estimate } in stats {
- writeln!(
- file,
- "| `{name}` | {instantiation_count} | {size_estimate} | {total_estimate} |"
- )?;
- }
- }
- }
- }
-
- Ok(())
-}
-
-fn codegened_and_inlined_items(tcx: TyCtxt<'_>, (): ()) -> &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;
- }
- let body = tcx.instance_mir(instance.def);
- for block in body.basic_blocks.iter() {
- for statement in &block.statements {
- let mir::StatementKind::Coverage(_) = statement.kind else { continue };
- let scope = statement.source_info.scope;
- if let Some(inlined) = scope.inlined_instance(&body.source_scopes) {
- 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:?}"))
- };
-}
diff --git a/compiler/rustc_monomorphize/src/util.rs b/compiler/rustc_monomorphize/src/util.rs
index d12bfc6f6..f6a80b043 100644
--- a/compiler/rustc_monomorphize/src/util.rs
+++ b/compiler/rustc_monomorphize/src/util.rs
@@ -29,12 +29,12 @@ pub(crate) fn dump_closure_profile<'tcx>(tcx: TyCtxt<'tcx>, closure_instance: In
let before_feature_tys = tcx.subst_and_normalize_erasing_regions(
closure_instance.substs,
param_env,
- ty::EarlyBinder(before_feature_tys),
+ ty::EarlyBinder::bind(before_feature_tys),
);
let after_feature_tys = tcx.subst_and_normalize_erasing_regions(
closure_instance.substs,
param_env,
- ty::EarlyBinder(after_feature_tys),
+ ty::EarlyBinder::bind(after_feature_tys),
);
let new_size = tcx