1//! Mono Item Collection2//! ====================3//!4//! This module is responsible for discovering all items that will contribute5//! to code generation of the crate. The important part here is that it not only6//! needs to find syntax-level items (functions, structs, etc) but also all7//! their monomorphized instantiations. Every non-generic, non-const function8//! maps to one LLVM artifact. Every generic function can produce9//! from zero to N artifacts, depending on the sets of type arguments it10//! is instantiated with.11//! This also applies to generic items from other crates: A generic definition12//! in crate X might produce monomorphizations that are compiled into crate Y.13//! We also have to collect these here.14//!15//! The following kinds of "mono items" are handled here:16//!17//! - Functions18//! - Methods19//! - Closures20//! - Statics21//! - Drop glue22//!23//! The following things also result in LLVM artifacts, but are not collected24//! here, since we instantiate them locally on demand when needed in a given25//! codegen unit:26//!27//! - Constants28//! - VTables29//! - Object Shims30//!31//! The main entry point is `collect_crate_mono_items`, at the bottom of this file.32//!33//! General Algorithm34//! -----------------35//! Let's define some terms first:36//!37//! - A "mono item" is something that results in a function or global in38//!   the LLVM IR of a codegen unit. Mono items do not stand on their39//!   own, they can use other mono items. For example, if function40//!   `foo()` calls function `bar()` then the mono item for `foo()`41//!   uses the mono item for function `bar()`. In general, the42//!   definition for mono item A using a mono item B is that43//!   the LLVM artifact produced for A uses the LLVM artifact produced44//!   for B.45//!46//! - Mono items and the uses between them form a directed graph,47//!   where the mono items are the nodes and uses form the edges.48//!   Let's call this graph the "mono item graph".49//!50//! - The mono item graph for a program contains all mono items51//!   that are needed in order to produce the complete LLVM IR of the program.52//!53//! The purpose of the algorithm implemented in this module is to build the54//! mono item graph for the current crate. It runs in two phases:55//!56//! 1. Discover the roots of the graph by traversing the HIR of the crate.57//! 2. Starting from the roots, find uses by inspecting the MIR58//!    representation of the item corresponding to a given node, until no more59//!    new nodes are found.60//!61//! ### Discovering roots62//! The roots of the mono item graph correspond to the public non-generic63//! syntactic items in the source code. We find them by walking the HIR of the64//! crate, and whenever we hit upon a public function, method, or static item,65//! we create a mono item consisting of the items DefId and, since we only66//! consider non-generic items, an empty type-parameters set. (In eager67//! collection mode, during incremental compilation, all non-generic functions68//! are considered as roots, as well as when the `-Clink-dead-code` option is69//! specified. Functions marked `#[no_mangle]` and functions called by inlinable70//! functions also always act as roots.)71//!72//! ### Finding uses73//! Given a mono item node, we can discover uses by inspecting its MIR. We walk74//! the MIR to find other mono items used by each mono item. Since the mono75//! item we are currently at is always monomorphic, we also know the concrete76//! type arguments of its used mono items. The specific forms a use can take in77//! MIR are quite diverse. Here is an overview:78//!79//! #### Calling Functions/Methods80//! The most obvious way for one mono item to use another is a81//! function or method call (represented by a CALL terminator in MIR). But82//! calls are not the only thing that might introduce a use between two83//! function mono items, and as we will see below, they are just a84//! specialization of the form described next, and consequently will not get any85//! special treatment in the algorithm.86//!87//! #### Taking a reference to a function or method88//! A function does not need to actually be called in order to be used by89//! another function. It suffices to just take a reference in order to introduce90//! an edge. Consider the following example:91//!92//! ```93//! # use core::fmt::Display;94//! fn print_val<T: Display>(x: T) {95//!     println!("{}", x);96//! }97//!98//! fn call_fn(f: &dyn Fn(i32), x: i32) {99//!     f(x);100//! }101//!102//! fn main() {103//!     let print_i32 = print_val::<i32>;104//!     call_fn(&print_i32, 0);105//! }106//! ```107//! The MIR of none of these functions will contain an explicit call to108//! `print_val::<i32>`. Nonetheless, in order to mono this program, we need109//! an instance of this function. Thus, whenever we encounter a function or110//! method in operand position, we treat it as a use of the current111//! mono item. Calls are just a special case of that.112//!113//! #### Drop glue114//! Drop glue mono items are introduced by MIR drop-statements. The115//! generated mono item will have additional drop-glue item uses if the116//! type to be dropped contains nested values that also need to be dropped. It117//! might also have a function item use for the explicit `Drop::drop`118//! implementation of its type.119//!120//! #### Unsizing Casts121//! A subtle way of introducing use edges is by casting to a trait object.122//! Since the resulting wide-pointer contains a reference to a vtable, we need to123//! instantiate all dyn-compatible methods of the trait, as we need to store124//! pointers to these functions even if they never get called anywhere. This can125//! be seen as a special case of taking a function reference.126//!127//!128//! Interaction with Cross-Crate Inlining129//! -------------------------------------130//! The binary of a crate will not only contain machine code for the items131//! defined in the source code of that crate. It will also contain monomorphic132//! instantiations of any extern generic functions and of functions marked with133//! `#[inline]`.134//! The collection algorithm handles this more or less mono. If it is135//! about to create a mono item for something with an external `DefId`,136//! it will take a look if the MIR for that item is available, and if so just137//! proceed normally. If the MIR is not available, it assumes that the item is138//! just linked to and no node is created; which is exactly what we want, since139//! no machine code should be generated in the current crate for such an item.140//!141//! Eager and Lazy Collection Strategy142//! ----------------------------------143//! Mono item collection can be performed with one of two strategies:144//!145//! - Lazy strategy means that items will only be instantiated when actually146//!   used. The goal is to produce the least amount of machine code147//!   possible.148//!149//! - Eager strategy is meant to be used in conjunction with incremental compilation150//!   where a stable set of mono items is more important than a minimal151//!   one. Thus, eager strategy will instantiate drop-glue for every drop-able type152//!   in the crate, even if no drop call for that type exists (yet). It will153//!   also instantiate default implementations of trait methods, something that154//!   otherwise is only done on demand.155//!156//! Collection-time const evaluation and "mentioned" items157//! ------------------------------------------------------158//!159//! One important role of collection is to evaluate all constants that are used by all the items160//! which are being collected. Codegen can then rely on only encountering constants that evaluate161//! successfully, and if a constant fails to evaluate, the collector has much better context to be162//! able to show where this constant comes up.163//!164//! However, the exact set of "used" items (collected as described above), and therefore the exact165//! set of used constants, can depend on optimizations. Optimizing away dead code may optimize away166//! a function call that uses a failing constant, so an unoptimized build may fail where an167//! optimized build succeeds. This is undesirable.168//!169//! To avoid this, the collector has the concept of "mentioned" items. Some time during the MIR170//! pipeline, before any optimization-level-dependent optimizations, we compute a list of all items171//! that syntactically appear in the code. These are considered "mentioned", and even if they are in172//! dead code and get optimized away (which makes them no longer "used"), they are still173//! "mentioned". For every used item, the collector ensures that all mentioned items, recursively,174//! do not use a failing constant. This is reflected via the [`CollectionMode`], which determines175//! whether we are visiting a used item or merely a mentioned item.176//!177//! The collector and "mentioned items" gathering (which lives in `rustc_mir_transform::mentioned_items`)178//! need to stay in sync in the following sense:179//!180//! - For every item that the collector gather that could eventually lead to build failure (most181//!   likely due to containing a constant that fails to evaluate), a corresponding mentioned item182//!   must be added. This should use the exact same strategy as the ecollector to make sure they are183//!   in sync. However, while the collector works on monomorphized types, mentioned items are184//!   collected on generic MIR -- so any time the collector checks for a particular type (such as185//!   `ty::FnDef`), we have to just onconditionally add this as a mentioned item.186//! - In `visit_mentioned_item`, we then do with that mentioned item exactly what the collector187//!   would have done during regular MIR visiting. Basically you can think of the collector having188//!   two stages, a pre-monomorphization stage and a post-monomorphization stage (usually quite189//!   literally separated by a call to `self.monomorphize`); the pre-monomorphizationn stage is190//!   duplicated in mentioned items gathering and the post-monomorphization stage is duplicated in191//!   `visit_mentioned_item`.192//! - Finally, as a performance optimization, the collector should fill `used_mentioned_item` during193//!   its MIR traversal with exactly what mentioned item gathering would have added in the same194//!   situation. This detects mentioned items that have *not* been optimized away and hence don't195//!   need a dedicated traversal.196//!197//! Open Issues198//! -----------199//! Some things are not yet fully implemented in the current version of this200//! module.201//!202//! ### Const Fns203//! Ideally, no mono item should be generated for const fns unless there204//! is a call to them that cannot be evaluated at compile time. At the moment205//! this is not implemented however: a mono item will be produced206//! regardless of whether it is actually needed or not.207208use std::cell::OnceCell;209use std::ops::ControlFlow;210211use rustc_data_structures::fx::FxIndexMap;212use rustc_data_structures::sync::{Lock, par_for_each_in};213use rustc_data_structures::unord::{UnordMap, UnordSet};214use rustc_hir as hir;215use rustc_hir::attrs::InlineAttr;216use rustc_hir::attrs::lang_items::LangItem;217use rustc_hir::def::DefKind;218use rustc_hir::def_id::{DefId, DefIdMap, LocalDefId};219use rustc_middle::middle::codegen_fn_attrs::CodegenFnAttrFlags;220use rustc_middle::mir::interpret::{AllocId, ErrorHandled, GlobalAlloc, Scalar};221use rustc_middle::mir::visit::Visitor as MirVisitor;222use rustc_middle::mir::{self, Body, Location, MentionedItem, traversal};223use rustc_middle::mono::{CollectionMode, InstantiationMode, MonoItem, NormalizationErrorInMono};224use rustc_middle::query::TyCtxtAt;225use rustc_middle::ty::adjustment::{CustomCoerceUnsized, PointerCoercion};226use rustc_middle::ty::layout::ValidityRequirement;227use rustc_middle::ty::{228    self, GenericArgs, GenericParamDefKind, Instance, InstanceKind, ShimKind, Ty, TyCtxt,229    TypeFoldable, TypeVisitable, TypeVisitableExt, TypeVisitor, Unnormalized, VtblEntry,230};231use rustc_middle::util::Providers;232use rustc_middle::{bug, span_bug};233use rustc_session::config::{DebugInfo, EntryFnType, Offload};234use rustc_span::{DUMMY_SP, Span, Spanned, Symbol, dummy_spanned, respan};235use rustc_structures::Limit;236use tracing::{debug, instrument, trace};237238use crate::diagnostics::{239    self, EncounteredErrorWhileInstantiating, EncounteredErrorWhileInstantiatingGlobalAsm,240    NoOptimizedMir, RecursionLimit,241};242243#[derive(PartialEq)]244pub(crate) enum MonoItemCollectionStrategy {245    Eager,246    Lazy,247}248249/// The state that is shared across the concurrent threads that are doing collection.250struct SharedState<'tcx> {251    /// Items that have been or are currently being recursively collected.252    visited: Lock<UnordSet<MonoItem<'tcx>>>,253    /// Items that have been or are currently being recursively treated as "mentioned", i.e., their254    /// consts are evaluated but nothing is added to the collection.255    mentioned: Lock<UnordSet<MonoItem<'tcx>>>,256    /// Which items are being used where, for better errors.257    usage_map: Lock<UsageMap<'tcx>>,258}259260pub(crate) struct UsageMap<'tcx> {261    // Maps every mono item to the mono items used by it.262    pub used_map: UnordMap<MonoItem<'tcx>, Vec<MonoItem<'tcx>>>,263264    // Maps each mono item with users to the mono items that use it.265    // Be careful: subsets `used_map`, so unused items are vacant.266    user_map: UnordMap<MonoItem<'tcx>, Vec<MonoItem<'tcx>>>,267}268269impl<'tcx> UsageMap<'tcx> {270    fn new() -> UsageMap<'tcx> {271        UsageMap { used_map: Default::default(), user_map: Default::default() }272    }273274    fn record_used<'a>(&mut self, user_item: MonoItem<'tcx>, used_items: &'a MonoItems<'tcx>)275    where276        'tcx: 'a,277    {278        for used_item in used_items.items() {279            self.user_map.entry(used_item).or_default().push(user_item);280        }281282        assert!(self.used_map.insert(user_item, used_items.items().collect()).is_none());283    }284285    pub(crate) fn get_user_items(&self, item: MonoItem<'tcx>) -> &[MonoItem<'tcx>] {286        self.user_map.get(&item).map(|items| items.as_slice()).unwrap_or(&[])287    }288289    /// Internally iterate over all inlined items used by `item`.290    pub(crate) fn for_each_inlined_used_item<F>(291        &self,292        tcx: TyCtxt<'tcx>,293        item: MonoItem<'tcx>,294        mut f: F,295    ) where296        F: FnMut(MonoItem<'tcx>),297    {298        let used_items = self.used_map.get(&item).unwrap();299        for used_item in used_items.iter() {300            let is_inlined = used_item.instantiation_mode(tcx) == InstantiationMode::LocalCopy;301            if is_inlined {302                f(*used_item);303            }304        }305    }306}307308struct MonoItems<'tcx> {309    // We want a set of MonoItem + Span where trying to re-insert a MonoItem with a different Span310    // is ignored. Map does that, but it looks odd.311    items: FxIndexMap<MonoItem<'tcx>, Span>,312}313314impl<'tcx> MonoItems<'tcx> {315    fn new() -> Self {316        Self { items: FxIndexMap::default() }317    }318319    fn is_empty(&self) -> bool {320        self.items.is_empty()321    }322323    fn push(&mut self, item: Spanned<MonoItem<'tcx>>) {324        // Insert only if the entry does not exist. A normal insert would stomp the first span that325        // got inserted.326        self.items.entry(item.node).or_insert(item.span);327    }328329    fn items(&self) -> impl Iterator<Item = MonoItem<'tcx>> {330        self.items.keys().cloned()331    }332}333334impl<'tcx> IntoIterator for MonoItems<'tcx> {335    type Item = Spanned<MonoItem<'tcx>>;336    type IntoIter = impl Iterator<Item = Spanned<MonoItem<'tcx>>>;337338    fn into_iter(self) -> Self::IntoIter {339        self.items.into_iter().map(|(item, span)| respan(span, item))340    }341}342343impl<'tcx> Extend<Spanned<MonoItem<'tcx>>> for MonoItems<'tcx> {344    fn extend<I>(&mut self, iter: I)345    where346        I: IntoIterator<Item = Spanned<MonoItem<'tcx>>>,347    {348        for item in iter {349            self.push(item)350        }351    }352}353354fn collect_items_root<'tcx>(355    tcx: TyCtxt<'tcx>,356    starting_item: Spanned<MonoItem<'tcx>>,357    state: &SharedState<'tcx>,358    recursion_limit: Limit,359) {360    if !state.visited.lock().insert(starting_item.node) {361        // We've been here already, no need to search again.362        return;363    }364    let mut recursion_depths = DefIdMap::default();365    collect_items_rec(366        tcx,367        starting_item,368        state,369        &mut recursion_depths,370        recursion_limit,371        CollectionMode::UsedItems,372    );373}374375/// Collect all monomorphized items reachable from `starting_point`, and emit a note diagnostic if a376/// post-monomorphization error is encountered during a collection step.377///378/// `mode` determined whether we are scanning for [used items][CollectionMode::UsedItems]379/// or [mentioned items][CollectionMode::MentionedItems].380#[instrument(skip(tcx, state, recursion_depths, recursion_limit), level = "debug")]381fn collect_items_rec<'tcx>(382    tcx: TyCtxt<'tcx>,383    starting_item: Spanned<MonoItem<'tcx>>,384    state: &SharedState<'tcx>,385    recursion_depths: &mut DefIdMap<usize>,386    recursion_limit: Limit,387    mode: CollectionMode,388) {389    let mut used_items = MonoItems::new();390    let mut mentioned_items = MonoItems::new();391    let recursion_depth_reset;392393    // Post-monomorphization errors MVP394    //395    // We can encounter errors while monomorphizing an item, but we don't have a good way of396    // showing a complete stack of spans ultimately leading to collecting the erroneous one yet.397    // (It's also currently unclear exactly which diagnostics and information would be interesting398    // to report in such cases)399    //400    // This leads to suboptimal error reporting: a post-monomorphization error (PME) will be401    // shown with just a spanned piece of code causing the error, without information on where402    // it was called from. This is especially obscure if the erroneous mono item is in a403    // dependency. See for example issue #85155, where, before minimization, a PME happened two404    // crates downstream from libcore's stdarch, without a way to know which dependency was the405    // cause.406    //407    // If such an error occurs in the current crate, its span will be enough to locate the408    // source. If the cause is in another crate, the goal here is to quickly locate which mono409    // item in the current crate is ultimately responsible for causing the error.410    //411    // To give at least _some_ context to the user: while collecting mono items, we check the412    // error count. If it has changed, a PME occurred, and we trigger some diagnostics about the413    // current step of mono items collection.414    //415    // FIXME: don't rely on global state, instead bubble up errors. Note: this is very hard to do.416    let error_count = tcx.dcx().err_count_on_current_thread();417418    // In `mentioned_items` we collect items that were mentioned in this MIR but possibly do not419    // need to be monomorphized. This is done to ensure that optimizing away function calls does not420    // hide const-eval errors that those calls would otherwise have triggered.421    match starting_item.node {422        MonoItem::Static(def_id) => {423            recursion_depth_reset = None;424425            // Statics always get evaluated (which is possible because they can't be generic), so for426            // `MentionedItems` collection there's nothing to do here.427            if mode == CollectionMode::UsedItems {428                let instance = Instance::mono(tcx, def_id);429430                // Sanity check whether this ended up being collected accidentally431                debug_assert!(tcx.should_codegen_locally(instance));432433                let DefKind::Static { nested, .. } = tcx.def_kind(def_id) else { bug!() };434                // Nested statics have no type.435                if !nested {436                    let ty = instance.ty(tcx, ty::TypingEnv::fully_monomorphized());437                    visit_drop_use(tcx, ty, true, starting_item.span, &mut used_items);438                }439440                if let Ok(alloc) = tcx.eval_static_initializer(def_id) {441                    for &prov in alloc.inner().provenance().ptrs().values() {442                        collect_alloc(tcx, prov.alloc_id(), &mut used_items);443                    }444                }445446                if tcx.needs_thread_local_shim(def_id) {447                    used_items.push(respan(448                        starting_item.span,449                        MonoItem::Fn(Instance {450                            def: InstanceKind::Shim(ShimKind::ThreadLocal(def_id)),451                            args: GenericArgs::empty(),452                        }),453                    ));454                }455            }456457            // mentioned_items stays empty since there's no codegen for statics. statics don't get458            // optimized, and if they did then the const-eval interpreter would have to worry about459            // mentioned_items.460        }461        MonoItem::Fn(instance) => {462            // Sanity check whether this ended up being collected accidentally463            debug_assert!(tcx.should_codegen_locally(instance));464465            // Keep track of the monomorphization recursion depth466            recursion_depth_reset = Some(check_recursion_limit(467                tcx,468                instance,469                starting_item.span,470                recursion_depths,471                recursion_limit,472            ));473474            let Ok((used, mentioned)) = tcx.items_of_instance((instance, mode)) else {475                // Normalization errors here are usually due to trait solving overflow.476                // FIXME: I assume that there are few type errors at post-analysis stage, but not477                // entirely sure.478                // We have to emit the error outside of `items_of_instance` to access the479                // span of the `starting_item`.480                let def_id = instance.def_id();481                let def_span = tcx.def_span(def_id);482                let def_path_str = tcx.def_path_str(def_id);483                tcx.dcx().emit_fatal(RecursionLimit {484                    span: starting_item.span,485                    instance,486                    def_span,487                    def_path_str,488                });489            };490            used_items.extend(used.into_iter().copied());491            mentioned_items.extend(mentioned.into_iter().copied());492        }493        MonoItem::GlobalAsm(item_id) => {494            assert!(495                mode == CollectionMode::UsedItems,496                "should never encounter global_asm when collecting mentioned items"497            );498            recursion_depth_reset = None;499500            let item = tcx.hir_item(item_id);501            if let hir::ItemKind::GlobalAsm { asm, .. } = item.kind {502                for (op, op_sp) in asm.operands {503                    match *op {504                        hir::InlineAsmOperand::Const { anon_const } => {505                            match tcx.const_eval_poly(anon_const.def_id.to_def_id()) {506                                Ok(val) => {507                                    collect_const_value(tcx, val, &mut used_items);508                                }509                                Err(ErrorHandled::TooGeneric(..)) => {510                                    span_bug!(*op_sp, "asm const cannot be resolved; too generic")511                                }512                                Err(ErrorHandled::Reported(..)) => {513                                    continue;514                                }515                            }516                        }517                        hir::InlineAsmOperand::SymFn { expr } => {518                            let fn_ty = tcx.typeck(item_id.owner_id).expr_ty(expr);519                            visit_fn_use(tcx, fn_ty, false, *op_sp, &mut used_items);520                        }521                        hir::InlineAsmOperand::SymStatic { path: _, def_id } => {522                            let instance = Instance::mono(tcx, def_id);523                            if tcx.should_codegen_locally(instance) {524                                trace!("collecting static {:?}", def_id);525                                used_items.push(dummy_spanned(MonoItem::Static(def_id)));526                            }527                        }528                        hir::InlineAsmOperand::In { .. }529                        | hir::InlineAsmOperand::Out { .. }530                        | hir::InlineAsmOperand::InOut { .. }531                        | hir::InlineAsmOperand::SplitInOut { .. }532                        | hir::InlineAsmOperand::Label { .. } => {533                            span_bug!(*op_sp, "invalid operand type for global_asm!")534                        }535                    }536                }537            } else {538                span_bug!(item.span, "Mismatch between hir::Item type and MonoItem type")539            }540541            // mention_items stays empty as nothing gets optimized here.542        }543    };544545    // Check for PMEs and emit a diagnostic if one happened. To try to show relevant edges of the546    // mono item graph.547    if tcx.dcx().err_count_on_current_thread() > error_count548        && starting_item.node.is_generic_fn()549        && starting_item.node.is_user_defined()550    {551        match starting_item.node {552            MonoItem::Fn(instance) => tcx.dcx().emit_note(EncounteredErrorWhileInstantiating {553                span: starting_item.span,554                kind: "fn",555                instance,556            }),557            MonoItem::Static(def_id) => tcx.dcx().emit_note(EncounteredErrorWhileInstantiating {558                span: starting_item.span,559                kind: "static",560                instance: Instance::new_raw(def_id, GenericArgs::empty()),561            }),562            MonoItem::GlobalAsm(_) => {563                tcx.dcx().emit_note(EncounteredErrorWhileInstantiatingGlobalAsm {564                    span: starting_item.span,565                })566            }567        }568    }569    // Only updating `usage_map` for used items as otherwise we may be inserting the same item570    // multiple times (if it is first 'mentioned' and then later actually used), and the usage map571    // logic does not like that.572    // This is part of the output of collection and hence only relevant for "used" items.573    // ("Mentioned" items are only considered internally during collection.)574    if mode == CollectionMode::UsedItems {575        state.usage_map.lock().record_used(starting_item.node, &used_items);576    }577578    {579        let mut visited = OnceCell::default();580        if mode == CollectionMode::UsedItems {581            used_items582                .items583                .retain(|k, _| visited.get_mut_or_init(|| state.visited.lock()).insert(*k));584        }585586        let mut mentioned = OnceCell::default();587        mentioned_items.items.retain(|k, _| {588            !visited.get_or_init(|| state.visited.lock()).contains(k)589                && mentioned.get_mut_or_init(|| state.mentioned.lock()).insert(*k)590        });591    }592    if mode == CollectionMode::MentionedItems {593        assert!(used_items.is_empty(), "'mentioned' collection should never encounter used items");594    } else {595        for used_item in used_items {596            collect_items_rec(597                tcx,598                used_item,599                state,600                recursion_depths,601                recursion_limit,602                CollectionMode::UsedItems,603            );604        }605    }606607    // Walk over mentioned items *after* used items, so that if an item is both mentioned and used then608    // the loop above has fully collected it, so this loop will skip it.609    for mentioned_item in mentioned_items {610        collect_items_rec(611            tcx,612            mentioned_item,613            state,614            recursion_depths,615            recursion_limit,616            CollectionMode::MentionedItems,617        );618    }619620    if let Some((def_id, depth)) = recursion_depth_reset {621        recursion_depths.insert(def_id, depth);622    }623}624625// Check whether we can normalize every type in the instantiated MIR body.626fn check_normalization_error<'tcx>(627    tcx: TyCtxt<'tcx>,628    instance: Instance<'tcx>,629    body: &Body<'tcx>,630) -> Result<(), NormalizationErrorInMono> {631    struct NormalizationChecker<'tcx> {632        tcx: TyCtxt<'tcx>,633        instance: Instance<'tcx>,634    }635    impl<'tcx> TypeVisitor<TyCtxt<'tcx>> for NormalizationChecker<'tcx> {636        type Result = ControlFlow<()>;637638        fn visit_ty(&mut self, t: Ty<'tcx>) -> Self::Result {639            match self.instance.try_instantiate_mir_and_normalize_erasing_regions(640                self.tcx,641                ty::TypingEnv::fully_monomorphized(),642                ty::EarlyBinder::bind(self.tcx, t),643            ) {644                Ok(_) => ControlFlow::Continue(()),645                Err(_) => ControlFlow::Break(()),646            }647        }648    }649650    let mut checker = NormalizationChecker { tcx, instance };651    if body.visit_with(&mut checker).is_break() { Err(NormalizationErrorInMono) } else { Ok(()) }652}653654fn check_recursion_limit<'tcx>(655    tcx: TyCtxt<'tcx>,656    instance: Instance<'tcx>,657    span: Span,658    recursion_depths: &mut DefIdMap<usize>,659    recursion_limit: Limit,660) -> (DefId, usize) {661    let def_id = instance.def_id();662    let recursion_depth = recursion_depths.get(&def_id).cloned().unwrap_or(0);663    debug!(" => recursion depth={}", recursion_depth);664665    let adjusted_recursion_depth = if tcx.is_lang_item(def_id, LangItem::DropGlue) {666        // HACK: `drop_glue` creates tight monomorphization loops. Give667        // it more margin.668        recursion_depth / 4669    } else {670        recursion_depth671    };672673    // Code that needs to instantiate the same function recursively674    // more than the recursion limit is assumed to be causing an675    // infinite expansion.676    if !recursion_limit.value_within_limit(adjusted_recursion_depth) {677        let def_span = tcx.def_span(def_id);678        let def_path_str = tcx.def_path_str(def_id);679        tcx.dcx().emit_fatal(RecursionLimit { span, instance, def_span, def_path_str });680    }681682    recursion_depths.insert(def_id, recursion_depth + 1);683684    (def_id, recursion_depth)685}686687struct MirUsedCollector<'a, 'tcx> {688    tcx: TyCtxt<'tcx>,689    body: &'a mir::Body<'tcx>,690    used_items: &'a mut MonoItems<'tcx>,691    /// See the comment in `collect_items_of_instance` for the purpose of this set.692    /// Note that this contains *not-monomorphized* items!693    used_mentioned_items: &'a mut UnordSet<MentionedItem<'tcx>>,694    instance: Instance<'tcx>,695}696697impl<'a, 'tcx> MirUsedCollector<'a, 'tcx> {698    fn monomorphize<T>(&self, value: T) -> T699    where700        T: TypeFoldable<TyCtxt<'tcx>>,701    {702        trace!("monomorphize: self.instance={:?}", self.instance);703        self.instance.instantiate_mir_and_normalize_erasing_regions(704            self.tcx,705            ty::TypingEnv::fully_monomorphized(),706            ty::EarlyBinder::bind(self.tcx, value),707        )708    }709710    /// Evaluates a *not yet monomorphized* constant.711    fn eval_constant(&mut self, constant: &mir::ConstOperand<'tcx>) -> Option<mir::ConstValue> {712        let const_ = self.monomorphize(constant.const_);713        // Evaluate the constant. This makes const eval failure a collection-time error (rather than714        // a codegen-time error). rustc stops after collection if there was an error, so this715        // ensures codegen never has to worry about failing consts.716        // (codegen relies on this and ICEs will happen if this is violated.)717        match const_.eval(self.tcx, ty::TypingEnv::fully_monomorphized(), constant.span) {718            Ok(v) => Some(v),719            Err(ErrorHandled::TooGeneric(..)) => span_bug!(720                constant.span,721                "collection encountered polymorphic constant: {:?}",722                const_723            ),724            Err(err @ ErrorHandled::Reported(..)) => {725                err.emit_note(self.tcx);726                return None;727            }728        }729    }730}731732impl<'a, 'tcx> MirVisitor<'tcx> for MirUsedCollector<'a, 'tcx> {733    fn visit_rvalue(&mut self, rvalue: &mir::Rvalue<'tcx>, location: Location) {734        debug!("visiting rvalue {:?}", *rvalue);735736        let span = self.body.source_info(location).span;737738        match *rvalue {739            // When doing an cast from a regular pointer to a wide pointer, we740            // have to instantiate all methods of the trait being cast to, so we741            // can build the appropriate vtable.742            mir::Rvalue::Cast(743                mir::CastKind::PointerCoercion(PointerCoercion::Unsize, _),744                ref operand,745                target_ty,746            ) => {747                let source_ty = operand.ty(self.body, self.tcx);748                // *Before* monomorphizing, record that we already handled this mention.749                self.used_mentioned_items750                    .insert(MentionedItem::UnsizeCast { source_ty, target_ty });751                let target_ty = self.monomorphize(target_ty);752                let source_ty = self.monomorphize(source_ty);753                let (source_ty, target_ty) =754                    find_tails_for_unsizing(self.tcx.at(span), source_ty, target_ty);755                // This could also be a different Unsize instruction, like756                // from a fixed sized array to a slice. But we are only757                // interested in things that produce a vtable.758                if target_ty.is_trait() && !source_ty.is_trait() {759                    create_mono_items_for_vtable_methods(760                        self.tcx,761                        target_ty,762                        source_ty,763                        span,764                        self.used_items,765                    );766                }767            }768            mir::Rvalue::Cast(769                mir::CastKind::PointerCoercion(PointerCoercion::ReifyFnPointer(_), _),770                ref operand,771                _,772            ) => {773                let fn_ty = operand.ty(self.body, self.tcx);774                // *Before* monomorphizing, record that we already handled this mention.775                self.used_mentioned_items.insert(MentionedItem::Fn(fn_ty));776                let fn_ty = self.monomorphize(fn_ty);777                visit_fn_use(self.tcx, fn_ty, false, span, self.used_items);778            }779            mir::Rvalue::Cast(780                mir::CastKind::PointerCoercion(PointerCoercion::ClosureFnPointer(_), _),781                ref operand,782                _,783            ) => {784                let source_ty = operand.ty(self.body, self.tcx);785                // *Before* monomorphizing, record that we already handled this mention.786                self.used_mentioned_items.insert(MentionedItem::Closure(source_ty));787                let source_ty = self.monomorphize(source_ty);788                if let ty::Closure(def_id, args) = *source_ty.kind() {789                    let instance =790                        Instance::resolve_closure(self.tcx, def_id, args, ty::ClosureKind::FnOnce);791                    if self.tcx.should_codegen_locally(instance) {792                        self.used_items.push(create_fn_mono_item(self.tcx, instance, span));793                    }794                } else {795                    bug!()796                }797            }798            mir::Rvalue::ThreadLocalRef(def_id) => {799                assert!(self.tcx.is_thread_local_static(def_id));800                let instance = Instance::mono(self.tcx, def_id);801                if self.tcx.should_codegen_locally(instance) {802                    trace!("collecting thread-local static {:?}", def_id);803                    self.used_items.push(respan(span, MonoItem::Static(def_id)));804                }805            }806            _ => { /* not interesting */ }807        }808809        self.super_rvalue(rvalue, location);810    }811812    /// This does not walk the MIR of the constant as that is not needed for codegen, all we need is813    /// to ensure that the constant evaluates successfully and walk the result.814    #[instrument(skip(self), level = "debug")]815    fn visit_const_operand(&mut self, constant: &mir::ConstOperand<'tcx>, _location: Location) {816        // No `super_constant` as we don't care about `visit_ty`/`visit_ty_const`.817        let Some(val) = self.eval_constant(constant) else { return };818        collect_const_value(self.tcx, val, self.used_items);819    }820821    fn visit_terminator(&mut self, terminator: &mir::Terminator<'tcx>, location: Location) {822        debug!("visiting terminator {:?} @ {:?}", terminator, location);823        let source = self.body.source_info(location).span;824825        let tcx = self.tcx;826        let push_mono_lang_item = |this: &mut Self, lang_item: LangItem| {827            let instance = Instance::mono(tcx, tcx.require_lang_item(lang_item, source));828            if tcx.should_codegen_locally(instance) {829                this.used_items.push(create_fn_mono_item(tcx, instance, source));830            }831        };832833        match terminator.kind {834            mir::TerminatorKind::Call { ref func, ref args, .. }835            | mir::TerminatorKind::TailCall { ref func, ref args, .. } => {836                let callee_ty = func.ty(self.body, tcx);837                // *Before* monomorphizing, record that we already handled this mention.838                self.used_mentioned_items.insert(MentionedItem::Fn(callee_ty));839                let callee_ty = self.monomorphize(callee_ty);840841                // HACK(explicit_tail_calls): collect tail calls to `#[track_caller]` functions as indirect,842                // because we later call them as such, to prevent issues with ABI incompatibility.843                // Ideally we'd replace such tail calls with normal call + return, but this requires844                // post-mono MIR optimizations, which we don't yet have.845                let force_indirect_call =846                    if matches!(terminator.kind, mir::TerminatorKind::TailCall { .. })847                        && let &ty::FnDef(def_id, args) = callee_ty.kind()848                        && let instance = ty::Instance::expect_resolve(849                            self.tcx,850                            ty::TypingEnv::fully_monomorphized(),851                            def_id,852                            args.no_bound_vars().unwrap(),853                            source,854                        )855                        && instance.def.requires_caller_location(self.tcx)856                    {857                        true858                    } else {859                        false860                    };861862                visit_fn_use(863                    self.tcx,864                    callee_ty,865                    !force_indirect_call,866                    source,867                    &mut self.used_items,868                );869870                if let ty::FnDef(def_id, _) = *callee_ty.kind()871                    && self.tcx.is_intrinsic(def_id, rustc_span::sym::offload)872                    && let Some(kernel) = args.first()873                {874                    let kernel_ty = kernel.node.ty(self.body, self.tcx);875                    let kernel_ty = self.monomorphize(kernel_ty);876                    visit_fn_use(self.tcx, kernel_ty, false, source, &mut self.used_items);877                }878            }879            mir::TerminatorKind::Drop { ref place, .. } => {880                let ty = place.ty(self.body, self.tcx).ty;881                // *Before* monomorphizing, record that we already handled this mention.882                self.used_mentioned_items.insert(MentionedItem::Drop(ty));883                let ty = self.monomorphize(ty);884                visit_drop_use(self.tcx, ty, true, source, self.used_items);885            }886            mir::TerminatorKind::InlineAsm { ref operands, .. } => {887                for op in operands {888                    match *op {889                        mir::InlineAsmOperand::SymFn { ref value } => {890                            let fn_ty = value.const_.ty();891                            // *Before* monomorphizing, record that we already handled this mention.892                            self.used_mentioned_items.insert(MentionedItem::Fn(fn_ty));893                            let fn_ty = self.monomorphize(fn_ty);894                            visit_fn_use(self.tcx, fn_ty, false, source, self.used_items);895                        }896                        mir::InlineAsmOperand::SymStatic { def_id } => {897                            let instance = Instance::mono(self.tcx, def_id);898                            if self.tcx.should_codegen_locally(instance) {899                                trace!("collecting asm sym static {:?}", def_id);900                                self.used_items.push(respan(source, MonoItem::Static(def_id)));901                            }902                        }903                        _ => {}904                    }905                }906            }907            mir::TerminatorKind::Assert { ref msg, .. } => match &**msg {908                mir::AssertKind::BoundsCheck { .. } => {909                    push_mono_lang_item(self, LangItem::PanicBoundsCheck);910                }911                mir::AssertKind::MisalignedPointerDereference { .. } => {912                    push_mono_lang_item(self, LangItem::PanicMisalignedPointerDereference);913                }914                mir::AssertKind::NullPointerDereference => {915                    push_mono_lang_item(self, LangItem::PanicNullPointerDereference);916                }917                mir::AssertKind::NullReferenceConstructed => {918                    push_mono_lang_item(self, LangItem::PanicNullReferenceConstructed);919                }920                mir::AssertKind::InvalidEnumConstruction(_) => {921                    push_mono_lang_item(self, LangItem::PanicInvalidEnumConstruction);922                }923                _ => {924                    push_mono_lang_item(self, msg.panic_function());925                }926            },927            mir::TerminatorKind::UnwindTerminate(reason) => {928                push_mono_lang_item(self, reason.lang_item());929            }930            mir::TerminatorKind::Goto { .. }931            | mir::TerminatorKind::SwitchInt { .. }932            | mir::TerminatorKind::UnwindResume933            | mir::TerminatorKind::Return934            | mir::TerminatorKind::Unreachable => {}935            mir::TerminatorKind::CoroutineDrop936            | mir::TerminatorKind::Yield { .. }937            | mir::TerminatorKind::FalseEdge { .. }938            | mir::TerminatorKind::FalseUnwind { .. } => bug!(),939        }940941        if let Some(mir::UnwindAction::Terminate(reason)) = terminator.unwind() {942            push_mono_lang_item(self, reason.lang_item());943        }944945        self.super_terminator(terminator, location);946    }947}948949fn visit_drop_use<'tcx>(950    tcx: TyCtxt<'tcx>,951    ty: Ty<'tcx>,952    is_direct_call: bool,953    source: Span,954    output: &mut MonoItems<'tcx>,955) {956    let instance = Instance::resolve_drop_glue(tcx, ty);957    visit_instance_use(tcx, instance, is_direct_call, source, output);958}959960/// For every call of this function in the visitor, make sure there is a matching call in the961/// `mentioned_items` pass!962fn visit_fn_use<'tcx>(963    tcx: TyCtxt<'tcx>,964    ty: Ty<'tcx>,965    is_direct_call: bool,966    source: Span,967    output: &mut MonoItems<'tcx>,968) {969    if let ty::FnDef(def_id, args) = *ty.kind() {970        let args = args.no_bound_vars().unwrap();971        let instance = if is_direct_call {972            ty::Instance::expect_resolve(973                tcx,974                ty::TypingEnv::fully_monomorphized(),975                def_id,976                args,977                source,978            )979        } else {980            match ty::Instance::resolve_for_fn_ptr(981                tcx,982                ty::TypingEnv::fully_monomorphized(),983                def_id,984                args,985            ) {986                Some(instance) => instance,987                _ => bug!("failed to resolve instance for {ty}"),988            }989        };990        visit_instance_use(tcx, instance, is_direct_call, source, output);991    }992}993994fn visit_instance_use<'tcx>(995    tcx: TyCtxt<'tcx>,996    instance: ty::Instance<'tcx>,997    is_direct_call: bool,998    source: Span,999    output: &mut MonoItems<'tcx>,1000) {1001    debug!("visit_item_use({:?}, is_direct_call={:?})", instance, is_direct_call);1002    if !tcx.should_codegen_locally(instance) {1003        return;1004    }1005    if let Some(intrinsic) = tcx.intrinsic(instance.def_id()) {1006        if let Some(_requirement) = ValidityRequirement::from_intrinsic(intrinsic.name) {1007            // The intrinsics assert_inhabited, assert_zero_valid, and assert_mem_uninitialized_valid will1008            // be lowered in codegen to nothing or a call to panic_nounwind. So if we encounter any1009            // of those intrinsics, we need to include a mono item for panic_nounwind, else we may try to1010            // codegen a call to that function without generating code for the function itself.1011            let def_id = tcx.require_lang_item(LangItem::PanicNounwind, source);1012            let panic_instance = Instance::mono(tcx, def_id);1013            if tcx.should_codegen_locally(panic_instance) {1014                output.push(create_fn_mono_item(tcx, panic_instance, source));1015            }1016        } else if !intrinsic.must_be_overridden1017            && (tcx.sess.opts.unstable_opts.force_intrinsic_fallback1018                || !tcx.sess.replaced_intrinsics.contains(&intrinsic.name))1019        {1020            // Codegen the fallback body of intrinsics with fallback bodies.1021            // We have to skip this otherwise as there's no body to codegen.1022            //1023            // We also skip `replaced_intrinsics` which are always replaced by the backend and hence1024            // monomorphizing the fallback body would be pointless.1025            //1026            // However, when -Zforce-intrinsic-fallback is set (e.g. to test the fallback1027            // implementations) we ignore the optimization hint and do monomorphize1028            // the fallback body.1029            let instance = ty::Instance::new_raw(instance.def_id(), instance.args);1030            if tcx.should_codegen_locally(instance) {1031                output.push(create_fn_mono_item(tcx, instance, source));1032            }1033        }1034    }10351036    match instance.def {1037        ty::InstanceKind::Virtual(..)1038        | ty::InstanceKind::Intrinsic(_)1039        | ty::InstanceKind::LlvmIntrinsic(_) => {1040            if !is_direct_call {1041                bug!("{:?} being reified", instance);1042            }1043        }1044        ty::InstanceKind::Shim(ty::ShimKind::ThreadLocal(..)) => {1045            bug!("{:?} being reified", instance);1046        }1047        ty::InstanceKind::Shim(ty::ShimKind::DropGlue(_, None)) => {1048            // Don't need to emit noop drop glue if we are calling directly.1049            //1050            // Note that we also optimize away the call to visit_instance_use in vtable construction1051            // (see create_mono_items_for_vtable_methods).1052            if !is_direct_call {1053                output.push(create_fn_mono_item(tcx, instance, source));1054            }1055        }1056        ty::InstanceKind::Item(..)1057        | ty::InstanceKind::Shim(ty::ShimKind::DropGlue(_, Some(_)))1058        | ty::InstanceKind::Shim(ty::ShimKind::FutureDropPoll(..))1059        | ty::InstanceKind::Shim(ty::ShimKind::AsyncDropGlue(_, _))1060        | ty::InstanceKind::Shim(ty::ShimKind::AsyncDropGlueCtor(_, _))1061        | ty::InstanceKind::Shim(ty::ShimKind::VTable(..))1062        | ty::InstanceKind::Shim(ty::ShimKind::Reify(..))1063        | ty::InstanceKind::Shim(ty::ShimKind::ClosureOnce { .. })1064        | ty::InstanceKind::Shim(ty::ShimKind::ConstructCoroutineInClosure { .. })1065        | ty::InstanceKind::Shim(ty::ShimKind::FnPtr(..))1066        | ty::InstanceKind::Shim(ty::ShimKind::Clone(..))1067        | ty::InstanceKind::Shim(ty::ShimKind::FnPtrAsPtr(..))1068        | ty::InstanceKind::Shim(ty::ShimKind::FnPtrFromPtr(..)) => {1069            output.push(create_fn_mono_item(tcx, instance, source));1070        }1071    }1072}10731074/// Returns `true` if we should codegen an instance in the local crate, or returns `false` if we1075/// can just link to the upstream crate and therefore don't need a mono item.1076fn should_codegen_locally<'tcx>(tcx: TyCtxt<'tcx>, instance: Instance<'tcx>) -> bool {1077    let Some(def_id) = instance.def.def_id_if_not_guaranteed_local_codegen() else {1078        return true;1079    };10801081    if tcx.is_foreign_item(def_id) {1082        // Foreign items are always linked against, there's no way of instantiating them.1083        return false;1084    }10851086    if tcx.def_kind(def_id).has_codegen_attrs()1087        && matches!(tcx.codegen_fn_attrs(def_id).inline, InlineAttr::Force { .. })1088    {1089        // `#[rustc_force_inline]` items should never be codegened. This should be caught by1090        // the MIR validator.1091        tcx.dcx().delayed_bug("attempt to codegen `#[rustc_force_inline]` item");1092    }10931094    if def_id.is_local() {1095        // Local items cannot be referred to locally without monomorphizing them locally.1096        return true;1097    }10981099    if tcx.is_reachable_non_generic(def_id) || instance.upstream_monomorphization(tcx).is_some() {1100        // We can link to the item in question, no instance needed in this crate.1101        return false;1102    }11031104    if let DefKind::Static { .. } = tcx.def_kind(def_id) {1105        // We cannot monomorphize statics from upstream crates.1106        return false;1107    }11081109    // See comment in should_encode_mir in rustc_metadata for why we don't report1110    // an error for constructors.1111    if !tcx.is_mir_available(def_id) && !matches!(tcx.def_kind(def_id), DefKind::Ctor(..)) {1112        tcx.dcx().emit_fatal(NoOptimizedMir {1113            span: tcx.def_span(def_id),1114            crate_name: tcx.crate_name(def_id.krate),1115            instance: instance.to_string(),1116        });1117    }11181119    true1120}11211122/// For a given pair of source and target type that occur in an unsizing coercion,1123/// this function finds the pair of types that determines the vtable linking1124/// them.1125///1126/// For example, the source type might be `&SomeStruct` and the target type1127/// might be `&dyn SomeTrait` in a cast like:1128///1129/// ```rust,ignore (not real code)1130/// let src: &SomeStruct = ...;1131/// let target = src as &dyn SomeTrait;1132/// ```1133///1134/// Then the output of this function would be (SomeStruct, SomeTrait) since for1135/// constructing the `target` wide-pointer we need the vtable for that pair.1136///1137/// Things can get more complicated though because there's also the case where1138/// the unsized type occurs as a field:1139///1140/// ```rust1141/// struct ComplexStruct<T: ?Sized> {1142///    a: u32,1143///    b: f64,1144///    c: T1145/// }1146/// ```1147///1148/// In this case, if `T` is sized, `&ComplexStruct<T>` is a thin pointer. If `T`1149/// is unsized, `&SomeStruct` is a wide pointer, and the vtable it points to is1150/// for the pair of `T` (which is a trait) and the concrete type that `T` was1151/// originally coerced from:1152///1153/// ```rust,ignore (not real code)1154/// let src: &ComplexStruct<SomeStruct> = ...;1155/// let target = src as &ComplexStruct<dyn SomeTrait>;1156/// ```1157///1158/// Again, we want this `find_vtable_types_for_unsizing()` to provide the pair1159/// `(SomeStruct, SomeTrait)`.1160///1161/// Finally, there is also the case of custom unsizing coercions, e.g., for1162/// smart pointers such as `Rc` and `Arc`.1163fn find_tails_for_unsizing<'tcx>(1164    tcx: TyCtxtAt<'tcx>,1165    source_ty: Ty<'tcx>,1166    target_ty: Ty<'tcx>,1167) -> (Ty<'tcx>, Ty<'tcx>) {1168    let typing_env = ty::TypingEnv::fully_monomorphized();1169    debug_assert!(!source_ty.has_param(), "{source_ty} should be fully monomorphic");1170    debug_assert!(!target_ty.has_param(), "{target_ty} should be fully monomorphic");11711172    match (source_ty.kind(), target_ty.kind()) {1173        (&ty::Pat(source, _), &ty::Pat(target, _)) => find_tails_for_unsizing(tcx, source, target),1174        (1175            &ty::Ref(_, source_pointee, _),1176            &ty::Ref(_, target_pointee, _) | &ty::RawPtr(target_pointee, _),1177        )1178        | (&ty::RawPtr(source_pointee, _), &ty::RawPtr(target_pointee, _)) => {1179            tcx.struct_lockstep_tails_for_codegen(source_pointee, target_pointee, typing_env)1180        }11811182        // `Box<T>` could go through the ADT code below, b/c it'll unpeel to `Unique<T>`,1183        // and eventually bottom out in a raw ref, but we can micro-optimize it here.1184        (_, _)1185            if let Some(source_boxed) = source_ty.boxed_ty()1186                && let Some(target_boxed) = target_ty.boxed_ty() =>1187        {1188            tcx.struct_lockstep_tails_for_codegen(source_boxed, target_boxed, typing_env)1189        }11901191        (&ty::Adt(source_adt_def, source_args), &ty::Adt(target_adt_def, target_args)) => {1192            assert_eq!(source_adt_def, target_adt_def);1193            let CustomCoerceUnsized::Struct(coerce_index) =1194                match crate::custom_coerce_unsize_info(tcx, source_ty, target_ty) {1195                    Ok(ccu) => ccu,1196                    Err(e) => {1197                        let e = Ty::new_error(tcx.tcx, e);1198                        return (e, e);1199                    }1200                };1201            let coerce_field = &source_adt_def.non_enum_variant().fields[coerce_index];1202            // We're getting a possibly unnormalized type, so normalize it.1203            let source_field =1204                tcx.normalize_erasing_regions(typing_env, coerce_field.ty(*tcx, source_args));1205            let target_field =1206                tcx.normalize_erasing_regions(typing_env, coerce_field.ty(*tcx, target_args));1207            find_tails_for_unsizing(tcx, source_field, target_field)1208        }12091210        _ => bug!(1211            "find_vtable_types_for_unsizing: invalid coercion {:?} -> {:?}",1212            source_ty,1213            target_ty1214        ),1215    }1216}12171218#[instrument(skip(tcx), level = "debug", ret)]1219fn create_fn_mono_item<'tcx>(1220    tcx: TyCtxt<'tcx>,1221    instance: Instance<'tcx>,1222    source: Span,1223) -> Spanned<MonoItem<'tcx>> {1224    let def_id = instance.def_id();1225    if tcx.sess.opts.unstable_opts.profile_closures1226        && def_id.is_local()1227        && tcx.is_closure_like(def_id)1228    {1229        crate::util::dump_closure_profile(tcx, instance);1230    }12311232    respan(source, MonoItem::Fn(instance))1233}12341235/// Creates a `MonoItem` for each method that is referenced by the vtable for1236/// the given trait/impl pair.1237fn create_mono_items_for_vtable_methods<'tcx>(1238    tcx: TyCtxt<'tcx>,1239    trait_ty: Ty<'tcx>,1240    impl_ty: Ty<'tcx>,1241    source: Span,1242    output: &mut MonoItems<'tcx>,1243) {1244    assert!(!trait_ty.has_escaping_bound_vars() && !impl_ty.has_escaping_bound_vars());12451246    let ty::Dynamic(trait_ty, ..) = trait_ty.kind() else {1247        bug!("create_mono_items_for_vtable_methods: {trait_ty:?} not a trait type");1248    };1249    if let Some(principal) = trait_ty.principal() {1250        let trait_ref =1251            tcx.instantiate_bound_regions_with_erased(principal.with_self_ty(tcx, impl_ty));1252        assert!(!trait_ref.has_escaping_bound_vars());12531254        // Walk all methods of the trait, including those of its supertraits1255        let entries = tcx.vtable_entries(trait_ref);1256        debug!(?entries);1257        let methods = entries1258            .iter()1259            .filter_map(|entry| match entry {1260                VtblEntry::MetadataDropInPlace1261                | VtblEntry::MetadataSize1262                | VtblEntry::MetadataAlign1263                | VtblEntry::Vacant => None,1264                VtblEntry::TraitVPtr(_) => {1265                    // all super trait items already covered, so skip them.1266                    None1267                }1268                VtblEntry::Method(instance) => {1269                    Some(*instance).filter(|instance| tcx.should_codegen_locally(*instance))1270                }1271            })1272            .map(|item| create_fn_mono_item(tcx, item, source));1273        output.extend(methods);1274    }12751276    // Also add the destructor, if it's necessary.1277    //1278    // This matches the check in vtable_allocation_provider in middle/ty/vtable.rs,1279    // if we don't need drop we're not adding an actual pointer to the vtable.1280    if impl_ty.needs_drop(tcx, ty::TypingEnv::fully_monomorphized()) {1281        visit_drop_use(tcx, impl_ty, false, source, output);1282    }1283}12841285/// Scans the CTFE alloc in order to find function pointers and statics that must be monomorphized.1286fn collect_alloc<'tcx>(tcx: TyCtxt<'tcx>, alloc_id: AllocId, output: &mut MonoItems<'tcx>) {1287    match tcx.global_alloc(alloc_id) {1288        GlobalAlloc::Static(def_id) => {1289            assert!(!tcx.is_thread_local_static(def_id));1290            let instance = Instance::mono(tcx, def_id);1291            if tcx.should_codegen_locally(instance) {1292                trace!("collecting static {:?}", def_id);1293                output.push(dummy_spanned(MonoItem::Static(def_id)));1294            }1295        }1296        GlobalAlloc::Memory(alloc) => {1297            trace!("collecting {:?} with {:#?}", alloc_id, alloc);1298            let ptrs = alloc.inner().provenance().ptrs();1299            if !ptrs.is_empty() {1300                for &prov in ptrs.values() {1301                    collect_alloc(tcx, prov.alloc_id(), output);1302                }1303            }1304        }1305        GlobalAlloc::Function { instance, .. } => {1306            if tcx.should_codegen_locally(instance) {1307                trace!("collecting {:?} with {:#?}", alloc_id, instance);1308                output.push(create_fn_mono_item(tcx, instance, DUMMY_SP));1309            }1310        }1311        GlobalAlloc::VTable(ty, dyn_ty) => {1312            let alloc_id = tcx.vtable_allocation((1313                ty,1314                dyn_ty1315                    .principal()1316                    .map(|principal| tcx.instantiate_bound_regions_with_erased(principal)),1317            ));1318            collect_alloc(tcx, alloc_id, output)1319        }1320        GlobalAlloc::TypeId { .. } => {}1321    }1322}13231324/// Scans the MIR in order to find function calls, closures, and drop-glue.1325///1326/// Anything that's found is added to `output`. Furthermore the "mentioned items" of the MIR are returned.1327#[instrument(skip(tcx), level = "debug")]1328fn collect_items_of_instance<'tcx>(1329    tcx: TyCtxt<'tcx>,1330    instance: Instance<'tcx>,1331    mode: CollectionMode,1332) -> Result<(MonoItems<'tcx>, MonoItems<'tcx>), NormalizationErrorInMono> {1333    // This item is getting monomorphized, do mono-time checks.1334    let body = tcx.instance_mir(instance.def);1335    // Plenty of code paths later assume that everything can be normalized. So we have to check1336    // normalization first.1337    // We choose to emit the error outside to provide helpful diagnostics.1338    check_normalization_error(tcx, instance, body)?;1339    tcx.ensure_ok().check_mono_item(instance);13401341    // Naively, in "used" collection mode, all functions get added to *both* `used_items` and1342    // `mentioned_items`. Mentioned items processing will then notice that they have already been1343    // visited, but at that point each mentioned item has been monomorphized, added to the1344    // `mentioned_items` worklist, and checked in the global set of visited items. To remove that1345    // overhead, we have a special optimization that avoids adding items to `mentioned_items` when1346    // they are already added in `used_items`. We could just scan `used_items`, but that's a linear1347    // scan and not very efficient. Furthermore we can only do that *after* monomorphizing the1348    // mentioned item. So instead we collect all pre-monomorphized `MentionedItem` that were already1349    // added to `used_items` in a hash set, which can efficiently query in the1350    // `body.mentioned_items` loop below without even having to monomorphize the item.1351    let mut used_items = MonoItems::new();1352    let mut mentioned_items = MonoItems::new();1353    let mut used_mentioned_items = Default::default();1354    let mut collector = MirUsedCollector {1355        tcx,1356        body,1357        used_items: &mut used_items,1358        used_mentioned_items: &mut used_mentioned_items,1359        instance,1360    };13611362    if mode == CollectionMode::UsedItems {1363        if tcx.sess.opts.debuginfo == DebugInfo::Full {1364            for var_debug_info in &body.var_debug_info {1365                collector.visit_var_debug_info(var_debug_info);1366            }1367        }1368        for (bb, data) in traversal::mono_reachable(body, tcx, instance) {1369            collector.visit_basic_block_data(bb, data)1370        }1371    }13721373    // Always visit all `required_consts`, so that we evaluate them and abort compilation if any of1374    // them errors.1375    for const_op in body.required_consts() {1376        if let Some(val) = collector.eval_constant(const_op) {1377            collect_const_value(tcx, val, &mut mentioned_items);1378        }1379    }13801381    // Always gather mentioned items. We try to avoid processing items that we have already added to1382    // `used_items` above.1383    for item in body.mentioned_items() {1384        if !collector.used_mentioned_items.contains(&item.node) {1385            let item_mono = collector.monomorphize(item.node);1386            visit_mentioned_item(tcx, &item_mono, item.span, &mut mentioned_items);1387        }1388    }13891390    Ok((used_items, mentioned_items))1391}13921393fn items_of_instance<'tcx>(1394    tcx: TyCtxt<'tcx>,1395    (instance, mode): (Instance<'tcx>, CollectionMode),1396) -> Result<1397    (&'tcx [Spanned<MonoItem<'tcx>>], &'tcx [Spanned<MonoItem<'tcx>>]),1398    NormalizationErrorInMono,1399> {1400    let (used_items, mentioned_items) = collect_items_of_instance(tcx, instance, mode)?;14011402    let used_items = tcx.arena.alloc_from_iter(used_items);1403    let mentioned_items = tcx.arena.alloc_from_iter(mentioned_items);14041405    Ok((used_items, mentioned_items))1406}14071408/// `item` must be already monomorphized.1409#[instrument(skip(tcx, span, output), level = "debug")]1410fn visit_mentioned_item<'tcx>(1411    tcx: TyCtxt<'tcx>,1412    item: &MentionedItem<'tcx>,1413    span: Span,1414    output: &mut MonoItems<'tcx>,1415) {1416    match *item {1417        MentionedItem::Fn(ty) => {1418            if let ty::FnDef(def_id, args) = *ty.kind() {1419                let args = args.no_bound_vars().unwrap();1420                let instance = Instance::expect_resolve(1421                    tcx,1422                    ty::TypingEnv::fully_monomorphized(),1423                    def_id,1424                    args,1425                    span,1426                );1427                // `visit_instance_use` was written for "used" item collection but works just as well1428                // for "mentioned" item collection.1429                // We can set `is_direct_call`; that just means we'll skip a bunch of shims that anyway1430                // can't have their own failing constants.1431                visit_instance_use(tcx, instance, /*is_direct_call*/ true, span, output);1432            }1433        }1434        MentionedItem::Drop(ty) => {1435            visit_drop_use(tcx, ty, /*is_direct_call*/ true, span, output);1436        }1437        MentionedItem::UnsizeCast { source_ty, target_ty } => {1438            let (source_ty, target_ty) =1439                find_tails_for_unsizing(tcx.at(span), source_ty, target_ty);1440            // This could also be a different Unsize instruction, like1441            // from a fixed sized array to a slice. But we are only1442            // interested in things that produce a vtable.1443            if target_ty.is_trait() && !source_ty.is_trait() {1444                create_mono_items_for_vtable_methods(tcx, target_ty, source_ty, span, output);1445            }1446        }1447        MentionedItem::Closure(source_ty) => {1448            if let ty::Closure(def_id, args) = *source_ty.kind() {1449                let instance =1450                    Instance::resolve_closure(tcx, def_id, args, ty::ClosureKind::FnOnce);1451                if tcx.should_codegen_locally(instance) {1452                    output.push(create_fn_mono_item(tcx, instance, span));1453                }1454            } else {1455                bug!()1456            }1457        }1458    }1459}14601461#[instrument(skip(tcx, output), level = "debug")]1462fn collect_const_value<'tcx>(1463    tcx: TyCtxt<'tcx>,1464    value: mir::ConstValue,1465    output: &mut MonoItems<'tcx>,1466) {1467    match value {1468        mir::ConstValue::Scalar(Scalar::Ptr(ptr, _size)) => {1469            collect_alloc(tcx, ptr.provenance.alloc_id(), output)1470        }1471        mir::ConstValue::Indirect { alloc_id, .. }1472        | mir::ConstValue::Slice { alloc_id, meta: _ } => collect_alloc(tcx, alloc_id, output),1473        _ => {}1474    }1475}14761477//=-----------------------------------------------------------------------------1478// Root Collection1479//=-----------------------------------------------------------------------------14801481// Find all non-generic items by walking the HIR. These items serve as roots to1482// start monomorphizing from.1483#[instrument(skip(tcx, mode), level = "debug")]1484fn collect_roots(tcx: TyCtxt<'_>, mode: MonoItemCollectionStrategy) -> Vec<MonoItem<'_>> {1485    debug!("collecting roots");1486    let mut roots = MonoItems::new();14871488    // Read the manifest and add the recorded kernel instantiations as roots so they are codegened.1489    if let Some(manifest_path) = tcx.sess.opts.unstable_opts.offload.iter().find_map(|o| {1490        if let rustc_session::config::Offload::Device(p) = o1491            && !p.is_empty()1492        {1493            Some(p)1494        } else {1495            None1496        }1497    }) {1498        tcx.sess.file_depinfo.borrow_mut().insert(Symbol::intern(manifest_path));1499        match crate::offload::manifest::read_manifest(std::path::Path::new(manifest_path), tcx) {1500            Ok(instances) => {1501                for instance in instances {1502                    if instance.def_id().is_local() {1503                        roots.push(dummy_spanned(MonoItem::Fn(instance)));1504                    }1505                }1506            }1507            Err(e) => {1508                tcx.dcx().emit_err(crate::diagnostics::OffloadManifestReadError {1509                    path: manifest_path.clone(),1510                    err: e.to_string(),1511                });1512            }1513        }1514    }15151516    {1517        let entry_fn = tcx.entry_fn(());15181519        debug!("collect_roots: entry_fn = {:?}", entry_fn);15201521        let mut collector = RootCollector { tcx, strategy: mode, entry_fn, output: &mut roots };15221523        let crate_items = tcx.hir_crate_items(());15241525        for id in crate_items.free_items() {1526            collector.process_item(id);1527        }15281529        for id in crate_items.impl_items() {1530            collector.process_impl_item(id);1531        }15321533        for id in crate_items.nested_bodies() {1534            collector.process_nested_body(id);1535        }15361537        collector.push_extra_entry_roots();1538    }15391540    let is_host_metadata = tcx1541        .sess1542        .opts1543        .unstable_opts1544        .offload1545        .iter()1546        .any(|o| matches!(o, rustc_session::config::Offload::HostMetadata(_)));1547    if is_host_metadata {1548        let crate_items = tcx.hir_crate_items(());1549        for id in crate_items.free_items() {1550            if !matches!(tcx.def_kind(id.owner_id), DefKind::Fn | DefKind::AssocFn) {1551                continue;1552            }1553            let def_id = id.owner_id.to_def_id();1554            if !tcx.generics_of(def_id).requires_monomorphization(tcx)1555                && tcx.codegen_fn_attrs(def_id).flags.intersects(CodegenFnAttrFlags::OFFLOAD_KERNEL)1556            {1557                roots.push(dummy_spanned(MonoItem::Fn(Instance::mono(tcx, def_id))));1558            }1559        }1560        for id in crate_items.impl_items() {1561            if !matches!(tcx.def_kind(id.owner_id), DefKind::Fn | DefKind::AssocFn) {1562                continue;1563            }1564            let def_id = id.owner_id.to_def_id();1565            if !tcx.generics_of(def_id).requires_monomorphization(tcx)1566                && tcx.codegen_fn_attrs(def_id).flags.intersects(CodegenFnAttrFlags::OFFLOAD_KERNEL)1567            {1568                roots.push(dummy_spanned(MonoItem::Fn(Instance::mono(tcx, def_id))));1569            }1570        }1571        for id in crate_items.trait_items() {1572            if !matches!(tcx.def_kind(id.owner_id), DefKind::Fn | DefKind::AssocFn) {1573                continue;1574            }1575            let def_id = id.owner_id.to_def_id();1576            if !tcx.generics_of(def_id).requires_monomorphization(tcx)1577                && tcx.codegen_fn_attrs(def_id).flags.intersects(CodegenFnAttrFlags::OFFLOAD_KERNEL)1578            {1579                roots.push(dummy_spanned(MonoItem::Fn(Instance::mono(tcx, def_id))));1580            }1581        }1582    }15831584    // We can only codegen items that are instantiable - items all of1585    // whose predicates hold. Luckily, items that aren't instantiable1586    // can't actually be used, so we can just skip codegenning them.1587    roots1588        .into_iter()1589        .filter_map(|Spanned { node: mono_item, .. }| {1590            mono_item.is_instantiable(tcx).then_some(mono_item)1591        })1592        .collect()1593}15941595struct RootCollector<'a, 'tcx> {1596    tcx: TyCtxt<'tcx>,1597    strategy: MonoItemCollectionStrategy,1598    output: &'a mut MonoItems<'tcx>,1599    entry_fn: Option<(DefId, EntryFnType)>,1600}16011602impl<'v> RootCollector<'_, 'v> {1603    fn process_item(&mut self, id: hir::ItemId) {1604        match self.tcx.def_kind(id.owner_id) {1605            DefKind::Enum | DefKind::Struct | DefKind::Union => {1606                if self.strategy == MonoItemCollectionStrategy::Eager1607                    && !self.tcx.generics_of(id.owner_id).requires_monomorphization(self.tcx)1608                {1609                    debug!("RootCollector: ADT drop-glue for `{id:?}`",);1610                    let id_args =1611                        ty::GenericArgs::for_item(self.tcx, id.owner_id.to_def_id(), |param, _| {1612                            match param.kind {1613                                GenericParamDefKind::Lifetime => {1614                                    self.tcx.lifetimes.re_erased.into()1615                                }1616                                GenericParamDefKind::Type { .. }1617                                | GenericParamDefKind::Const { .. } => {1618                                    unreachable!(1619                                        "`own_requires_monomorphization` check means that \1620                                we should have no type/const params"1621                                    )1622                                }1623                            }1624                        });16251626                    // This type is impossible to instantiate, so we should not try to1627                    // generate a `drop_glue` instance for it.1628                    if self.tcx.instantiate_and_check_impossible_clauses((1629                        id.owner_id.to_def_id(),1630                        id_args,1631                    )) {1632                        return;1633                    }16341635                    let ty = self1636                        .tcx1637                        .type_of(id.owner_id.to_def_id())1638                        .instantiate(self.tcx, id_args)1639                        .skip_norm_wip();1640                    assert!(!ty.has_non_region_param());1641                    visit_drop_use(self.tcx, ty, true, DUMMY_SP, self.output);1642                }1643            }1644            DefKind::GlobalAsm => {1645                debug!(1646                    "RootCollector: ItemKind::GlobalAsm({})",1647                    self.tcx.def_path_str(id.owner_id)1648                );1649                self.output.push(dummy_spanned(MonoItem::GlobalAsm(id)));1650            }1651            DefKind::Static { .. } => {1652                let def_id = id.owner_id.to_def_id();1653                debug!("RootCollector: ItemKind::Static({})", self.tcx.def_path_str(def_id));1654                self.output.push(dummy_spanned(MonoItem::Static(def_id)));1655            }1656            DefKind::Const { .. } => {1657                // Const items only generate mono items if they are actually used somewhere.1658                // Just declaring them is insufficient.16591660                // If we're collecting items eagerly, then recurse into all constants.1661                // Otherwise the value is only collected when explicitly mentioned in other items.1662                if self.strategy == MonoItemCollectionStrategy::Eager {1663                    let def_id = id.owner_id.to_def_id();1664                    // Type Consts don't have bodies to evaluate1665                    // nor do they make sense as a static.1666                    if self.tcx.is_type_const(def_id) {1667                        // FIXME(mgca): Is this actually what we want? We may want to1668                        // normalize to a ValTree then convert to a const allocation and1669                        // collect that?1670                        return;1671                    }1672                    if self.tcx.generics_of(id.owner_id).own_requires_monomorphization() {1673                        return;1674                    }1675                    let Ok(val) = self.tcx.const_eval_poly(def_id) else {1676                        return;1677                    };1678                    collect_const_value(self.tcx, val, self.output);1679                }1680            }1681            DefKind::Impl { of_trait: true } => {1682                if self.strategy == MonoItemCollectionStrategy::Eager {1683                    create_mono_items_for_default_impls(self.tcx, id, self.output);1684                }1685            }1686            DefKind::Fn => {1687                self.push_if_root(id.owner_id.def_id);1688            }1689            _ => {}1690        }1691    }16921693    fn process_impl_item(&mut self, id: hir::ImplItemId) {1694        if self.tcx.def_kind(id.owner_id) == DefKind::AssocFn {1695            self.push_if_root(id.owner_id.def_id);1696        }1697    }16981699    fn process_nested_body(&mut self, def_id: LocalDefId) {1700        match self.tcx.def_kind(def_id) {1701            DefKind::Closure => {1702                // for 'pub async fn foo(..)' also trying to monomorphize foo::{closure}1703                let is_pub_fn_coroutine =1704                    match *self.tcx.type_of(def_id).instantiate_identity().skip_norm_wip().kind() {1705                        ty::Coroutine(cor_id, _args) => {1706                            let tcx = self.tcx;1707                            let parent_id = tcx.parent(cor_id);1708                            tcx.def_kind(parent_id) == DefKind::Fn1709                                && tcx.asyncness(parent_id).is_async()1710                                && tcx.visibility(parent_id).is_public()1711                        }1712                        ty::Closure(..) | ty::CoroutineClosure(..) => false,1713                        _ => unreachable!(),1714                    };1715                if (self.strategy == MonoItemCollectionStrategy::Eager || is_pub_fn_coroutine)1716                    && !self1717                        .tcx1718                        .generics_of(self.tcx.typeck_root_def_id_local(def_id))1719                        .requires_monomorphization(self.tcx)1720                {1721                    let instance = match *self1722                        .tcx1723                        .type_of(def_id)1724                        .instantiate_identity()1725                        .skip_norm_wip()1726                        .kind()1727                    {1728                        ty::Closure(def_id, args)1729                        | ty::Coroutine(def_id, args)1730                        | ty::CoroutineClosure(def_id, args) => {1731                            Instance::new_raw(def_id, self.tcx.erase_and_anonymize_regions(args))1732                        }1733                        _ => unreachable!(),1734                    };1735                    let Ok(instance) = self.tcx.try_normalize_erasing_regions(1736                        ty::TypingEnv::fully_monomorphized(),1737                        Unnormalized::new_wip(instance),1738                    ) else {1739                        // Don't ICE on an impossible-to-normalize closure.1740                        return;1741                    };1742                    let mono_item = create_fn_mono_item(self.tcx, instance, DUMMY_SP);1743                    if mono_item.node.is_instantiable(self.tcx) {1744                        self.output.push(mono_item);1745                    }1746                }1747            }1748            _ => {}1749        }1750    }17511752    fn is_root(&self, def_id: LocalDefId) -> bool {1753        !self.tcx.generics_of(def_id).requires_monomorphization(self.tcx)1754            && match self.strategy {1755                MonoItemCollectionStrategy::Eager => {1756                    !matches!(self.tcx.codegen_fn_attrs(def_id).inline, InlineAttr::Force { .. })1757                    // comptime fns can't be codegenned, so we need to prevent collecting them even1758                    // with link-dead-code. Lazy mode prevents them by them not showing up in1759                    // `is_reachable_non_generic` (and `entry_fn` can't be comptime).1760                    && match self.tcx.def_kind(def_id) {1761                        DefKind::Fn | DefKind::AssocFn => {1762                            self.tcx.constness(def_id) != hir::Constness::Const { always: true }1763                        }1764                        _ => true,1765                    }1766                }1767                MonoItemCollectionStrategy::Lazy => {1768                    self.entry_fn.and_then(|(id, _)| id.as_local()) == Some(def_id)1769                        || self.tcx.is_reachable_non_generic(def_id)1770                        || {1771                            let flags = self.tcx.codegen_fn_attrs(def_id).flags;1772                            flags.intersects(1773                                CodegenFnAttrFlags::RUSTC_STD_INTERNAL_SYMBOL1774                                    | CodegenFnAttrFlags::EXTERNALLY_IMPLEMENTABLE_ITEM,1775                            )1776                        }1777                }1778            }1779    }17801781    /// If `def_id` represents a root, pushes it onto the list of1782    /// outputs. (Note that all roots must be monomorphic.)1783    #[instrument(skip(self), level = "debug")]1784    fn push_if_root(&mut self, def_id: LocalDefId) {1785        if self.is_root(def_id) {1786            debug!("found root");17871788            let instance = Instance::mono(self.tcx, def_id.to_def_id());1789            self.output.push(create_fn_mono_item(self.tcx, instance, DUMMY_SP));1790        }1791    }17921793    /// As a special case, when/if we encounter the1794    /// `main()` function, we also have to generate a1795    /// monomorphized copy of the start lang item based on1796    /// the return type of `main`. This is not needed when1797    /// the user writes their own `start` manually.1798    fn push_extra_entry_roots(&mut self) {1799        let Some((main_def_id, EntryFnType::Main { .. })) = self.entry_fn else {1800            return;1801        };18021803        let main_instance = Instance::mono(self.tcx, main_def_id);1804        if self.tcx.should_codegen_locally(main_instance) {1805            self.output.push(create_fn_mono_item(1806                self.tcx,1807                main_instance,1808                self.tcx.def_span(main_def_id),1809            ));1810        }18111812        let Some(start_def_id) = self.tcx.lang_items().start_fn() else {1813            self.tcx.dcx().emit_fatal(diagnostics::StartNotFound);1814        };1815        let main_ret_ty = self.tcx.fn_sig(main_def_id).no_bound_vars().unwrap().output();18161817        // Given that `main()` has no arguments,1818        // then its return type cannot have1819        // late-bound regions, since late-bound1820        // regions must appear in the argument1821        // listing.1822        let main_ret_ty = self.tcx.normalize_erasing_regions(1823            ty::TypingEnv::fully_monomorphized(),1824            Unnormalized::new_wip(main_ret_ty.no_bound_vars().unwrap()),1825        );18261827        let start_instance = Instance::expect_resolve(1828            self.tcx,1829            ty::TypingEnv::fully_monomorphized(),1830            start_def_id,1831            self.tcx.mk_args(&[main_ret_ty.into()]),1832            DUMMY_SP,1833        );18341835        self.output.push(create_fn_mono_item(self.tcx, start_instance, DUMMY_SP));1836    }1837}18381839#[instrument(level = "debug", skip(tcx, output))]1840fn create_mono_items_for_default_impls<'tcx>(1841    tcx: TyCtxt<'tcx>,1842    item: hir::ItemId,1843    output: &mut MonoItems<'tcx>,1844) {1845    let impl_ = tcx.impl_trait_header(item.owner_id);18461847    if impl_.polarity == ty::ImplPolarity::Negative {1848        return;1849    }18501851    if tcx.generics_of(item.owner_id).own_requires_monomorphization() {1852        return;1853    }18541855    // Lifetimes never affect trait selection, so we are allowed to eagerly1856    // instantiate an instance of an impl method if the impl (and method,1857    // which we check below) is only parameterized over lifetime. In that case,1858    // we use the ReErased, which has no lifetime information associated with1859    // it, to validate whether or not the impl is legal to instantiate at all.1860    let only_region_params = |param: &ty::GenericParamDef, _: &_| match param.kind {1861        GenericParamDefKind::Lifetime => tcx.lifetimes.re_erased.into(),1862        GenericParamDefKind::Type { .. } | GenericParamDefKind::Const { .. } => {1863            unreachable!(1864                "`own_requires_monomorphization` check means that \1865                we should have no type/const params"1866            )1867        }1868    };1869    let impl_args = GenericArgs::for_item(tcx, item.owner_id.to_def_id(), only_region_params);1870    let trait_ref = impl_.trait_ref.instantiate(tcx, impl_args).skip_norm_wip();18711872    // Unlike 'lazy' monomorphization that begins by collecting items transitively1873    // called by `main` or other global items, when eagerly monomorphizing impl1874    // items, we never actually check that the predicates of this impl are satisfied1875    // in a empty param env (i.e. with no assumptions).1876    //1877    // Even though this impl has no type or const generic parameters, because we don't1878    // consider higher-ranked predicates such as `for<'a> &'a mut [u8]: Copy` to1879    // be trivially false. We must now check that the impl has no impossible-to-satisfy1880    // clauses.1881    if tcx.instantiate_and_check_impossible_clauses((item.owner_id.to_def_id(), impl_args)) {1882        return;1883    }18841885    let typing_env = ty::TypingEnv::fully_monomorphized();1886    let trait_ref = tcx.normalize_erasing_regions(typing_env, Unnormalized::new_wip(trait_ref));1887    let overridden_methods = tcx.impl_item_implementor_ids(item.owner_id);1888    for method in tcx.provided_trait_methods(trait_ref.def_id) {1889        if overridden_methods.contains_key(&method.def_id) {1890            continue;1891        }18921893        if tcx.generics_of(method.def_id).own_requires_monomorphization() {1894            continue;1895        }18961897        // As mentioned above, the method is legal to eagerly instantiate if it1898        // only has lifetime generic parameters. This is validated by calling1899        // `own_requires_monomorphization` on both the impl and method.1900        let args = trait_ref.args.extend_to(tcx, method.def_id, only_region_params);1901        let instance = ty::Instance::expect_resolve(tcx, typing_env, method.def_id, args, DUMMY_SP);19021903        let mono_item = create_fn_mono_item(tcx, instance, DUMMY_SP);1904        if mono_item.node.is_instantiable(tcx) && tcx.should_codegen_locally(instance) {1905            output.push(mono_item);1906        }1907    }1908}19091910//=-----------------------------------------------------------------------------1911// Top-level entry point, tying it all together1912//=-----------------------------------------------------------------------------19131914#[instrument(skip(tcx, strategy), level = "debug")]1915pub(crate) fn collect_crate_mono_items<'tcx>(1916    tcx: TyCtxt<'tcx>,1917    strategy: MonoItemCollectionStrategy,1918) -> (Vec<MonoItem<'tcx>>, UsageMap<'tcx>) {1919    let _prof_timer = tcx.prof.generic_activity("monomorphization_collector");19201921    let roots = tcx1922        .sess1923        .time("monomorphization_collector_root_collections", || collect_roots(tcx, strategy));19241925    debug!("building mono item graph, beginning at roots");19261927    let state = SharedState {1928        visited: Lock::new(UnordSet::default()),1929        mentioned: Lock::new(UnordSet::default()),1930        usage_map: Lock::new(UsageMap::new()),1931    };1932    let recursion_limit = tcx.recursion_limit();19331934    tcx.sess.time("monomorphization_collector_graph_walk", || {1935        par_for_each_in(roots, |root| {1936            collect_items_root(tcx, dummy_spanned(*root), &state, recursion_limit);1937        });1938    });19391940    // The set of MonoItems was created in an inherently indeterministic order because1941    // of parallelism. We sort it here to ensure that the output is deterministic.1942    let mono_items = tcx.with_stable_hashing_context(move |mut hcx| {1943        state.visited.into_inner().into_sorted(&mut hcx, true)1944    });19451946    if tcx1947        .sess1948        .opts1949        .unstable_opts1950        .offload1951        .iter()1952        .any(|o| matches!(o, Offload::Device(p) if p.is_empty()))1953    {1954        crate::offload::check_offload_kernels_instantiated(tcx, &mono_items);1955    }19561957    (mono_items, state.usage_map.into_inner())1958}19591960pub(crate) fn provide(providers: &mut Providers) {1961    providers.hooks.should_codegen_locally = should_codegen_locally;1962    providers.queries.items_of_instance = items_of_instance;1963}