1use std::cmp;2use std::collections::BTreeSet;3use std::sync::Arc;4use std::time::{Duration, Instant};56use itertools::Itertools;7use rustc_abi::FIRST_VARIANT;8use rustc_ast::expand::allocator::{9    ALLOC_ERROR_HANDLER, ALLOCATOR_METHODS, AllocatorKind, AllocatorMethod, AllocatorMethodInput,10    AllocatorTy,11};12use rustc_data_structures::fx::{FxHashMap, FxIndexSet};13use rustc_data_structures::profiling::{get_resident_set_size, print_time_passes_entry};14use rustc_data_structures::sync::{IntoDynSyncSend, par_map};15use rustc_data_structures::unord::UnordMap;16use rustc_hir::attrs::{DebuggerVisualizerType, OptimizeAttr};17use rustc_hir::def_id::{DefId, LOCAL_CRATE};18use rustc_hir::lang_items::LangItem;19use rustc_hir::{ItemId, Target, find_attr};20use rustc_middle::middle::codegen_fn_attrs::CodegenFnAttrs;21use rustc_middle::middle::debugger_visualizer::DebuggerVisualizerFile;22use rustc_middle::middle::dependency_format::Dependencies;23use rustc_middle::middle::exported_symbols::{self, SymbolExportKind};24use rustc_middle::middle::lang_items;25use rustc_middle::mir::BinOp;26use rustc_middle::mir::interpret::ErrorHandled;27use rustc_middle::mono::{CodegenUnit, CodegenUnitNameBuilder, MonoItem, MonoItemPartitions};28use rustc_middle::query::Providers;29use rustc_middle::ty::layout::{HasTyCtxt, HasTypingEnv, LayoutOf, TyAndLayout};30use rustc_middle::ty::{self, Instance, PatternKind, Ty, TyCtxt, Unnormalized};31use rustc_middle::{bug, span_bug};32use rustc_session::Session;33use rustc_session::config::{self, CrateType, EntryFnType};34use rustc_span::{DUMMY_SP, Symbol};35use rustc_symbol_mangling::mangle_internal_symbol;36use rustc_target::spec::{Arch, Os};37use rustc_trait_selection::infer::{BoundRegionConversionTime, TyCtxtInferExt};38use rustc_trait_selection::traits::{ObligationCause, ObligationCtxt};39use tracing::{debug, info};4041use crate::assert_module_sources::CguReuse;42use crate::back::link::are_upstream_rust_objects_already_included;43use crate::back::write::{44    ComputedLtoType, OngoingCodegen, compute_per_cgu_lto_type, start_async_codegen,45    submit_codegened_module_to_llvm, submit_post_lto_module_to_llvm, submit_pre_lto_module_to_llvm,46};47use crate::common::{self, IntPredicate, RealPredicate, TypeKind};48use crate::meth::load_vtable;49use crate::mir::operand::OperandValue;50use crate::mir::place::PlaceRef;51use crate::traits::*;52use crate::{53    CachedModuleCodegen, CodegenLintLevelSpecs, CrateInfo, ModuleCodegen, errors, meth, mir,54};5556pub(crate) fn bin_op_to_icmp_predicate(op: BinOp, signed: bool) -> IntPredicate {57    match (op, signed) {58        (BinOp::Eq, _) => IntPredicate::IntEQ,59        (BinOp::Ne, _) => IntPredicate::IntNE,60        (BinOp::Lt, true) => IntPredicate::IntSLT,61        (BinOp::Lt, false) => IntPredicate::IntULT,62        (BinOp::Le, true) => IntPredicate::IntSLE,63        (BinOp::Le, false) => IntPredicate::IntULE,64        (BinOp::Gt, true) => IntPredicate::IntSGT,65        (BinOp::Gt, false) => IntPredicate::IntUGT,66        (BinOp::Ge, true) => IntPredicate::IntSGE,67        (BinOp::Ge, false) => IntPredicate::IntUGE,68        op => bug!("bin_op_to_icmp_predicate: expected comparison operator, found {:?}", op),69    }70}7172pub(crate) fn bin_op_to_fcmp_predicate(op: BinOp) -> RealPredicate {73    match op {74        BinOp::Eq => RealPredicate::RealOEQ,75        BinOp::Ne => RealPredicate::RealUNE,76        BinOp::Lt => RealPredicate::RealOLT,77        BinOp::Le => RealPredicate::RealOLE,78        BinOp::Gt => RealPredicate::RealOGT,79        BinOp::Ge => RealPredicate::RealOGE,80        op => bug!("bin_op_to_fcmp_predicate: expected comparison operator, found {:?}", op),81    }82}8384pub fn compare_simd_types<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(85    bx: &mut Bx,86    lhs: Bx::Value,87    rhs: Bx::Value,88    t: Ty<'tcx>,89    ret_ty: Bx::Type,90    op: BinOp,91) -> Bx::Value {92    let signed = match t.kind() {93        ty::Float(_) => {94            let cmp = bin_op_to_fcmp_predicate(op);95            let cmp = bx.fcmp(cmp, lhs, rhs);96            return bx.sext(cmp, ret_ty);97        }98        ty::Uint(_) => false,99        ty::Int(_) => true,100        _ => bug!("compare_simd_types: invalid SIMD type"),101    };102103    let cmp = bin_op_to_icmp_predicate(op, signed);104    let cmp = bx.icmp(cmp, lhs, rhs);105    // LLVM outputs an `< size x i1 >`, so we need to perform a sign extension106    // to get the correctly sized type. This will compile to a single instruction107    // once the IR is converted to assembly if the SIMD instruction is supported108    // by the target architecture.109    bx.sext(cmp, ret_ty)110}111112/// Codegen takes advantage of the additional assumption, where if the113/// principal trait def id of what's being casted doesn't change,114/// then we don't need to adjust the vtable at all. This115/// corresponds to the fact that `dyn Tr<A>: Unsize<dyn Tr<B>>`116/// requires that `A = B`; we don't allow *upcasting* objects117/// between the same trait with different args. If we, for118/// some reason, were to relax the `Unsize` trait, it could become119/// unsound, so let's validate here that the trait refs are subtypes.120pub fn validate_trivial_unsize<'tcx>(121    tcx: TyCtxt<'tcx>,122    source_data: &'tcx ty::List<ty::PolyExistentialPredicate<'tcx>>,123    target_data: &'tcx ty::List<ty::PolyExistentialPredicate<'tcx>>,124) -> bool {125    match (source_data.principal(), target_data.principal()) {126        (Some(hr_source_principal), Some(hr_target_principal)) => {127            let (infcx, param_env) =128                tcx.infer_ctxt().build_with_typing_env(ty::TypingEnv::fully_monomorphized());129            let universe = infcx.universe();130            let ocx = ObligationCtxt::new(&infcx);131            infcx.enter_forall(hr_target_principal, |target_principal| {132                let source_principal = infcx.instantiate_binder_with_fresh_vars(133                    DUMMY_SP,134                    BoundRegionConversionTime::HigherRankedType,135                    hr_source_principal,136                );137                let Ok(()) = ocx.eq(138                    &ObligationCause::dummy(),139                    param_env,140                    target_principal,141                    source_principal,142                ) else {143                    return false;144                };145                if !ocx.evaluate_obligations_error_on_ambiguity().is_empty() {146                    return false;147                }148                infcx.leak_check(universe, None).is_ok()149            })150        }151        (_, None) => true,152        _ => false,153    }154}155156/// Retrieves the information we are losing (making dynamic) in an unsizing157/// adjustment.158///159/// The `old_info` argument is a bit odd. It is intended for use in an upcast,160/// where the new vtable for an object will be derived from the old one.161fn unsized_info<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(162    bx: &mut Bx,163    source: Ty<'tcx>,164    target: Ty<'tcx>,165    old_info: Option<Bx::Value>,166) -> Bx::Value {167    let cx = bx.cx();168    let (source, target) =169        cx.tcx().struct_lockstep_tails_for_codegen(source, target, bx.typing_env());170    match (source.kind(), target.kind()) {171        (&ty::Array(_, len), &ty::Slice(_)) => cx.const_usize(172            len.try_to_target_usize(cx.tcx()).expect("expected monomorphic const in codegen"),173        ),174        (&ty::Dynamic(data_a, _), &ty::Dynamic(data_b, _)) => {175            let old_info =176                old_info.expect("unsized_info: missing old info for trait upcasting coercion");177            let b_principal_def_id = data_b.principal_def_id();178            if data_a.principal_def_id() == b_principal_def_id || b_principal_def_id.is_none() {179                // Codegen takes advantage of the additional assumption, where if the180                // principal trait def id of what's being casted doesn't change,181                // then we don't need to adjust the vtable at all. This182                // corresponds to the fact that `dyn Tr<A>: Unsize<dyn Tr<B>>`183                // requires that `A = B`; we don't allow *upcasting* objects184                // between the same trait with different args. If we, for185                // some reason, were to relax the `Unsize` trait, it could become186                // unsound, so let's assert here that the trait refs are *equal*.187                debug_assert!(188                    validate_trivial_unsize(cx.tcx(), data_a, data_b),189                    "NOP unsize vtable changed principal trait ref: {data_a} -> {data_b}"190                );191192                // A NOP cast that doesn't actually change anything, let's avoid any193                // unnecessary work. This relies on the assumption that if the principal194                // traits are equal, then the associated type bounds (`dyn Trait<Assoc=T>`)195                // are also equal, which is ensured by the fact that normalization is196                // a function and we do not allow overlapping impls.197                return old_info;198            }199200            // trait upcasting coercion201202            let vptr_entry_idx = cx.tcx().supertrait_vtable_slot((source, target));203204            if let Some(entry_idx) = vptr_entry_idx {205                let ptr_size = bx.data_layout().pointer_size();206                let vtable_byte_offset = u64::try_from(entry_idx).unwrap() * ptr_size.bytes();207                load_vtable(bx, old_info, bx.type_ptr(), vtable_byte_offset, source, true)208            } else {209                old_info210            }211        }212        (_, ty::Dynamic(data, _)) => meth::get_vtable(213            cx,214            source,215            data.principal()216                .map(|principal| bx.tcx().instantiate_bound_regions_with_erased(principal)),217        ),218        _ => bug!("unsized_info: invalid unsizing {:?} -> {:?}", source, target),219    }220}221222/// Coerces `src` to `dst_ty`. `src_ty` must be a pointer.223pub(crate) fn unsize_ptr<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(224    bx: &mut Bx,225    src: Bx::Value,226    src_ty: Ty<'tcx>,227    dst_ty: Ty<'tcx>,228    old_info: Option<Bx::Value>,229) -> (Bx::Value, Bx::Value) {230    debug!("unsize_ptr: {:?} => {:?}", src_ty, dst_ty);231    match (src_ty.kind(), dst_ty.kind()) {232        (&ty::Pat(a, _), &ty::Pat(b, _)) => unsize_ptr(bx, src, a, b, old_info),233        (&ty::Ref(_, a, _), &ty::Ref(_, b, _) | &ty::RawPtr(b, _))234        | (&ty::RawPtr(a, _), &ty::RawPtr(b, _)) => {235            assert_eq!(bx.cx().type_is_sized(a), old_info.is_none());236            (src, unsized_info(bx, a, b, old_info))237        }238        (&ty::Adt(def_a, _), &ty::Adt(def_b, _)) => {239            assert_eq!(def_a, def_b); // implies same number of fields240            let src_layout = bx.cx().layout_of(src_ty);241            let dst_layout = bx.cx().layout_of(dst_ty);242            if src_ty == dst_ty {243                return (src, old_info.unwrap());244            }245            let mut result = None;246            for i in 0..src_layout.fields.count() {247                let src_f = src_layout.field(bx.cx(), i);248                if src_f.is_1zst() {249                    // We are looking for the one non-1-ZST field; this is not it.250                    continue;251                }252253                assert_eq!(src_layout.fields.offset(i).bytes(), 0);254                assert_eq!(dst_layout.fields.offset(i).bytes(), 0);255                assert_eq!(src_layout.size, src_f.size);256257                let dst_f = dst_layout.field(bx.cx(), i);258                assert_ne!(src_f.ty, dst_f.ty);259                assert_eq!(result, None);260                result = Some(unsize_ptr(bx, src, src_f.ty, dst_f.ty, old_info));261            }262            result.unwrap()263        }264        _ => bug!("unsize_ptr: called on bad types"),265    }266}267268/// Coerces `src`, which is a reference to a value of type `src_ty`,269/// to a value of type `dst_ty`, and stores the result in `dst`.270pub(crate) fn coerce_unsized_into<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(271    bx: &mut Bx,272    src: PlaceRef<'tcx, Bx::Value>,273    dst: PlaceRef<'tcx, Bx::Value>,274) {275    let src_ty = src.layout.ty;276    let dst_ty = dst.layout.ty;277    match (src_ty.kind(), dst_ty.kind()) {278        (&ty::Pat(s, sp), &ty::Pat(d, dp))279            if let (PatternKind::NotNull, PatternKind::NotNull) = (*sp, *dp) =>280        {281            let src = src.project_type(bx, s);282            let dst = dst.project_type(bx, d);283            coerce_unsized_into(bx, src, dst)284        }285        (&ty::Ref(..), &ty::Ref(..) | &ty::RawPtr(..)) | (&ty::RawPtr(..), &ty::RawPtr(..)) => {286            let (base, info) = match bx.load_operand(src).val {287                OperandValue::Pair(base, info) => unsize_ptr(bx, base, src_ty, dst_ty, Some(info)),288                OperandValue::Immediate(base) => unsize_ptr(bx, base, src_ty, dst_ty, None),289                OperandValue::Ref(..) | OperandValue::ZeroSized => bug!(),290            };291            OperandValue::Pair(base, info).store(bx, dst);292        }293294        (&ty::Adt(def_a, _), &ty::Adt(def_b, _)) => {295            assert_eq!(def_a, def_b); // implies same number of fields296297            for i in def_a.variant(FIRST_VARIANT).fields.indices() {298                let src_f = src.project_field(bx, i.as_usize());299                let dst_f = dst.project_field(bx, i.as_usize());300301                if dst_f.layout.is_zst() {302                    // No data here, nothing to copy/coerce.303                    continue;304                }305306                if src_f.layout.ty == dst_f.layout.ty {307                    bx.typed_place_copy(dst_f.val, src_f.val, src_f.layout);308                } else {309                    coerce_unsized_into(bx, src_f, dst_f);310                }311            }312        }313        _ => bug!("coerce_unsized_into: invalid coercion {:?} -> {:?}", src_ty, dst_ty,),314    }315}316317/// Returns `rhs` sufficiently masked, truncated, and/or extended so that it can be used to shift318/// `lhs`: it has the same size as `lhs`, and the value, when interpreted unsigned (no matter its319/// type), will not exceed the size of `lhs`.320///321/// Shifts in MIR are all allowed to have mismatched LHS & RHS types, and signed RHS.322/// The shift methods in `BuilderMethods`, however, are fully homogeneous323/// (both parameters and the return type are all the same size) and assume an unsigned RHS.324///325/// If `is_unchecked` is false, this masks the RHS to ensure it stays in-bounds,326/// as the `BuilderMethods` shifts are UB for out-of-bounds shift amounts.327/// For 32- and 64-bit types, this matches the semantics328/// of Java. (See related discussion on #1877 and #10183.)329///330/// If `is_unchecked` is true, this does no masking, and adds sufficient `assume`331/// calls or operation flags to preserve as much freedom to optimize as possible.332pub(crate) fn build_shift_expr_rhs<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(333    bx: &mut Bx,334    lhs: Bx::Value,335    mut rhs: Bx::Value,336    is_unchecked: bool,337) -> Bx::Value {338    // Shifts may have any size int on the rhs339    let mut rhs_llty = bx.cx().val_ty(rhs);340    let mut lhs_llty = bx.cx().val_ty(lhs);341342    let mask = common::shift_mask_val(bx, lhs_llty, rhs_llty, false);343    if !is_unchecked {344        rhs = bx.and(rhs, mask);345    }346347    if bx.cx().type_kind(rhs_llty) == TypeKind::Vector {348        rhs_llty = bx.cx().element_type(rhs_llty)349    }350    if bx.cx().type_kind(lhs_llty) == TypeKind::Vector {351        lhs_llty = bx.cx().element_type(lhs_llty)352    }353    let rhs_sz = bx.cx().int_width(rhs_llty);354    let lhs_sz = bx.cx().int_width(lhs_llty);355    if lhs_sz < rhs_sz {356        if is_unchecked { bx.unchecked_utrunc(rhs, lhs_llty) } else { bx.trunc(rhs, lhs_llty) }357    } else if lhs_sz > rhs_sz {358        // We zero-extend even if the RHS is signed. So e.g. `(x: i32) << -1i8` will zero-extend the359        // RHS to `255i32`. But then we mask the shift amount to be within the size of the LHS360        // anyway so the result is `31` as it should be. All the extra bits introduced by zext361        // are masked off so their value does not matter.362        // FIXME: if we ever support 512bit integers, this will be wrong! For such large integers,363        // the extra bits introduced by zext are *not* all masked away any more.364        assert!(lhs_sz <= 256);365        bx.zext(rhs, lhs_llty)366    } else {367        rhs368    }369}370371// Returns `true` if this session's target will use native wasm372// exceptions. This means that the VM does the unwinding for373// us374pub fn wants_wasm_eh(sess: &Session) -> bool {375    sess.target.is_like_wasm376}377378/// Returns `true` if this session's target will use SEH-based unwinding.379///380/// This is only true for MSVC targets, and even then the 64-bit MSVC target381/// currently uses SEH-ish unwinding with DWARF info tables to the side (same as382/// 64-bit MinGW) instead of "full SEH".383pub fn wants_msvc_seh(sess: &Session) -> bool {384    sess.target.is_like_msvc385}386387/// Returns `true` if this session's target requires the new exception388/// handling LLVM IR instructions (catchpad / cleanuppad / ... instead389/// of landingpad)390pub(crate) fn wants_new_eh_instructions(sess: &Session) -> bool {391    wants_wasm_eh(sess) || wants_msvc_seh(sess)392}393394pub(crate) fn codegen_instance<'a, 'tcx: 'a, Bx: BuilderMethods<'a, 'tcx>>(395    cx: &'a Bx::CodegenCx,396    instance: Instance<'tcx>,397) {398    // this is an info! to allow collecting monomorphization statistics399    // and to allow finding the last function before LLVM aborts from400    // release builds.401    info!("codegen_instance({})", instance);402403    mir::codegen_mir::<Bx>(cx, instance);404}405406pub fn codegen_global_asm<'tcx, Cx>(cx: &mut Cx, item_id: ItemId)407where408    Cx: LayoutOf<'tcx, LayoutOfResult = TyAndLayout<'tcx>> + AsmCodegenMethods<'tcx>,409{410    let item = cx.tcx().hir_item(item_id);411    if let rustc_hir::ItemKind::GlobalAsm { asm, .. } = item.kind {412        let operands: Vec<_> = asm413            .operands414            .iter()415            .map(|(op, op_sp)| match *op {416                rustc_hir::InlineAsmOperand::Const { ref anon_const } => {417                    match cx.tcx().const_eval_poly(anon_const.def_id.to_def_id()) {418                        Ok(const_value) => {419                            let ty =420                                cx.tcx().typeck_body(anon_const.body).node_type(anon_const.hir_id);421                            let string = common::asm_const_to_str(422                                cx.tcx(),423                                *op_sp,424                                const_value,425                                cx.layout_of(ty),426                            );427                            GlobalAsmOperandRef::Const { string }428                        }429                        Err(ErrorHandled::Reported { .. }) => {430                            // An error has already been reported and431                            // compilation is guaranteed to fail if execution432                            // hits this path. So an empty string instead of433                            // a stringified constant value will suffice.434                            GlobalAsmOperandRef::Const { string: String::new() }435                        }436                        Err(ErrorHandled::TooGeneric(_)) => {437                            span_bug!(*op_sp, "asm const cannot be resolved; too generic")438                        }439                    }440                }441                rustc_hir::InlineAsmOperand::SymFn { expr } => {442                    let ty = cx.tcx().typeck(item_id.owner_id).expr_ty(expr);443                    let instance = match ty.kind() {444                        &ty::FnDef(def_id, args) => Instance::expect_resolve(445                            cx.tcx(),446                            ty::TypingEnv::fully_monomorphized(),447                            def_id,448                            args,449                            expr.span,450                        ),451                        _ => span_bug!(*op_sp, "asm sym is not a function"),452                    };453454                    GlobalAsmOperandRef::SymFn { instance }455                }456                rustc_hir::InlineAsmOperand::SymStatic { path: _, def_id } => {457                    GlobalAsmOperandRef::SymStatic { def_id }458                }459                rustc_hir::InlineAsmOperand::In { .. }460                | rustc_hir::InlineAsmOperand::Out { .. }461                | rustc_hir::InlineAsmOperand::InOut { .. }462                | rustc_hir::InlineAsmOperand::SplitInOut { .. }463                | rustc_hir::InlineAsmOperand::Label { .. } => {464                    span_bug!(*op_sp, "invalid operand type for global_asm!")465                }466            })467            .collect();468469        cx.codegen_global_asm(asm.template, &operands, asm.options, asm.line_spans);470    } else {471        span_bug!(item.span, "Mismatch between hir::Item type and MonoItem type")472    }473}474475/// Creates the `main` function which will initialize the rust runtime and call476/// users main function.477pub fn maybe_create_entry_wrapper<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(478    cx: &'a Bx::CodegenCx,479    cgu: &CodegenUnit<'tcx>,480) -> Option<Bx::Function> {481    let (main_def_id, entry_type) = cx.tcx().entry_fn(())?;482    let main_is_local = main_def_id.is_local();483    let instance = Instance::mono(cx.tcx(), main_def_id);484485    if main_is_local {486        // We want to create the wrapper in the same codegen unit as Rust's main487        // function.488        if !cgu.contains_item(&MonoItem::Fn(instance)) {489            return None;490        }491    } else if !cgu.is_primary() {492        // We want to create the wrapper only when the codegen unit is the primary one493        return None;494    }495496    let main_llfn = cx.get_fn_addr(instance);497498    let entry_fn = create_entry_fn::<Bx>(cx, main_llfn, main_def_id, entry_type);499    return Some(entry_fn);500501    fn create_entry_fn<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(502        cx: &'a Bx::CodegenCx,503        rust_main: Bx::Value,504        rust_main_def_id: DefId,505        entry_type: EntryFnType,506    ) -> Bx::Function {507        // The entry function is either `int main(void)` or `int main(int argc, char **argv)`, or508        // `usize efi_main(void *handle, void *system_table)` depending on the target.509        let llfty = if cx.sess().target.os == Os::Uefi {510            cx.type_func(&[cx.type_ptr(), cx.type_ptr()], cx.type_isize())511        } else if cx.sess().target.main_needs_argc_argv {512            cx.type_func(&[cx.type_int(), cx.type_ptr()], cx.type_int())513        } else {514            cx.type_func(&[], cx.type_int())515        };516517        let main_ret_ty = cx.tcx().fn_sig(rust_main_def_id).no_bound_vars().unwrap().output();518        // Given that `main()` has no arguments,519        // then its return type cannot have520        // late-bound regions, since late-bound521        // regions must appear in the argument522        // listing.523        let main_ret_ty = cx.tcx().normalize_erasing_regions(524            cx.typing_env(),525            Unnormalized::new_wip(main_ret_ty.no_bound_vars().unwrap()),526        );527528        let Some(llfn) = cx.declare_c_main(llfty) else {529            // FIXME: We should be smart and show a better diagnostic here.530            let span = cx.tcx().def_span(rust_main_def_id);531            cx.tcx().dcx().emit_fatal(errors::MultipleMainFunctions { span });532        };533534        // `main` should respect same config for frame pointer elimination as rest of code535        cx.set_frame_pointer_type(llfn);536        cx.apply_target_cpu_attr(llfn);537538        let llbb = Bx::append_block(cx, llfn, "top");539        let mut bx = Bx::build(cx, llbb);540541        bx.insert_reference_to_gdb_debug_scripts_section_global();542543        let isize_ty = cx.type_isize();544        let ptr_ty = cx.type_ptr();545        let (arg_argc, arg_argv) = get_argc_argv(&mut bx);546547        let EntryFnType::Main { sigpipe } = entry_type;548        let (start_fn, start_ty, args, instance) = {549            let start_def_id = cx.tcx().require_lang_item(LangItem::Start, DUMMY_SP);550            let start_instance = ty::Instance::expect_resolve(551                cx.tcx(),552                cx.typing_env(),553                start_def_id,554                cx.tcx().mk_args(&[main_ret_ty.into()]),555                DUMMY_SP,556            );557            let start_fn = cx.get_fn_addr(start_instance);558559            let i8_ty = cx.type_i8();560            let arg_sigpipe = bx.const_u8(sigpipe);561562            let start_ty = cx.type_func(&[cx.val_ty(rust_main), isize_ty, ptr_ty, i8_ty], isize_ty);563            (564                start_fn,565                start_ty,566                vec![rust_main, arg_argc, arg_argv, arg_sigpipe],567                Some(start_instance),568            )569        };570571        let result = bx.call(start_ty, None, None, start_fn, &args, None, instance);572        if cx.sess().target.os == Os::Uefi {573            bx.ret(result);574        } else {575            let cast = bx.intcast(result, cx.type_int(), true);576            bx.ret(cast);577        }578579        llfn580    }581}582583/// Obtain the `argc` and `argv` values to pass to the rust start function584/// (i.e., the "start" lang item).585fn get_argc_argv<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(bx: &mut Bx) -> (Bx::Value, Bx::Value) {586    if bx.cx().sess().target.os == Os::Uefi {587        // Params for UEFI588        let param_handle = bx.get_param(0);589        let param_system_table = bx.get_param(1);590        let ptr_size = bx.tcx().data_layout.pointer_size();591        let ptr_align = bx.tcx().data_layout.pointer_align().abi;592        let arg_argc = bx.const_int(bx.cx().type_isize(), 2);593        let arg_argv = bx.alloca(2 * ptr_size, ptr_align);594        bx.store(param_handle, arg_argv, ptr_align);595        let arg_argv_el1 = bx.inbounds_ptradd(arg_argv, bx.const_usize(ptr_size.bytes()));596        bx.store(param_system_table, arg_argv_el1, ptr_align);597        (arg_argc, arg_argv)598    } else if bx.cx().sess().target.main_needs_argc_argv {599        // Params from native `main()` used as args for rust start function600        let param_argc = bx.get_param(0);601        let param_argv = bx.get_param(1);602        let arg_argc = bx.intcast(param_argc, bx.cx().type_isize(), true);603        let arg_argv = param_argv;604        (arg_argc, arg_argv)605    } else {606        // The Rust start function doesn't need `argc` and `argv`, so just pass zeros.607        let arg_argc = bx.const_int(bx.cx().type_int(), 0);608        let arg_argv = bx.const_null(bx.cx().type_ptr());609        (arg_argc, arg_argv)610    }611}612613/// This function returns all of the debugger visualizers specified for the614/// current crate as well as all upstream crates transitively that match the615/// `visualizer_type` specified.616pub fn collect_debugger_visualizers_transitive(617    tcx: TyCtxt<'_>,618    visualizer_type: DebuggerVisualizerType,619) -> BTreeSet<DebuggerVisualizerFile> {620    tcx.debugger_visualizers(LOCAL_CRATE)621        .iter()622        .chain(623            tcx.crates(())624                .iter()625                .filter(|&cnum| {626                    let used_crate_source = tcx.used_crate_source(*cnum);627                    used_crate_source.rlib.is_some() || used_crate_source.rmeta.is_some()628                })629                .flat_map(|&cnum| tcx.debugger_visualizers(cnum)),630        )631        .filter(|visualizer| visualizer.visualizer_type == visualizer_type)632        .cloned()633        .collect::<BTreeSet<_>>()634}635636/// Decide allocator kind to codegen. If `Some(_)` this will be the same as637/// `tcx.allocator_kind`, but it may be `None` in more cases (e.g. if using638/// allocator definitions from a dylib dependency).639pub fn allocator_kind_for_codegen(tcx: TyCtxt<'_>) -> Option<AllocatorKind> {640    // If the crate doesn't have an `allocator_kind` set then there's definitely641    // no shim to generate. Otherwise we also check our dependency graph for all642    // our output crate types. If anything there looks like its a `Dynamic`643    // linkage for all crate types we may link as, then it's already got an644    // allocator shim and we'll be using that one instead. If nothing exists645    // then it's our job to generate the allocator! If crate types disagree646    // about whether an allocator shim is necessary or not, we generate one647    // and let needs_allocator_shim_for_linking decide at link time whether or648    // not to use it for any particular linker invocation.649    let all_crate_types_any_dynamic_crate = tcx.dependency_formats(()).iter().all(|(_, list)| {650        use rustc_middle::middle::dependency_format::Linkage;651        list.iter().any(|&linkage| linkage == Linkage::Dynamic)652    });653    if all_crate_types_any_dynamic_crate { None } else { tcx.allocator_kind(()) }654}655656/// Decide if this particular crate type needs an allocator shim linked in.657/// This may return true even when allocator_kind_for_codegen returns false. In658/// this case no allocator shim shall be linked.659pub(crate) fn needs_allocator_shim_for_linking(660    dependency_formats: &Dependencies,661    crate_type: CrateType,662) -> bool {663    use rustc_middle::middle::dependency_format::Linkage;664    let any_dynamic_crate =665        dependency_formats[&crate_type].iter().any(|&linkage| linkage == Linkage::Dynamic);666    !any_dynamic_crate667}668669pub fn allocator_shim_contents(tcx: TyCtxt<'_>, kind: AllocatorKind) -> Vec<AllocatorMethod> {670    let mut methods = Vec::new();671672    if kind == AllocatorKind::Default {673        methods.extend(ALLOCATOR_METHODS.into_iter().copied());674    }675676    // If the return value of allocator_kind_for_codegen is Some then677    // alloc_error_handler_kind must also be Some.678    if tcx.alloc_error_handler_kind(()).unwrap() == AllocatorKind::Default {679        methods.push(AllocatorMethod {680            name: ALLOC_ERROR_HANDLER,681            special: None,682            inputs: &[AllocatorMethodInput { name: "layout", ty: AllocatorTy::Layout }],683            output: AllocatorTy::Never,684        });685    }686687    methods688}689690pub fn codegen_crate<691    B: ExtraBackendMethods<Module = M> + WriteBackendMethods<Module = M>,692    M: Send,693>(694    backend: B,695    tcx: TyCtxt<'_>,696) -> OngoingCodegen<B> {697    if tcx.sess.target.need_explicit_cpu && tcx.sess.opts.cg.target_cpu.is_none() {698        // The target has no default cpu, but none is set explicitly699        tcx.dcx().emit_fatal(errors::CpuRequired);700    }701702    if let Some(target_cpu) = &tcx.sess.opts.cg.target_cpu703        && tcx.sess.target.unsupported_cpus.contains(&target_cpu.into())704    {705        // The target cpu is explicitly listed as an unsupported cpu706        tcx.dcx().emit_fatal(errors::CpuUnsupported { target_cpu: target_cpu.clone() });707    }708709    let cgu_name_builder = &mut CodegenUnitNameBuilder::new(tcx);710711    // Run the monomorphization collector and partition the collected items into712    // codegen units.713    let MonoItemPartitions { codegen_units, .. } = tcx.collect_and_partition_mono_items(());714715    // Force all codegen_unit queries so they are already either red or green716    // when compile_codegen_unit accesses them. We are not able to re-execute717    // the codegen_unit query from just the DepNode, so an unknown color would718    // lead to having to re-execute compile_codegen_unit, possibly719    // unnecessarily.720    if tcx.dep_graph.is_fully_enabled() {721        for cgu in codegen_units {722            tcx.ensure_ok().codegen_unit(cgu.name());723        }724    }725726    // Codegen an allocator shim, if necessary.727    let allocator_module = if let Some(kind) = allocator_kind_for_codegen(tcx) {728        let llmod_id =729            cgu_name_builder.build_cgu_name(LOCAL_CRATE, &["crate"], Some("allocator")).to_string();730731        tcx.sess.time("write_allocator_module", || {732            let module =733                backend.codegen_allocator(tcx, &llmod_id, &allocator_shim_contents(tcx, kind));734            Some(ModuleCodegen::new_allocator(llmod_id, module))735        })736    } else {737        None738    };739740    let ongoing_codegen = start_async_codegen(backend.clone(), tcx, allocator_module);741742    // For better throughput during parallel processing by LLVM, we used to sort743    // CGUs largest to smallest. This would lead to better thread utilization744    // by, for example, preventing a large CGU from being processed last and745    // having only one LLVM thread working while the rest remained idle.746    //747    // However, this strategy would lead to high memory usage, as it meant the748    // LLVM-IR for all of the largest CGUs would be resident in memory at once.749    //750    // Instead, we can compromise by ordering CGUs such that the largest and751    // smallest are first, second largest and smallest are next, etc. If there752    // are large size variations, this can reduce memory usage significantly.753    let codegen_units: Vec<_> = {754        let mut sorted_cgus = codegen_units.iter().collect::<Vec<_>>();755        sorted_cgus.sort_by_key(|cgu| cmp::Reverse(cgu.size_estimate()));756757        let (first_half, second_half) = sorted_cgus.split_at(sorted_cgus.len() / 2);758        first_half.iter().interleave(second_half.iter().rev()).copied().collect()759    };760761    // Calculate the CGU reuse762    let cgu_reuse = tcx.sess.time("find_cgu_reuse", || {763        codegen_units.iter().map(|cgu| determine_cgu_reuse(tcx, cgu)).collect::<Vec<_>>()764    });765766    crate::assert_module_sources::assert_module_sources(tcx, &|cgu_reuse_tracker| {767        for (i, cgu) in codegen_units.iter().enumerate() {768            let cgu_reuse = cgu_reuse[i];769            cgu_reuse_tracker.set_actual_reuse(cgu.name().as_str(), cgu_reuse);770        }771    });772773    let mut total_codegen_time = Duration::new(0, 0);774    let start_rss = tcx.sess.opts.unstable_opts.time_passes.then(|| get_resident_set_size());775776    // The non-parallel compiler can only translate codegen units to LLVM IR777    // on a single thread, leading to a staircase effect where the N LLVM778    // threads have to wait on the single codegen threads to generate work779    // for them. The parallel compiler does not have this restriction, so780    // we can pre-load the LLVM queue in parallel before handing off781    // coordination to the OnGoingCodegen scheduler.782    //783    // This likely is a temporary measure. Once we don't have to support the784    // non-parallel compiler anymore, we can compile CGUs end-to-end in785    // parallel and get rid of the complicated scheduling logic.786    let mut pre_compiled_cgus = if let Some(threads) = tcx.sess.threads() {787        tcx.sess.time("compile_first_CGU_batch", || {788            // Try to find one CGU to compile per thread.789            let cgus: Vec<_> = cgu_reuse790                .iter()791                .enumerate()792                .filter(|&(_, reuse)| reuse == &CguReuse::No)793                .take(threads)794                .collect();795796            // Compile the found CGUs in parallel.797            let start_time = Instant::now();798799            let pre_compiled_cgus = par_map(cgus, |(i, _)| {800                let module = backend.compile_codegen_unit(tcx, codegen_units[i].name());801                (i, IntoDynSyncSend(module))802            });803804            total_codegen_time += start_time.elapsed();805806            pre_compiled_cgus807        })808    } else {809        FxHashMap::default()810    };811812    for (i, cgu) in codegen_units.iter().enumerate() {813        ongoing_codegen.wait_for_signal_to_codegen_item();814        ongoing_codegen.check_for_errors(tcx.sess);815816        let cgu_reuse = cgu_reuse[i];817818        match cgu_reuse {819            CguReuse::No => {820                let (module, cost) = if let Some(cgu) = pre_compiled_cgus.remove(&i) {821                    cgu.0822                } else {823                    let start_time = Instant::now();824                    let module = backend.compile_codegen_unit(tcx, cgu.name());825                    total_codegen_time += start_time.elapsed();826                    module827                };828                // This will unwind if there are errors, which triggers our `AbortCodegenOnDrop`829                // guard. Unfortunately, just skipping the `submit_codegened_module_to_llvm` makes830                // compilation hang on post-monomorphization errors.831                tcx.dcx().abort_if_errors();832833                submit_codegened_module_to_llvm(&ongoing_codegen.coordinator, module, cost);834            }835            CguReuse::PreLto => {836                submit_pre_lto_module_to_llvm(837                    tcx,838                    &ongoing_codegen.coordinator,839                    CachedModuleCodegen {840                        name: cgu.name().to_string(),841                        source: cgu.previous_work_product(tcx),842                    },843                );844            }845            CguReuse::PostLto => {846                submit_post_lto_module_to_llvm(847                    &ongoing_codegen.coordinator,848                    CachedModuleCodegen {849                        name: cgu.name().to_string(),850                        source: cgu.previous_work_product(tcx),851                    },852                );853            }854        }855    }856857    ongoing_codegen.codegen_finished(tcx);858859    // Since the main thread is sometimes blocked during codegen, we keep track860    // -Ztime-passes output manually.861    if tcx.sess.opts.unstable_opts.time_passes {862        let end_rss = get_resident_set_size();863864        print_time_passes_entry(865            "codegen_to_LLVM_IR",866            total_codegen_time,867            start_rss.unwrap(),868            end_rss,869            tcx.sess.opts.unstable_opts.time_passes_format,870        );871    }872873    ongoing_codegen.check_for_errors(tcx.sess);874    ongoing_codegen875}876877/// Returns whether a call from the current crate to the [`Instance`] would produce a call878/// from `compiler_builtins` to a symbol the linker must resolve.879///880/// Such calls from `compiler_bultins` are effectively impossible for the linker to handle. Some881/// linkers will optimize such that dead calls to unresolved symbols are not an error, but this is882/// not guaranteed. So we used this function in codegen backends to ensure we do not generate any883/// unlinkable calls.884///885/// Note that calls to LLVM intrinsics are uniquely okay because they won't make it to the linker.886pub fn is_call_from_compiler_builtins_to_upstream_monomorphization<'tcx>(887    tcx: TyCtxt<'tcx>,888    instance: Instance<'tcx>,889) -> bool {890    fn is_llvm_intrinsic(tcx: TyCtxt<'_>, def_id: DefId) -> bool {891        if let Some(name) = tcx.codegen_fn_attrs(def_id).symbol_name {892            name.as_str().starts_with("llvm.")893        } else {894            false895        }896    }897898    let def_id = instance.def_id();899    !def_id.is_local()900        && tcx.is_compiler_builtins(LOCAL_CRATE)901        && !is_llvm_intrinsic(tcx, def_id)902        && !tcx.should_codegen_locally(instance)903}904905impl CrateInfo {906    pub fn new(tcx: TyCtxt<'_>, target_cpu: String) -> CrateInfo {907        let crate_types = tcx.crate_types().to_vec();908        let exported_symbols = crate_types909            .iter()910            .map(|&c| (c, crate::back::linker::exported_symbols(tcx, c)))911            .collect();912        let linked_symbols =913            crate_types.iter().map(|&c| (c, crate::back::linker::linked_symbols(tcx, c))).collect();914        let local_crate_name = tcx.crate_name(LOCAL_CRATE);915        let windows_subsystem = find_attr!(tcx, crate, WindowsSubsystem(kind) => *kind);916917        // This list is used when generating the command line to pass through to918        // system linker. The linker expects undefined symbols on the left of the919        // command line to be defined in libraries on the right, not the other way920        // around. For more info, see some comments in the add_used_library function921        // below.922        //923        // In order to get this left-to-right dependency ordering, we use the reverse924        // postorder of all crates putting the leaves at the rightmost positions.925        let mut compiler_builtins = None;926        let mut used_crates: Vec<_> = tcx927            .postorder_cnums(())928            .iter()929            .rev()930            .copied()931            .filter(|&cnum| {932                let link = !tcx.crate_dep_kind(cnum).macros_only();933                if link && tcx.is_compiler_builtins(cnum) {934                    compiler_builtins = Some(cnum);935                    return false;936                }937                link938            })939            .collect();940        // `compiler_builtins` are always placed last to ensure that they're linked correctly.941        used_crates.extend(compiler_builtins);942943        let crates = tcx.crates(());944        let n_crates = crates.len();945        let mut info = CrateInfo {946            target_cpu,947            target_features: tcx.global_backend_features(()).clone(),948            crate_types,949            exported_symbols,950            linked_symbols,951            local_crate_name,952            compiler_builtins,953            profiler_runtime: None,954            is_no_builtins: Default::default(),955            native_libraries: Default::default(),956            used_libraries: tcx.native_libraries(LOCAL_CRATE).iter().map(Into::into).collect(),957            crate_name: UnordMap::with_capacity(n_crates),958            used_crates,959            used_crate_source: UnordMap::with_capacity(n_crates),960            dependency_formats: Arc::clone(tcx.dependency_formats(())),961            windows_subsystem,962            natvis_debugger_visualizers: Default::default(),963            lint_level_specs: CodegenLintLevelSpecs::from_tcx(tcx),964            metadata_symbol: exported_symbols::metadata_symbol_name(tcx),965            symbol_rename_suffix: format!(".rs{:x}", tcx.stable_crate_id(LOCAL_CRATE)),966            each_linked_rlib_file_for_lto: Default::default(),967            exported_symbols_for_lto: Default::default(),968        };969970        info.native_libraries.reserve(n_crates);971972        for &cnum in crates.iter() {973            info.native_libraries974                .insert(cnum, tcx.native_libraries(cnum).iter().map(Into::into).collect());975            info.crate_name.insert(cnum, tcx.crate_name(cnum));976977            let used_crate_source = tcx.used_crate_source(cnum);978            info.used_crate_source.insert(cnum, Arc::clone(used_crate_source));979            if tcx.is_profiler_runtime(cnum) {980                info.profiler_runtime = Some(cnum);981            }982            if tcx.is_no_builtins(cnum) {983                info.is_no_builtins.insert(cnum);984            }985        }986987        // Handle circular dependencies in the standard library.988        // See comment before `add_linked_symbol_object` function for the details.989        // If global LTO is enabled then almost everything (*) is glued into a single object file,990        // so this logic is not necessary and can cause issues on some targets (due to weak lang991        // item symbols being "privatized" to that object file), so we disable it.992        // (*) Native libs, and `#[compiler_builtins]` and `#[no_builtins]` crates are not glued,993        // and we assume that they cannot define weak lang items. This is not currently enforced994        // by the compiler, but that's ok because all this stuff is unstable anyway.995        let target = &tcx.sess.target;996        if !are_upstream_rust_objects_already_included(tcx.sess) {997            let add_prefix = match (target.is_like_windows, &target.arch) {998                (true, Arch::X86) => |name: String, _: SymbolExportKind| format!("_{name}"),999                (true, Arch::Arm64EC) => {1000                    // Only functions are decorated for arm64ec.1001                    |name: String, export_kind: SymbolExportKind| match export_kind {1002                        SymbolExportKind::Text => format!("#{name}"),1003                        _ => name,1004                    }1005                }1006                _ => |name: String, _: SymbolExportKind| name,1007            };1008            let missing_weak_lang_items: FxIndexSet<(Symbol, SymbolExportKind)> = info1009                .used_crates1010                .iter()1011                .flat_map(|&cnum| tcx.missing_lang_items(cnum))1012                .filter(|l| l.is_weak())1013                .filter_map(|&l| {1014                    let name = l.link_name()?;1015                    let export_kind = match l.target() {1016                        Target::Fn => SymbolExportKind::Text,1017                        Target::Static => SymbolExportKind::Data,1018                        _ => bug!(1019                            "Don't know what the export kind is for lang item of kind {:?}",1020                            l.target()1021                        ),1022                    };1023                    lang_items::required(tcx, l).then_some((name, export_kind))1024                })1025                .collect();10261027            // This loop only adds new items to values of the hash map, so the order in which we1028            // iterate over the values is not important.1029            #[allow(rustc::potential_query_instability)]1030            info.linked_symbols1031                .iter_mut()1032                .filter(|(crate_type, _)| {1033                    !matches!(crate_type, CrateType::Rlib | CrateType::StaticLib)1034                })1035                .for_each(|(_, linked_symbols)| {1036                    let mut symbols = missing_weak_lang_items1037                        .iter()1038                        .map(|(item, export_kind)| {1039                            (1040                                add_prefix(1041                                    mangle_internal_symbol(tcx, item.as_str()),1042                                    *export_kind,1043                                ),1044                                *export_kind,1045                            )1046                        })1047                        .collect::<Vec<_>>();1048                    symbols.sort_unstable_by(|a, b| a.0.cmp(&b.0));1049                    linked_symbols.extend(symbols);1050                });1051        }10521053        let mut each_linked_rlib_for_lto = Vec::new();1054        let mut each_linked_rlib_file_for_lto = Vec::new();1055        if tcx.sess.lto() != config::Lto::No && tcx.sess.lto() != config::Lto::ThinLocal {1056            drop(crate::back::link::each_linked_rlib(&info, None, &mut |cnum, path| {1057                if crate::back::link::ignored_for_lto(tcx.sess, &info, cnum) {1058                    return;1059                }10601061                each_linked_rlib_for_lto.push(cnum);1062                each_linked_rlib_file_for_lto.push(path.to_path_buf());1063            }));1064        }1065        info.each_linked_rlib_file_for_lto = each_linked_rlib_file_for_lto;10661067        // FIXME move to -Zlink-only half such that each_linked_rlib_file_for_lto can be moved there too1068        // Compute the set of symbols we need to retain when doing LTO (if we need to)1069        info.exported_symbols_for_lto =1070            crate::back::lto::exported_symbols_for_lto(tcx, &each_linked_rlib_for_lto);10711072        let embed_visualizers = tcx.crate_types().iter().any(|&crate_type| match crate_type {1073            CrateType::Executable | CrateType::Dylib | CrateType::Cdylib | CrateType::Sdylib => {1074                // These are crate types for which we invoke the linker and can embed1075                // NatVis visualizers.1076                true1077            }1078            CrateType::ProcMacro => {1079                // We could embed NatVis for proc macro crates too (to improve the debugging1080                // experience for them) but it does not seem like a good default, since1081                // this is a rare use case and we don't want to slow down the common case.1082                false1083            }1084            CrateType::StaticLib | CrateType::Rlib => {1085                // We don't invoke the linker for these, so we don't need to collect the NatVis for1086                // them.1087                false1088            }1089        });10901091        if target.is_like_msvc && embed_visualizers {1092            info.natvis_debugger_visualizers =1093                collect_debugger_visualizers_transitive(tcx, DebuggerVisualizerType::Natvis);1094        }10951096        info1097    }1098}10991100pub(crate) fn provide(providers: &mut Providers) {1101    providers.backend_optimization_level = |tcx, cratenum| {1102        let for_speed = match tcx.sess.opts.optimize {1103            // If globally no optimisation is done, #[optimize] has no effect.1104            //1105            // This is done because if we ended up "upgrading" to `-O2` here, we’d populate the1106            // pass manager and it is likely that some module-wide passes (such as inliner or1107            // cross-function constant propagation) would ignore the `optnone` annotation we put1108            // on the functions, thus necessarily involving these functions into optimisations.1109            config::OptLevel::No => return config::OptLevel::No,1110            // If globally optimise-speed is already specified, just use that level.1111            config::OptLevel::Less => return config::OptLevel::Less,1112            config::OptLevel::More => return config::OptLevel::More,1113            config::OptLevel::Aggressive => return config::OptLevel::Aggressive,1114            // If globally optimize-for-size has been requested, use -O2 instead (if optimize(size)1115            // are present).1116            config::OptLevel::Size => config::OptLevel::More,1117            config::OptLevel::SizeMin => config::OptLevel::More,1118        };11191120        let defids = tcx.collect_and_partition_mono_items(cratenum).all_mono_items;11211122        let any_for_speed = defids.items().any(|id| {1123            let CodegenFnAttrs { optimize, .. } = tcx.codegen_fn_attrs(*id);1124            matches!(optimize, OptimizeAttr::Speed)1125        });11261127        if any_for_speed {1128            return for_speed;1129        }11301131        tcx.sess.opts.optimize1132    };1133}11341135pub fn determine_cgu_reuse<'tcx>(tcx: TyCtxt<'tcx>, cgu: &CodegenUnit<'tcx>) -> CguReuse {1136    if !tcx.dep_graph.is_fully_enabled()1137        || tcx.sess.opts.unstable_opts.disable_incr_comp_backend_caching1138    {1139        return CguReuse::No;1140    }11411142    let work_product_id = &cgu.work_product_id();1143    if tcx.dep_graph.previous_work_product(work_product_id).is_none() {1144        // We don't have anything cached for this CGU. This can happen1145        // if the CGU did not exist in the previous session.1146        return CguReuse::No;1147    }11481149    // Try to mark the CGU as green. If it we can do so, it means that nothing1150    // affecting the LLVM module has changed and we can re-use a cached version.1151    // If we compile with any kind of LTO, this means we can re-use the bitcode1152    // of the Pre-LTO stage (possibly also the Post-LTO version but we'll only1153    // know that later). If we are not doing LTO, there is only one optimized1154    // version of each module, so we re-use that.1155    let dep_node = cgu.codegen_dep_node(tcx);1156    tcx.dep_graph.assert_dep_node_not_yet_allocated_in_current_session(tcx.sess, &dep_node, || {1157        format!(1158            "CompileCodegenUnit dep-node for CGU `{}` already exists before marking.",1159            cgu.name()1160        )1161    });11621163    if tcx.dep_graph.try_mark_green(tcx, &dep_node).is_some() {1164        // We can re-use either the pre- or the post-thinlto state. If no LTO is1165        // being performed then we can use post-LTO artifacts, otherwise we must1166        // reuse pre-LTO artifacts1167        match compute_per_cgu_lto_type(1168            &tcx.sess.lto(),1169            tcx.sess.opts.cg.linker_plugin_lto.enabled(),1170            tcx.crate_types(),1171        ) {1172            ComputedLtoType::No => CguReuse::PostLto,1173            _ => CguReuse::PreLto,1174        }1175    } else {1176        CguReuse::No1177    }1178}