1use std::marker::PhantomData;2use std::num::NonZero;3use std::panic::AssertUnwindSafe;4use std::path::{Path, PathBuf};5use std::sync::Arc;6use std::sync::mpsc::{Receiver, Sender, channel};7use std::{assert_matches, fs, io, str, thread};89use rustc_abi::Size;10use rustc_data_structures::jobserver::{self, Acquired};11use rustc_data_structures::profiling::{SelfProfilerRef, VerboseTimingGuard};12use rustc_errors::emitter::Emitter;13use rustc_errors::{14    Diag, DiagCtxt, DiagCtxtHandle, DiagInner, FatalError, FatalErrorMarker, Level,15    catch_fatal_errors,16};17use rustc_fs_util::link_or_copy;18use rustc_incremental::{19    copy_cgu_workproduct_to_incr_comp_cache_dir, in_incr_comp_dir_sess, in_old_incr_comp_dir_sess,20};21use rustc_macros::{Decodable, Encodable};22use rustc_metadata::fs::copy_to_stdout;23use rustc_middle::dep_graph::{WorkProduct, WorkProductMap};24use rustc_middle::ty::TyCtxt;25use rustc_session::config::{26    self, Lto, OptLevel, OutFileName, OutputFilenames, OutputType, Passes, SwitchWithOptPath,27};28use rustc_session::{IncrCompSession, Session};29use rustc_span::source_map::SourceMap;30use rustc_span::{BytePos, FileName, InnerSpan, Span, SyntaxContext, bug};31use rustc_structures::CrateType;32use rustc_target::spec::{MergeFunctions, SanitizerSet};33use tracing::debug;3435use crate::back::link::ensure_removed;36use crate::back::lto::{self, SerializedModule, check_lto_allowed};37use crate::diagnostics::ErrorCreatingRemarkDir;38use crate::traits::*;39use crate::{40    CachedModuleCodegen, CompiledModule, CompiledModules, CrateInfo, ModuleCodegen, ModuleKind,41    diagnostics,42};4344const PRE_LTO_BC_EXT: &str = "pre-lto.bc";4546/// What kind of object file to emit.47#[derive(Clone, Copy, PartialEq, Encodable, Decodable)]48pub enum EmitObj {49    // No object file.50    None,5152    // Just uncompressed llvm bitcode. Provides easy compatibility with53    // emscripten's ecc compiler, when used as the linker.54    Bitcode,5556    // Object code, possibly augmented with a bitcode section.57    ObjectCode(BitcodeSection),58}5960/// What kind of llvm bitcode section to embed in an object file.61#[derive(Clone, Copy, PartialEq, Encodable, Decodable)]62pub enum BitcodeSection {63    // No bitcode section.64    None,6566    // A full, uncompressed bitcode section.67    Full,68}6970/// Module-specific configuration for `optimize_and_codegen`.71#[derive(Encodable, Decodable)]72pub struct ModuleConfig {73    /// Names of additional optimization passes to run.74    pub passes: Vec<String>,75    /// Some(level) to optimize at a certain level, or None to run76    /// absolutely no optimizations (used for the allocator module).77    pub opt_level: Option<config::OptLevel>,7879    pub pgo_gen: SwitchWithOptPath,80    pub pgo_use: Option<PathBuf>,81    pub pgo_sample_use: Option<PathBuf>,82    pub debug_info_for_profiling: bool,83    pub instrument_coverage: bool,8485    pub sanitizer: SanitizerSet,86    pub sanitizer_cfi_diag: Option<bool>,87    pub sanitizer_cfi_recover: Option<bool>,88    pub sanitizer_recover: SanitizerSet,89    pub sanitizer_dataflow_abilist: Vec<String>,90    pub sanitizer_memory_track_origins: usize,9192    // Flags indicating which outputs to produce.93    pub emit_pre_lto_bc: bool,94    pub emit_bc: bool,95    pub emit_ir: bool,96    pub emit_asm: bool,97    pub emit_obj: EmitObj,98    pub emit_thin_lto_summary: bool,99100    // Miscellaneous flags. These are mostly copied from command-line101    // options.102    pub verify_llvm_ir: bool,103    pub lint_llvm_ir: bool,104    pub no_prepopulate_passes: bool,105    pub no_builtins: bool,106    pub vectorize_loop: bool,107    pub vectorize_slp: bool,108    pub merge_functions: bool,109    pub emit_lifetime_markers: bool,110    pub llvm_plugins: Vec<String>,111    pub autodiff: Vec<config::AutoDiff>,112    pub autodiff_post_passes: Option<String>,113    pub offload: Vec<config::Offload>,114}115116impl ModuleConfig {117    pub(crate) fn new(kind: ModuleKind, tcx: TyCtxt<'_>, no_builtins: bool) -> ModuleConfig {118        // If it's a regular module, use `$regular`, otherwise use `$other`.119        // `$regular` and `$other` are evaluated lazily.120        macro_rules! if_regular {121            ($regular: expr, $other: expr) => {122                if let ModuleKind::Regular = kind { $regular } else { $other }123            };124        }125126        let sess = tcx.sess;127        let opt_level_and_size = if_regular!(Some(sess.opts.optimize), None);128129        let save_temps = sess.opts.cg.save_temps;130131        let should_emit_obj = sess.opts.output_types.contains_key(&OutputType::Exe)132            || match kind {133                ModuleKind::Regular => sess.opts.output_types.contains_key(&OutputType::Object),134                ModuleKind::Allocator => false,135            };136137        let emit_obj = if !should_emit_obj {138            EmitObj::None139        } else if sess.target.obj_is_bitcode140            || (sess.opts.cg.linker_plugin_lto.enabled()141                && (!no_builtins || tcx.sess.is_sanitizer_cfi_enabled()))142        {143            // This case is selected if the target uses objects as bitcode, or144            // if linker plugin LTO is enabled. In the linker plugin LTO case145            // the assumption is that the final link-step will read the bitcode146            // and convert it to object code. This may be done by either the147            // native linker or rustc itself.148            //149            // By default this branch is skipped for `#![no_builtins]` crates so150            // they emit native object files (machine code), not LLVM bitcode151            // objects for the linker (see rust-lang/rust#146133).152            //153            // However, when LLVM CFI is enabled (`-Zsanitizer=cfi`), this154            // breaks LLVM's expected pipeline: LLVM emits `llvm.type.test`155            // intrinsics and related metadata that must be lowered by LLVM's156            // `LowerTypeTests` pass before instruction selection during157            // link-time LTO. Otherwise, `llvm.type.test` intrinsics and related158            // metadata are not lowered by LLVM's `LowerTypeTests` pass before159            // reaching the target backend, and LLVM may abort during codegen160            // (for example in SelectionDAG type legalization) (see161            // rust-lang/rust#142284).162            //163            // Therefore, with `-Clinker-plugin-lto` and `-Zsanitizer=cfi`, a164            // `#![no_builtins]` crate must still use rustc's `EmitObj::Bitcode`165            // path (and emit LLVM bitcode in the `.o` for linker-based LTO).166            EmitObj::Bitcode167        } else if need_bitcode_in_object(tcx) || sess.target.requires_lto {168            EmitObj::ObjectCode(BitcodeSection::Full)169        } else {170            EmitObj::ObjectCode(BitcodeSection::None)171        };172173        ModuleConfig {174            passes: if_regular!(sess.opts.cg.passes.clone(), vec![]),175176            opt_level: opt_level_and_size,177178            pgo_gen: if_regular!(179                sess.opts.cg.profile_generate.clone(),180                SwitchWithOptPath::Disabled181            ),182            pgo_use: if_regular!(sess.opts.cg.profile_use.clone(), None),183            pgo_sample_use: if_regular!(sess.opts.cg.profile_sample_use.clone(), None),184            debug_info_for_profiling: sess.opts.unstable_opts.debuginfo_for_profiling,185            instrument_coverage: if_regular!(sess.instrument_coverage(), false),186187            sanitizer: if_regular!(sess.sanitizers(), SanitizerSet::empty()),188            sanitizer_cfi_diag: if_regular!(sess.opts.unstable_opts.sanitizer_cfi_diag, None),189            sanitizer_cfi_recover: if_regular!(sess.opts.unstable_opts.sanitizer_cfi_recover, None),190            sanitizer_dataflow_abilist: if_regular!(191                sess.opts.unstable_opts.sanitizer_dataflow_abilist.clone(),192                Vec::new()193            ),194            sanitizer_recover: if_regular!(195                sess.opts.unstable_opts.sanitizer_recover,196                SanitizerSet::empty()197            ),198            sanitizer_memory_track_origins: if_regular!(199                sess.opts.unstable_opts.sanitizer_memory_track_origins,200                0201            ),202203            emit_pre_lto_bc: if_regular!(204                save_temps || need_pre_lto_bitcode_for_incr_comp(sess),205                false206            ),207            emit_bc: if_regular!(208                save_temps || sess.opts.output_types.contains_key(&OutputType::Bitcode),209                save_temps210            ),211            emit_ir: if_regular!(212                sess.opts.output_types.contains_key(&OutputType::LlvmAssembly),213                false214            ),215            emit_asm: if_regular!(216                sess.opts.output_types.contains_key(&OutputType::Assembly),217                false218            ),219            emit_obj,220            emit_thin_lto_summary: if_regular!(221                sess.opts.output_types.contains_key(&OutputType::ThinLinkBitcode),222                false223            ),224225            verify_llvm_ir: sess.verify_llvm_ir(),226            lint_llvm_ir: sess.opts.unstable_opts.lint_llvm_ir,227            no_prepopulate_passes: sess.opts.cg.no_prepopulate_passes,228            no_builtins: no_builtins || sess.target.no_builtins,229230            // Copy what clang does by turning on loop vectorization at O2 and231            // slp vectorization at O3.232            vectorize_loop: !sess.opts.cg.no_vectorize_loops233                && (sess.opts.optimize == config::OptLevel::More234                    || sess.opts.optimize == config::OptLevel::Aggressive),235            vectorize_slp: !sess.opts.cg.no_vectorize_slp236                && sess.opts.optimize == config::OptLevel::Aggressive,237238            // Some targets (namely, NVPTX) interact badly with the239            // MergeFunctions pass. This is because MergeFunctions can generate240            // new function calls which may interfere with the target calling241            // convention; e.g. for the NVPTX target, PTX kernels should not242            // call other PTX kernels. MergeFunctions can also be configured to243            // generate aliases instead, but aliases are not supported by some244            // backends (again, NVPTX). Therefore, allow targets to opt out of245            // the MergeFunctions pass, but otherwise keep the pass enabled (at246            // O2 and O3) since it can be useful for reducing code size.247            merge_functions: match sess.merge_functions() {248                MergeFunctions::Disabled => false,249                MergeFunctions::Trampolines | MergeFunctions::Aliases => {250                    use config::OptLevel::*;251                    match sess.opts.optimize {252                        Aggressive | More | SizeMin | Size => true,253                        Less | No => false,254                    }255                }256            },257258            emit_lifetime_markers: sess.emit_lifetime_markers(),259            llvm_plugins: if_regular!(sess.opts.unstable_opts.llvm_plugins.clone(), vec![]),260            autodiff: if_regular!(sess.opts.unstable_opts.autodiff.clone(), vec![]),261            autodiff_post_passes: if_regular!(262                sess.opts.unstable_opts.autodiff_post_passes.clone(),263                None264            ),265            offload: if_regular!(sess.opts.unstable_opts.offload.clone(), vec![]),266        }267    }268269    pub fn bitcode_needed(&self) -> bool {270        self.emit_bc271            || self.emit_thin_lto_summary272            || self.emit_obj == EmitObj::Bitcode273            || self.emit_obj == EmitObj::ObjectCode(BitcodeSection::Full)274    }275276    pub fn embed_bitcode(&self) -> bool {277        self.emit_obj == EmitObj::ObjectCode(BitcodeSection::Full)278    }279}280281/// Configuration passed to the function returned by the `target_machine_factory`.282pub struct TargetMachineFactoryConfig {283    /// Split DWARF is enabled in LLVM by checking that `TM.MCOptions.SplitDwarfFile` isn't empty,284    /// so the path to the dwarf object has to be provided when we create the target machine.285    /// This can be ignored by backends which do not need it for their Split DWARF support.286    pub split_dwarf_file: Option<PathBuf>,287288    /// The name of the output object file. Used for setting OutputFilenames in target options289    /// so that LLVM can emit the CodeView S_OBJNAME record in pdb files290    pub output_obj_file: Option<PathBuf>,291}292293impl TargetMachineFactoryConfig {294    pub fn new(cgcx: &CodegenContext, module_name: &str) -> TargetMachineFactoryConfig {295        let split_dwarf_file = if cgcx.target_can_use_split_dwarf {296            cgcx.output_filenames.split_dwarf_path(297                cgcx.split_debuginfo,298                cgcx.split_dwarf_kind,299                module_name,300            )301        } else {302            None303        };304305        let output_obj_file =306            Some(cgcx.output_filenames.temp_path_for_cgu(OutputType::Object, module_name));307        TargetMachineFactoryConfig { split_dwarf_file, output_obj_file }308    }309}310311pub type TargetMachineFactoryFn<B> = Arc<312    dyn Fn(313            DiagCtxtHandle<'_>,314            TargetMachineFactoryConfig,315        ) -> <B as WriteBackendMethods>::TargetMachine316        + Send317        + Sync,318>;319320/// Additional resources used by optimize_and_codegen (not module specific)321#[derive(Clone, Encodable, Decodable)]322pub struct CodegenContext {323    // Resources needed when running LTO324    pub lto: Lto,325    pub use_linker_plugin_lto: bool,326    pub dylib_lto: bool,327    pub prefer_dynamic: bool,328    pub save_temps: bool,329    pub fewer_names: bool,330    pub time_trace: bool,331    pub crate_types: Vec<CrateType>,332    pub output_filenames: Arc<OutputFilenames>,333    pub module_config: Arc<ModuleConfig>,334    pub opt_level: OptLevel,335    pub msvc_imps_needed: bool,336    pub is_pe_coff: bool,337    pub target_can_use_split_dwarf: bool,338    pub target_arch: String,339    pub target_is_like_darwin: bool,340    pub target_is_like_aix: bool,341    pub target_is_like_gpu: bool,342    pub split_debuginfo: rustc_target::spec::SplitDebuginfo,343    pub split_dwarf_kind: rustc_session::config::SplitDwarfKind,344    pub pointer_size: Size,345    pub rust_eh_personality_symbol: String,346347    /// LLVM optimizations for which we want to print remarks.348    pub remark: Passes,349    /// Directory into which should the LLVM optimization remarks be written.350    /// If `None`, they will be written to stderr.351    pub remark_dir: Option<PathBuf>,352    /// The previous incremental compilation session directory, or None if we353    /// are not compiling incrementally or there is no previous session.354    pub old_incr_comp_session_dir: Option<PathBuf>,355    /// The incremental compilation session directory, or None if we are not356    /// compiling incrementally357    pub new_incr_comp_session_dir: Option<PathBuf>,358    /// `Some(limit)` if the codegen should be run in parallel.359    ///360    /// Depends on [`WriteBackendMethods::supports_parallel()`] and `--jobs-backend`.361    pub parallel: Option<NonZero<usize>>,362}363364fn generate_thin_lto_work<B: WriteBackendMethods>(365    cgcx: &CodegenContext,366    prof: &SelfProfilerRef,367    dcx: DiagCtxtHandle<'_>,368    exported_symbols_for_lto: &[String],369    each_linked_rlib_for_lto: &[PathBuf],370    needs_thin_lto: Vec<ThinLtoInput<B>>,371) -> Vec<(ThinLtoWorkItem<B>, u64)> {372    let _prof_timer = prof.generic_activity("codegen_thin_generate_lto_work");373374    let (lto_modules, copy_jobs) = B::run_thin_lto(375        cgcx,376        prof,377        dcx,378        exported_symbols_for_lto,379        each_linked_rlib_for_lto,380        needs_thin_lto,381    );382    lto_modules383        .into_iter()384        .map(|module| {385            let cost = module.cost();386            (ThinLtoWorkItem::ThinLto(module), cost)387        })388        .chain(copy_jobs.into_iter().map(|wp| {389            (390                ThinLtoWorkItem::CopyPostLtoArtifacts(CachedModuleCodegen {391                    name: wp.cgu_name.clone(),392                    source: wp,393                }),394                0, // copying is very cheap395            )396        }))397        .collect()398}399400enum MaybeLtoModules<B: WriteBackendMethods> {401    NoLto(CompiledModules),402    FatLto { cgcx: CodegenContext, needs_fat_lto: Vec<FatLtoInput<B>> },403    ThinLto { cgcx: CodegenContext, needs_thin_lto: Vec<ThinLtoInput<B>> },404}405406fn need_bitcode_in_object(tcx: TyCtxt<'_>) -> bool {407    let sess = tcx.sess;408    sess.opts.cg.embed_bitcode409        && tcx.crate_types().contains(&CrateType::Rlib)410        && sess.opts.output_types.contains_key(&OutputType::Exe)411}412413fn need_pre_lto_bitcode_for_incr_comp(sess: &Session) -> bool {414    if sess.opts.incremental.is_none() {415        return false;416    }417418    match sess.lto() {419        Lto::No => false,420        Lto::Fat | Lto::Thin | Lto::ThinLocal => true,421    }422}423424pub(crate) fn start_async_codegen<B: WriteBackendMethods>(425    backend: B,426    tcx: TyCtxt<'_>,427    regular_config: Arc<ModuleConfig>,428    allocator_config: Arc<ModuleConfig>,429    allocator_module: Option<ModuleCodegen<B::Module>>,430) -> OngoingCodegen<B> {431    let (coordinator_send, coordinator_receive) = channel();432433    let (shared_emitter, shared_emitter_main) = SharedEmitter::new();434    let (codegen_worker_send, codegen_worker_receive) = channel();435436    let coordinator_thread = start_executing_work(437        backend.clone(),438        tcx,439        shared_emitter,440        codegen_worker_send,441        coordinator_receive,442        regular_config,443        allocator_config,444        allocator_module,445        coordinator_send.clone(),446    );447448    OngoingCodegen {449        backend,450451        codegen_worker_receive,452        shared_emitter_main,453        coordinator: Coordinator {454            sender: coordinator_send,455            future: Some(coordinator_thread),456            phantom: PhantomData,457        },458        output_filenames: Arc::clone(tcx.output_filenames(())),459    }460}461462fn copy_all_cgu_workproducts_to_incr_comp_cache_dir(463    sess: &Session,464    incr_comp_session: Option<&IncrCompSession>,465    compiled_modules: &CompiledModules,466) -> WorkProductMap {467    let mut work_products = WorkProductMap::default();468469    if sess.opts.incremental.is_none() || sess.opts.unstable_opts.disable_incr_comp_backend_caching470    {471        return work_products;472    }473474    let _timer = sess.timer("copy_all_cgu_workproducts_to_incr_comp_cache_dir");475476    for module in compiled_modules.modules.iter().filter(|m| m.kind == ModuleKind::Regular) {477        let mut files = Vec::new();478        if let Some(object_file_path) = &module.object {479            files.push((OutputType::Object.extension(), object_file_path.as_path()));480        }481        if let Some(global_asm_object_file_path) = &module.global_asm_object {482            files.push(("asm.o", global_asm_object_file_path.as_path()));483        }484        if let Some(dwarf_object_file_path) = &module.dwarf_object {485            files.push(("dwo", dwarf_object_file_path.as_path()));486        }487        if let Some(path) = &module.assembly {488            files.push((OutputType::Assembly.extension(), path.as_path()));489        }490        if let Some(path) = &module.llvm_ir {491            files.push((OutputType::LlvmAssembly.extension(), path.as_path()));492        }493        if let Some(path) = &module.bytecode {494            files.push((OutputType::Bitcode.extension(), path.as_path()));495        }496        let (id, product) = copy_cgu_workproduct_to_incr_comp_cache_dir(497            sess,498            incr_comp_session.unwrap(),499            &module.name,500            files.as_slice(),501        );502        work_products.insert(id, product);503    }504505    work_products506}507508pub fn produce_final_output_artifacts(509    sess: &Session,510    compiled_modules: &CompiledModules,511    crate_output: &OutputFilenames,512) {513    let mut user_wants_bitcode = false;514    let mut user_wants_objects = false;515516    // Produce final compile outputs.517    let copy_gracefully = |from: &Path, to: &OutFileName| match to {518        OutFileName::Stdout if let Err(e) = copy_to_stdout(from) => {519            sess.dcx().emit_err(diagnostics::CopyPath::new(from, to.as_path(), e));520        }521        OutFileName::Real(path) if let Err(e) = fs::copy(from, path) => {522            sess.dcx().emit_err(diagnostics::CopyPath::new(from, path, e));523        }524        _ => {}525    };526527    let copy_if_one_unit = |output_type: OutputType, keep_numbered: bool| {528        if let [module] = &compiled_modules.modules[..] {529            // 1) Only one codegen unit. In this case it's no difficulty530            //    to copy `foo.0.x` to `foo.x`.531            let path = crate_output.temp_path_for_cgu(output_type, &module.name);532            let output = crate_output.path(output_type);533            if !output_type.is_text_output() && output.is_tty() {534                sess.dcx().emit_err(diagnostics::BinaryOutputToTty {535                    shorthand: output_type.shorthand(),536                });537            } else {538                copy_gracefully(&path, &output);539            }540            if !sess.opts.cg.save_temps && !keep_numbered {541                // The user just wants `foo.x`, not `foo.#module-name#.x`.542                ensure_removed(sess.dcx(), &path);543            }544        } else {545            if crate_output.outputs.contains_explicit_name(&output_type) {546                // 2) Multiple codegen units, with `--emit foo=some_name`. We have547                //    no good solution for this case, so warn the user.548                sess.dcx().emit_warn(diagnostics::IgnoringEmitPath {549                    extension: output_type.extension(),550                });551            } else if crate_output.single_output_file.is_some() {552                // 3) Multiple codegen units, with `-o some_name`. We have553                //    no good solution for this case, so warn the user.554                sess.dcx()555                    .emit_warn(diagnostics::IgnoringOutput { extension: output_type.extension() });556            } else {557                // 4) Multiple codegen units, but no explicit name. We558                //    just leave the `foo.0.x` files in place.559                // (We don't have to do any work in this case.)560            }561        }562    };563564    // Flag to indicate whether the user explicitly requested bitcode.565    // Otherwise, we produced it only as a temporary output, and will need566    // to get rid of it.567    for output_type in crate_output.outputs.keys() {568        match *output_type {569            OutputType::Bitcode => {570                user_wants_bitcode = true;571                // Copy to .bc, but always keep the .0.bc. There is a later572                // check to figure out if we should delete .0.bc files, or keep573                // them for making an rlib.574                copy_if_one_unit(OutputType::Bitcode, true);575            }576            OutputType::ThinLinkBitcode => {577                copy_if_one_unit(OutputType::ThinLinkBitcode, false);578            }579            OutputType::LlvmAssembly => {580                copy_if_one_unit(OutputType::LlvmAssembly, false);581            }582            OutputType::Assembly => {583                copy_if_one_unit(OutputType::Assembly, false);584            }585            OutputType::Object => {586                user_wants_objects = true;587                copy_if_one_unit(OutputType::Object, true);588            }589            OutputType::Mir | OutputType::Metadata | OutputType::Exe | OutputType::DepInfo => {}590        }591    }592593    // Clean up unwanted temporary files.594595    // We create the following files by default:596    //  - #crate#.#module-name#.rcgu.bc597    //  - #crate#.#module-name#.rcgu.o598    //  - #crate#.o (linked from crate.##.rcgu.o)599    //  - #crate#.bc (copied from crate.##.rcgu.bc)600    // We may create additional files if requested by the user (through601    // `-C save-temps` or `--emit=` flags).602603    if !sess.opts.cg.save_temps {604        // Remove the temporary .#module-name#.rcgu.o objects. If the user didn't605        // explicitly request bitcode (with --emit=bc), and the bitcode is not606        // needed for building an rlib, then we must remove .#module-name#.bc as607        // well.608609        // Specific rules for keeping .#module-name#.rcgu.bc:610        //  - If the user requested bitcode (`user_wants_bitcode`), and611        //    codegen_units > 1, then keep it.612        //  - If the user requested bitcode but codegen_units == 1, then we613        //    can toss .#module-name#.rcgu.bc because we copied it to .bc earlier.614        //  - If we're not building an rlib and the user didn't request615        //    bitcode, then delete .#module-name#.rcgu.bc.616        // If you change how this works, also update back::link::link_rlib,617        // where .#module-name#.rcgu.bc files are (maybe) deleted after making an618        // rlib.619        let needs_crate_object = crate_output.outputs.contains_key(&OutputType::Exe);620621        let keep_numbered_bitcode = user_wants_bitcode && sess.codegen_units().as_usize() > 1;622623        let keep_numbered_objects =624            needs_crate_object || (user_wants_objects && sess.codegen_units().as_usize() > 1);625626        for module in compiled_modules.modules.iter() {627            if !keep_numbered_objects {628                if let Some(ref path) = module.object {629                    ensure_removed(sess.dcx(), path);630                }631632                if let Some(ref path) = module.global_asm_object {633                    ensure_removed(sess.dcx(), path);634                }635636                if let Some(ref path) = module.dwarf_object {637                    ensure_removed(sess.dcx(), path);638                }639            }640641            if let Some(ref path) = module.bytecode {642                if !keep_numbered_bitcode {643                    ensure_removed(sess.dcx(), path);644                }645            }646        }647648        if !user_wants_bitcode649            && let Some(ref allocator_module) = compiled_modules.allocator_module650            && let Some(ref path) = allocator_module.bytecode651        {652            ensure_removed(sess.dcx(), path);653        }654    }655656    if sess.opts.json_artifact_notifications {657        if let [module] = &compiled_modules.modules[..] {658            module.for_each_output(|_path, ty| {659                if sess.opts.output_types.contains_key(&ty) {660                    let descr = ty.shorthand();661                    // for single cgu file is renamed to drop cgu specific suffix662                    // so we regenerate it the same way663                    let path = crate_output.path(ty);664                    sess.dcx().emit_artifact_notification(path.as_path(), descr);665                }666            });667        } else {668            for module in &compiled_modules.modules {669                module.for_each_output(|path, ty| {670                    if sess.opts.output_types.contains_key(&ty) {671                        let descr = ty.shorthand();672                        sess.dcx().emit_artifact_notification(&path, descr);673                    }674                });675            }676        }677    }678679    // We leave the following files around by default:680    //  - #crate#.o681    //  - #crate#.bc682    // These are used in linking steps and will be cleaned up afterward.683}684685pub(crate) enum WorkItem<B: WriteBackendMethods> {686    /// Optimize a newly codegened, totally unoptimized module.687    Optimize(ModuleCodegen<B::Module>),688    /// Copy the post-LTO artifacts from the incremental cache to the output689    /// directory.690    CopyPostLtoArtifacts(CachedModuleCodegen),691}692693enum ThinLtoWorkItem<B: WriteBackendMethods> {694    /// Copy the post-LTO artifacts from the incremental cache to the output695    /// directory.696    CopyPostLtoArtifacts(CachedModuleCodegen),697    /// Performs thin-LTO on the given module.698    ThinLto(lto::ThinModule<B>),699}700701// `pthread_setname()` on *nix ignores anything beyond the first 15702// bytes. Use short descriptions to maximize the space available for703// the module name.704#[cfg(not(windows))]705fn desc(short: &str, _long: &str, name: &str) -> String {706    // The short label is three bytes, and is followed by a space. That707    // leaves 11 bytes for the CGU name. How we obtain those 11 bytes708    // depends on the CGU name form.709    //710    // - Non-incremental, e.g. `regex.f10ba03eb5ec7975-cgu.0`: the part711    //   before the `-cgu.0` is the same for every CGU, so use the712    //   `cgu.0` part. The number suffix will be different for each713    //   CGU.714    //715    // - Incremental (normal), e.g. `2i52vvl2hco29us0`: use the whole716    //   name because each CGU will have a unique ASCII hash, and the717    //   first 11 bytes will be enough to identify it.718    //719    // - Incremental (with `-Zhuman-readable-cgu-names`), e.g.720    //   `regex.f10ba03eb5ec7975-re_builder.volatile`: use the whole721    //   name. The first 11 bytes won't be enough to uniquely identify722    //   it, but no obvious substring will, and this is a rarely used723    //   option so it doesn't matter much.724    //725    assert_eq!(short.len(), 3);726    let name = if let Some(index) = name.find("-cgu.") {727        &name[index + 1..] // +1 skips the leading '-'.728    } else {729        name730    };731    format!("{short} {name}")732}733734// Windows has no thread name length limit, so use more descriptive names.735#[cfg(windows)]736fn desc(_short: &str, long: &str, name: &str) -> String {737    format!("{long} {name}")738}739740impl<B: WriteBackendMethods> WorkItem<B> {741    /// Generate a short description of this work item suitable for use as a thread name.742    fn short_description(&self) -> String {743        match self {744            WorkItem::Optimize(m) => desc("opt", "optimize module", &m.name),745            WorkItem::CopyPostLtoArtifacts(m) => desc("cpy", "copy LTO artifacts for", &m.name),746        }747    }748}749750impl<B: WriteBackendMethods> ThinLtoWorkItem<B> {751    /// Generate a short description of this work item suitable for use as a thread name.752    fn short_description(&self) -> String {753        match self {754            ThinLtoWorkItem::CopyPostLtoArtifacts(m) => {755                desc("cpy", "copy LTO artifacts for", &m.name)756            }757            ThinLtoWorkItem::ThinLto(m) => desc("lto", "thin-LTO module", m.name()),758        }759    }760}761762/// A result produced by the backend.763pub(crate) enum WorkItemResult<B: WriteBackendMethods> {764    /// The backend has finished compiling a CGU, nothing more required.765    Finished(CompiledModule),766767    /// The backend has finished compiling a CGU, which now needs to go through768    /// fat LTO.769    NeedsFatLto(FatLtoInput<B>),770771    /// The backend has finished compiling a CGU, which now needs to go through772    /// thin LTO.773    NeedsThinLto(String, B::ModuleBuffer),774}775776pub enum FatLtoInput<B: WriteBackendMethods> {777    Serialized { name: String, bitcode_path: PathBuf },778    InMemory(ModuleCodegen<B::Module>),779}780781pub enum ThinLtoInput<B: WriteBackendMethods> {782    Red { name: String, buffer: SerializedModule<B::ModuleBuffer> },783    Green { wp: WorkProduct, bitcode_path: PathBuf },784}785786/// Actual LTO type we end up choosing based on multiple factors.787pub(crate) enum ComputedLtoType {788    No,789    Thin,790    Fat,791}792793pub(crate) fn compute_per_cgu_lto_type(794    sess_lto: &Lto,795    linker_does_lto: bool,796    sess_crate_types: &[CrateType],797) -> ComputedLtoType {798    // If the linker does LTO, we don't have to do it. Note that we799    // keep doing full LTO, if it is requested, as not to break the800    // assumption that the output will be a single module.801802    // We ignore a request for full crate graph LTO if the crate type803    // is only an rlib, as there is no full crate graph to process,804    // that'll happen later.805    //806    // This use case currently comes up primarily for targets that807    // require LTO so the request for LTO is always unconditionally808    // passed down to the backend, but we don't actually want to do809    // anything about it yet until we've got a final product.810    let is_rlib = matches!(sess_crate_types, [CrateType::Rlib]);811812    match sess_lto {813        Lto::ThinLocal if !linker_does_lto => ComputedLtoType::Thin,814        Lto::Thin if !linker_does_lto && !is_rlib => ComputedLtoType::Thin,815        Lto::Fat if !is_rlib => ComputedLtoType::Fat,816        _ => ComputedLtoType::No,817    }818}819820fn execute_optimize_work_item<B: WriteBackendMethods>(821    cgcx: &CodegenContext,822    prof: &SelfProfilerRef,823    shared_emitter: SharedEmitter,824    mut module: ModuleCodegen<B::Module>,825) -> WorkItemResult<B> {826    let _timer = prof.generic_activity_with_arg("codegen_module_optimize", &*module.name);827828    B::optimize(cgcx, prof, &shared_emitter, &mut module, &cgcx.module_config);829830    // After we've done the initial round of optimizations we need to831    // decide whether to synchronously codegen this module or ship it832    // back to the coordinator thread for further LTO processing (which833    // has to wait for all the initial modules to be optimized).834835    let lto_type =836        compute_per_cgu_lto_type(&cgcx.lto, cgcx.use_linker_plugin_lto, &cgcx.crate_types);837838    // If we're doing some form of incremental LTO then we need to be sure to839    // save our module to disk first.840    let bitcode = if cgcx.module_config.emit_pre_lto_bc {841        let filename = pre_lto_bitcode_filename(&module.name);842        cgcx.new_incr_comp_session_dir.as_ref().map(|path| path.join(&filename))843    } else {844        None845    };846847    match lto_type {848        ComputedLtoType::No => {849            let module = B::codegen(cgcx, &prof, &shared_emitter, module, &cgcx.module_config);850            WorkItemResult::Finished(module)851        }852        ComputedLtoType::Thin => {853            let thin_buffer = B::serialize_module(module.module_llvm, true);854            if let Some(path) = bitcode {855                fs::write(&path, thin_buffer.data()).unwrap_or_else(|e| {856                    panic!("Error writing pre-lto-bitcode file `{}`: {}", path.display(), e);857                });858            }859            WorkItemResult::NeedsThinLto(module.name, thin_buffer)860        }861        ComputedLtoType::Fat => match bitcode {862            Some(path) => {863                let buffer = B::serialize_module(module.module_llvm, false);864                fs::write(&path, buffer.data()).unwrap_or_else(|e| {865                    panic!("Error writing pre-lto-bitcode file `{}`: {}", path.display(), e);866                });867                WorkItemResult::NeedsFatLto(FatLtoInput::Serialized {868                    name: module.name,869                    bitcode_path: path,870                })871            }872            None => WorkItemResult::NeedsFatLto(FatLtoInput::InMemory(module)),873        },874    }875}876877fn execute_copy_from_cache_work_item(878    cgcx: &CodegenContext,879    prof: &SelfProfilerRef,880    shared_emitter: SharedEmitter,881    module: CachedModuleCodegen,882) -> CompiledModule {883    let _timer =884        prof.generic_activity_with_arg("codegen_copy_artifacts_from_incr_cache", &*module.name);885886    let dcx = DiagCtxt::new(Box::new(shared_emitter));887    let dcx = dcx.handle();888889    let incr_comp_session_dir = cgcx.old_incr_comp_session_dir.as_ref().unwrap();890891    let load_from_incr_comp_dir = |output_path: PathBuf, saved_path: &str| {892        let source_file_in_incr_comp_dir = incr_comp_session_dir.join(saved_path);893        debug!(894            "copying preexisting module `{}` from {:?} to {}",895            module.name,896            source_file_in_incr_comp_dir,897            output_path.display()898        );899        match link_or_copy(&source_file_in_incr_comp_dir, &output_path) {900            Ok(_) => Some(output_path),901            Err(error) => {902                dcx.emit_err(diagnostics::CopyPathBuf {903                    source_file: source_file_in_incr_comp_dir,904                    output_path,905                    error,906                });907                None908            }909        }910    };911912    let dwarf_object =913        module.source.saved_files.get("dwo").as_ref().and_then(|saved_dwarf_object_file| {914            let dwarf_obj_out = cgcx915                .output_filenames916                .split_dwarf_path(cgcx.split_debuginfo, cgcx.split_dwarf_kind, &module.name)917                .expect(918                    "saved dwarf object in work product but `split_dwarf_path` returned `None`",919                );920            load_from_incr_comp_dir(dwarf_obj_out, saved_dwarf_object_file)921        });922923    let load_from_incr_cache = |perform, output_type: OutputType| {924        if perform {925            let saved_file = module.source.saved_files.get(output_type.extension())?;926            let output_path = cgcx.output_filenames.temp_path_for_cgu(output_type, &module.name);927            load_from_incr_comp_dir(output_path, &saved_file)928        } else {929            None930        }931    };932933    let module_config = &cgcx.module_config;934    let should_emit_obj = module_config.emit_obj != EmitObj::None;935    let assembly = load_from_incr_cache(module_config.emit_asm, OutputType::Assembly);936    let llvm_ir = load_from_incr_cache(module_config.emit_ir, OutputType::LlvmAssembly);937    let bytecode = load_from_incr_cache(module_config.emit_bc, OutputType::Bitcode);938    let object = load_from_incr_cache(should_emit_obj, OutputType::Object);939    let global_asm_object =940        if should_emit_obj && let Some(saved_file) = module.source.saved_files.get("asm.o") {941            let output_path = cgcx.output_filenames.temp_path_ext_for_cgu("asm.o", &module.name);942            load_from_incr_comp_dir(output_path, &saved_file)943        } else {944            None945        };946    if should_emit_obj && object.is_none() {947        dcx.emit_fatal(diagnostics::NoSavedObjectFile { cgu_name: &module.name })948    }949950    CompiledModule {951        kind: ModuleKind::Regular,952        name: module.name,953        object,954        global_asm_object,955        dwarf_object,956        bytecode,957        assembly,958        llvm_ir,959    }960}961962fn do_fat_lto<B: WriteBackendMethods>(963    sess: &Session,964    cgcx: &CodegenContext,965    shared_emitter: SharedEmitter,966    tm_factory: TargetMachineFactoryFn<B>,967    exported_symbols_for_lto: &[String],968    each_linked_rlib_for_lto: &[PathBuf],969    needs_fat_lto: Vec<FatLtoInput<B>>,970) -> CompiledModule {971    let _timer = sess.prof.verbose_generic_activity("LLVM_fatlto");972973    let dcx = DiagCtxt::new(Box::new(shared_emitter.clone()));974    let dcx = dcx.handle();975976    check_lto_allowed(&cgcx, dcx);977978    B::optimize_and_codegen_fat_lto(979        sess,980        cgcx,981        &shared_emitter,982        tm_factory,983        exported_symbols_for_lto,984        each_linked_rlib_for_lto,985        needs_fat_lto,986    )987}988989fn do_thin_lto<B: WriteBackendMethods>(990    cgcx: &CodegenContext,991    prof: &SelfProfilerRef,992    shared_emitter: SharedEmitter,993    tm_factory: TargetMachineFactoryFn<B>,994    exported_symbols_for_lto: &[String],995    each_linked_rlib_for_lto: &[PathBuf],996    needs_thin_lto: Vec<ThinLtoInput<B>>,997    stack_size: usize,998) -> Vec<CompiledModule> {999    let _timer = prof.verbose_generic_activity("LLVM_thinlto");10001001    let dcx = DiagCtxt::new(Box::new(shared_emitter.clone()));1002    let dcx = dcx.handle();10031004    check_lto_allowed(&cgcx, dcx);10051006    let (coordinator_send, coordinator_receive) = channel();10071008    // First up, convert our jobserver into a helper thread so we can use normal1009    // mpsc channels to manage our messages and such.1010    // After we've requested tokens then we'll, when we can,1011    // get tokens on `coordinator_receive` which will1012    // get managed in the main loop below.1013    // Note that using `jobserver::Proxy` is not necessary here, the code below always acquires1014    // tokens before releasing them, so we can never accidentally release the last token1015    // permanently held by rustc process.1016    let jobserver_helper = cgcx.parallel.map(|_| {1017        let coordinator_send2 = coordinator_send.clone();1018        jobserver::client()1019            .into_helper_thread(move |token| {1020                drop(coordinator_send2.send(ThinLtoMessage::Token(token)));1021            })1022            .expect("failed to spawn helper thread")1023    });10241025    let mut work_items = vec![];10261027    // We have LTO work to do. Perform the serial work here of1028    // figuring out what we're going to LTO and then push a1029    // bunch of work items onto our queue to do LTO. This all1030    // happens on the coordinator thread but it's very quick so1031    // we don't worry about tokens.1032    for (i, (work, cost)) in generate_thin_lto_work::<B>(1033        cgcx,1034        prof,1035        dcx,1036        &exported_symbols_for_lto,1037        &each_linked_rlib_for_lto,1038        needs_thin_lto,1039    )1040    .into_iter()1041    .enumerate()1042    {1043        let insertion_index =1044            work_items.binary_search_by_key(&cost, |&(_, cost)| cost).unwrap_or_else(|e| e);1045        work_items.insert(insertion_index, (work, cost));1046        if let Some(helper) = &jobserver_helper1047            && i < cgcx.parallel.unwrap().get()1048        {1049            helper.request_token();1050        }1051    }10521053    let mut codegen_aborted = None;10541055    // These are the Jobserver Tokens we currently hold. Does not include1056    // the implicit Token the compiler process owns no matter what.1057    let mut tokens = vec![];10581059    // Amount of tokens that are used (including the implicit token).1060    let mut used_token_count = 0;10611062    let mut compiled_modules = vec![];10631064    // Run the message loop while there's still anything that needs message1065    // processing. Note that as soon as codegen is aborted we simply want to1066    // wait for all existing work to finish, so many of the conditions here1067    // only apply if codegen hasn't been aborted as they represent pending1068    // work to be done.1069    loop {1070        if codegen_aborted.is_none() {1071            if used_token_count == 0 && work_items.is_empty() {1072                // All codegen work is done.1073                break;1074            }10751076            // Spin up what work we can, only doing this while we've got available1077            // parallelism slots and work left to spawn.1078            while used_token_count < tokens.len() + 11079                && let Some((item, _)) = work_items.pop()1080            {1081                spawn_thin_lto_work(1082                    &cgcx,1083                    prof,1084                    shared_emitter.clone(),1085                    Arc::clone(&tm_factory),1086                    coordinator_send.clone(),1087                    item,1088                    stack_size,1089                );1090                used_token_count += 1;1091            }1092        } else {1093            // Don't queue up any more work if codegen was aborted, we're1094            // just waiting for our existing children to finish.1095            if used_token_count == 0 {1096                break;1097            }1098        }10991100        // Relinquish accidentally acquired extra tokens. Subtract 1 for the implicit token.1101        tokens.truncate(used_token_count.saturating_sub(1));11021103        match coordinator_receive.recv().unwrap() {1104            // Save the token locally and the next turn of the loop will use1105            // this to spawn a new unit of work, or it may get dropped1106            // immediately if we have no more work to spawn.1107            ThinLtoMessage::Token(token) => match token {1108                Ok(token) => {1109                    tokens.push(token);1110                }1111                Err(e) => {1112                    let msg = &format!("failed to acquire jobserver token: {e}");1113                    shared_emitter.fatal(msg);1114                    codegen_aborted = Some(FatalError);1115                }1116            },11171118            ThinLtoMessage::WorkItem { result } => {1119                // If a thread exits successfully then we drop a token associated1120                // with that worker and update our `used_token_count` count.1121                // We may later re-acquire a token to continue running more work.1122                // We may also not actually drop a token here if the worker was1123                // running with an "ephemeral token".1124                used_token_count -= 1;11251126                match result {1127                    Ok(compiled_module) => compiled_modules.push(compiled_module),1128                    Err(Some(WorkerFatalError)) => {1129                        // Like `CodegenAborted`, wait for remaining work to finish.1130                        codegen_aborted = Some(FatalError);1131                    }1132                    Err(None) => {1133                        // If the thread failed that means it panicked, so1134                        // we abort immediately.1135                        bug!("worker thread panicked");1136                    }1137                }1138            }1139        }1140    }11411142    if let Some(codegen_aborted) = codegen_aborted {1143        codegen_aborted.raise();1144    }11451146    compiled_modules1147}11481149/// Messages sent to the coordinator.1150pub(crate) enum Message<B: WriteBackendMethods> {1151    /// A jobserver token has become available. Sent from the jobserver helper1152    /// thread.1153    Token(io::Result<Acquired>),11541155    /// The backend has finished processing a work item for a codegen unit.1156    /// Sent from a backend worker thread.1157    WorkItem { result: Result<WorkItemResult<B>, Option<WorkerFatalError>> },11581159    /// The frontend has finished generating something (backend IR or a1160    /// post-LTO artifact) for a codegen unit, and it should be passed to the1161    /// backend. Sent from the main thread.1162    CodegenDone { llvm_work_item: WorkItem<B>, cost: u64 },11631164    /// Similar to `CodegenDone`, but for reusing a pre-LTO artifact1165    /// Sent from the main thread.1166    AddImportOnlyModule { bitcode_path: PathBuf, work_product: WorkProduct },11671168    /// The frontend has finished generating everything for all codegen units.1169    /// Sent from the main thread.1170    CodegenComplete,11711172    /// Some normal-ish compiler error occurred, and codegen should be wound1173    /// down. Sent from the main thread.1174    CodegenAborted,1175}11761177/// Messages sent to the coordinator.1178pub(crate) enum ThinLtoMessage {1179    /// A jobserver token has become available. Sent from the jobserver helper1180    /// thread.1181    Token(io::Result<Acquired>),11821183    /// The backend has finished processing a work item for a codegen unit.1184    /// Sent from a backend worker thread.1185    WorkItem { result: Result<CompiledModule, Option<WorkerFatalError>> },1186}11871188/// A message sent from the coordinator thread to the main thread telling it to1189/// process another codegen unit.1190pub struct CguMessage;11911192#[derive(PartialEq, Clone, Copy, Debug)]1193enum MainThreadState {1194    /// Doing nothing.1195    Idle,11961197    /// Doing codegen, i.e. MIR-to-LLVM-IR conversion.1198    Codegenning,11991200    /// Idle, but lending the compiler process's Token to an LLVM thread so it can do useful work.1201    Lending,1202}12031204fn start_executing_work<B: WriteBackendMethods>(1205    backend: B,1206    tcx: TyCtxt<'_>,1207    shared_emitter: SharedEmitter,1208    codegen_worker_send: Sender<CguMessage>,1209    coordinator_receive: Receiver<Message<B>>,1210    regular_config: Arc<ModuleConfig>,1211    allocator_config: Arc<ModuleConfig>,1212    mut allocator_module: Option<ModuleCodegen<B::Module>>,1213    coordinator_send: Sender<Message<B>>,1214) -> thread::JoinHandle<Result<MaybeLtoModules<B>, ()>> {1215    let sess = tcx.sess;1216    let prof = sess.prof.clone();12171218    // Compute the set of symbols we need to retain when doing thin local LTO (if we need to)1219    let exported_symbols_for_lto =1220        if sess.lto() == Lto::ThinLocal { lto::exported_symbols_for_lto(tcx, &[]) } else { vec![] };12211222    // First up, convert our jobserver into a helper thread so we can use normal1223    // mpsc channels to manage our messages and such.1224    // After we've requested tokens then we'll, when we can,1225    // get tokens on `coordinator_receive` which will1226    // get managed in the main loop below.1227    // Note that using `jobserver::Proxy` is not necessary here, the code below always acquires1228    // tokens before releasing them, so we can never accidentally release the last token1229    // permanently held by rustc process.1230    let parallel = match sess.opts.jobs.backend {1231        Some(n) if backend.supports_parallel() => Some(n),1232        _ => None,1233    };1234    let jobserver_helper = parallel.map(|_| {1235        let coordinator_send2 = coordinator_send.clone();1236        jobserver::client()1237            .into_helper_thread(move |token| {1238                drop(coordinator_send2.send(Message::Token::<B>(token)));1239            })1240            .expect("failed to spawn helper thread")1241    });12421243    let opt_level = tcx.backend_optimization_level(());1244    let tm_factory = backend.target_machine_factory(tcx.sess, opt_level);12451246    let remark_dir = if let Some(ref dir) = sess.opts.unstable_opts.remark_dir {1247        let result = fs::create_dir_all(dir).and_then(|_| dir.canonicalize());1248        match result {1249            Ok(dir) => Some(dir),1250            Err(error) => sess.dcx().emit_fatal(ErrorCreatingRemarkDir { error }),1251        }1252    } else {1253        None1254    };12551256    let stack_size = sess.opts.recommended_stack_size;12571258    let cgcx = CodegenContext {1259        crate_types: tcx.crate_types().to_vec(),1260        lto: sess.lto(),1261        use_linker_plugin_lto: sess.opts.cg.linker_plugin_lto.enabled(),1262        dylib_lto: sess.opts.unstable_opts.dylib_lto,1263        prefer_dynamic: sess.opts.cg.prefer_dynamic,1264        fewer_names: sess.fewer_names(),1265        save_temps: sess.opts.cg.save_temps,1266        time_trace: sess.opts.unstable_opts.llvm_time_trace,1267        remark: sess.opts.cg.remark.clone(),1268        remark_dir,1269        old_incr_comp_session_dir: tcx1270            .incr_comp_session1271            .as_ref()1272            .and_then(|incr_comp_session| incr_comp_session.old_session_directory.as_deref())1273            .map(ToOwned::to_owned),1274        new_incr_comp_session_dir: tcx1275            .incr_comp_session1276            .as_ref()1277            .map(|incr_comp_session| (&*incr_comp_session.new_session_directory).to_owned()),1278        output_filenames: Arc::clone(tcx.output_filenames(())),1279        module_config: regular_config,1280        opt_level,1281        msvc_imps_needed: msvc_imps_needed(tcx),1282        is_pe_coff: tcx.sess.target.is_like_windows,1283        target_can_use_split_dwarf: tcx.sess.target_can_use_split_dwarf(),1284        target_arch: tcx.sess.target.arch.to_string(),1285        target_is_like_darwin: tcx.sess.target.is_like_darwin,1286        target_is_like_aix: tcx.sess.target.is_like_aix,1287        target_is_like_gpu: tcx.sess.target.is_like_gpu,1288        rust_eh_personality_symbol: rustc_symbol_mangling::eh_personality_symbol(tcx),1289        split_debuginfo: tcx.sess.split_debuginfo(),1290        split_dwarf_kind: tcx.sess.opts.unstable_opts.split_dwarf_kind,1291        parallel,1292        pointer_size: tcx.data_layout.pointer_size(),1293    };12941295    // This is the "main loop" of parallel work happening for parallel codegen.1296    // It's here that we manage parallelism, schedule work, and work with1297    // messages coming from clients.1298    //1299    // There are a few environmental pre-conditions that shape how the system1300    // is set up:1301    //1302    // - Error reporting can only happen on the main thread because that's the1303    //   only place where we have access to the compiler `Session`.1304    // - LLVM work can be done on any thread.1305    // - Codegen can only happen on the main thread.1306    // - Each thread doing substantial work must be in possession of a `Token`1307    //   from the `Jobserver`.1308    // - The compiler process always holds one `Token`. Any additional `Tokens`1309    //   have to be requested from the `Jobserver`.1310    //1311    // Error Reporting1312    // ===============1313    // The error reporting restriction is handled separately from the rest: We1314    // set up a `SharedEmitter` that holds an open channel to the main thread.1315    // When an error occurs on any thread, the shared emitter will send the1316    // error message to the receiver main thread (`SharedEmitterMain`). The1317    // main thread will periodically query this error message queue and emit1318    // any error messages it has received. It might even abort compilation if1319    // it has received a fatal error. In this case we rely on all other threads1320    // being torn down automatically with the main thread.1321    // Since the main thread will often be busy doing codegen work, error1322    // reporting will be somewhat delayed, since the message queue can only be1323    // checked in between two work packages.1324    //1325    // Work Processing Infrastructure1326    // ==============================1327    // The work processing infrastructure knows three major actors:1328    //1329    // - the coordinator thread,1330    // - the main thread, and1331    // - LLVM worker threads1332    //1333    // The coordinator thread is running a message loop. It instructs the main1334    // thread about what work to do when, and it will spawn off LLVM worker1335    // threads as open LLVM WorkItems become available.1336    //1337    // The job of the main thread is to codegen CGUs into LLVM work packages1338    // (since the main thread is the only thread that can do this). The main1339    // thread will block until it receives a message from the coordinator, upon1340    // which it will codegen one CGU, send it to the coordinator and block1341    // again. This way the coordinator can control what the main thread is1342    // doing.1343    //1344    // The coordinator keeps a queue of LLVM WorkItems, and when a `Token` is1345    // available, it will spawn off a new LLVM worker thread and let it process1346    // a WorkItem. When a LLVM worker thread is done with its WorkItem,1347    // it will just shut down, which also frees all resources associated with1348    // the given LLVM module, and sends a message to the coordinator that the1349    // WorkItem has been completed.1350    //1351    // Work Scheduling1352    // ===============1353    // The scheduler's goal is to minimize the time it takes to complete all1354    // work there is, however, we also want to keep memory consumption low1355    // if possible. These two goals are at odds with each other: If memory1356    // consumption were not an issue, we could just let the main thread produce1357    // LLVM WorkItems at full speed, assuring maximal utilization of1358    // Tokens/LLVM worker threads. However, since codegen is usually faster1359    // than LLVM processing, the queue of LLVM WorkItems would fill up and each1360    // WorkItem potentially holds on to a substantial amount of memory.1361    //1362    // So the actual goal is to always produce just enough LLVM WorkItems as1363    // not to starve our LLVM worker threads. That means, once we have enough1364    // WorkItems in our queue, we can block the main thread, so it does not1365    // produce more until we need them.1366    //1367    // Doing LLVM Work on the Main Thread1368    // ----------------------------------1369    // Since the main thread owns the compiler process's implicit `Token`, it is1370    // wasteful to keep it blocked without doing any work. Therefore, what we do1371    // in this case is: We spawn off an additional LLVM worker thread that helps1372    // reduce the queue. The work it is doing corresponds to the implicit1373    // `Token`. The coordinator will mark the main thread as being busy with1374    // LLVM work. (The actual work happens on another OS thread but we just care1375    // about `Tokens`, not actual threads).1376    //1377    // When any LLVM worker thread finishes while the main thread is marked as1378    // "busy with LLVM work", we can do a little switcheroo: We give the Token1379    // of the just finished thread to the LLVM worker thread that is working on1380    // behalf of the main thread's implicit Token, thus freeing up the main1381    // thread again. The coordinator can then again decide what the main thread1382    // should do. This allows the coordinator to make decisions at more points1383    // in time.1384    //1385    // Striking a Balance between Throughput and Memory Consumption1386    // ------------------------------------------------------------1387    // Since our two goals, (1) use as many Tokens as possible and (2) keep1388    // memory consumption as low as possible, are in conflict with each other,1389    // we have to find a trade off between them. Right now, the goal is to keep1390    // all workers busy, which means that no worker should find the queue empty1391    // when it is ready to start.1392    // How do we do achieve this? Good question :) We actually never know how1393    // many `Tokens` are potentially available so it's hard to say how much to1394    // fill up the queue before switching the main thread to LLVM work. Also we1395    // currently don't have a means to estimate how long a running LLVM worker1396    // will still be busy with it's current WorkItem. However, we know the1397    // maximal count of available Tokens that makes sense (=the number of CPU1398    // cores), so we can take a conservative guess. The heuristic we use here1399    // is implemented in the `queue_full_enough()` function.1400    //1401    // Some Background on Jobservers1402    // -----------------------------1403    // It's worth also touching on the management of parallelism here. We don't1404    // want to just spawn a thread per work item because while that's optimal1405    // parallelism it may overload a system with too many threads or violate our1406    // configuration for the maximum amount of cpu to use for this process. To1407    // manage this we use the `jobserver` crate.1408    //1409    // Job servers are an artifact of GNU make and are used to manage1410    // parallelism between processes. A jobserver is a glorified IPC semaphore1411    // basically. Whenever we want to run some work we acquire the semaphore,1412    // and whenever we're done with that work we release the semaphore. In this1413    // manner we can ensure that the maximum number of parallel workers is1414    // capped at any one point in time.1415    //1416    // LTO and the coordinator thread1417    // ------------------------------1418    //1419    // The final job the coordinator thread is responsible for is managing LTO1420    // and how that works. When LTO is requested what we'll do is collect all1421    // optimized LLVM modules into a local vector on the coordinator. Once all1422    // modules have been codegened and optimized we hand this to the `lto`1423    // module for further optimization. The `lto` module will return back a list1424    // of more modules to work on, which the coordinator will continue to spawn1425    // work for.1426    //1427    // Each LLVM module is automatically sent back to the coordinator for LTO if1428    // necessary. There's already optimizations in place to avoid sending work1429    // back to the coordinator if LTO isn't requested.1430    let f = move || {1431        let _profiler = if cgcx.time_trace { B::thread_profiler() } else { Box::new(()) };14321433        // This is where we collect codegen units that have gone all the way1434        // through codegen and LLVM.1435        let mut compiled_modules = vec![];1436        let mut needs_fat_lto = Vec::new();1437        let mut needs_thin_lto = Vec::new();1438        let mut lto_import_only_modules = Vec::new();14391440        /// Possible state transitions:1441        /// - Ongoing -> Completed1442        /// - Ongoing -> Aborted1443        /// - Completed -> Aborted1444        #[derive(Debug, PartialEq)]1445        enum CodegenState {1446            Ongoing,1447            Completed,1448            Aborted,1449        }1450        use CodegenState::*;1451        let mut codegen_state = Ongoing;14521453        // This is the queue of LLVM work items that still need processing.1454        let mut work_items = Vec::<(WorkItem<B>, u64)>::new();14551456        // This are the Jobserver Tokens we currently hold. Does not include1457        // the implicit Token the compiler process owns no matter what.1458        let mut tokens = Vec::new();14591460        let mut main_thread_state = MainThreadState::Idle;14611462        // How many LLVM worker threads are running while holding a Token. This1463        // *excludes* any that the main thread is lending a Token to.1464        let mut running_with_own_token = 0;14651466        // How many LLVM worker threads are running in total. This *includes*1467        // any that the main thread is lending a Token to.1468        let running_with_any_token = |main_thread_state, running_with_own_token| {1469            running_with_own_token1470                + if main_thread_state == MainThreadState::Lending { 1 } else { 0 }1471        };14721473        let mut llvm_start_time: Option<VerboseTimingGuard<'_>> = None;14741475        if let Some(allocator_module) = &mut allocator_module {1476            B::optimize(&cgcx, &prof, &shared_emitter, allocator_module, &allocator_config);1477        }14781479        // Run the message loop while there's still anything that needs message1480        // processing. Note that as soon as codegen is aborted we simply want to1481        // wait for all existing work to finish, so many of the conditions here1482        // only apply if codegen hasn't been aborted as they represent pending1483        // work to be done.1484        loop {1485            // While there are still CGUs to be codegened, the coordinator has1486            // to decide how to utilize the compiler processes implicit Token:1487            // For codegenning more CGU or for running them through LLVM.1488            if codegen_state == Ongoing {1489                if main_thread_state == MainThreadState::Idle {1490                    // Compute the number of workers that will be running once we've taken as many1491                    // items from the work queue as we can, plus one for the main thread. It's not1492                    // critically important that we use this instead of just1493                    // `running_with_own_token`, but it prevents the `queue_full_enough` heuristic1494                    // from fluctuating just because a worker finished up and we decreased the1495                    // `running_with_own_token` count, even though we're just going to increase it1496                    // right after this when we put a new worker to work.1497                    let extra_tokens = tokens.len().checked_sub(running_with_own_token).unwrap();1498                    let additional_running = std::cmp::min(extra_tokens, work_items.len());1499                    let anticipated_running = running_with_own_token + additional_running + 1;15001501                    if !queue_full_enough(work_items.len(), anticipated_running) {1502                        // The queue is not full enough, process more codegen units:1503                        if codegen_worker_send.send(CguMessage).is_err() {1504                            panic!("Could not send CguMessage to main thread")1505                        }1506                        main_thread_state = MainThreadState::Codegenning;1507                    } else {1508                        // The queue is full enough to not let the worker1509                        // threads starve. Use the implicit Token to do some1510                        // LLVM work too.1511                        let (item, _) =1512                            work_items.pop().expect("queue empty - queue_full_enough() broken?");1513                        main_thread_state = MainThreadState::Lending;1514                        spawn_work(1515                            &cgcx,1516                            &prof,1517                            shared_emitter.clone(),1518                            coordinator_send.clone(),1519                            &mut llvm_start_time,1520                            item,1521                            stack_size,1522                        );1523                    }1524                }1525            } else if codegen_state == Completed {1526                if running_with_any_token(main_thread_state, running_with_own_token) == 01527                    && work_items.is_empty()1528                {1529                    // All codegen work is done.1530                    break;1531                }15321533                // In this branch, we know that everything has been codegened,1534                // so it's just a matter of determining whether the implicit1535                // Token is free to use for LLVM work.1536                match main_thread_state {1537                    MainThreadState::Idle => {1538                        if let Some((item, _)) = work_items.pop() {1539                            main_thread_state = MainThreadState::Lending;1540                            spawn_work(1541                                &cgcx,1542                                &prof,1543                                shared_emitter.clone(),1544                                coordinator_send.clone(),1545                                &mut llvm_start_time,1546                                item,1547                                stack_size,1548                            );1549                        } else {1550                            // There is no unstarted work, so let the main thread1551                            // take over for a running worker. Otherwise the1552                            // implicit token would just go to waste.1553                            // We reduce the `running` counter by one. The1554                            // `tokens.truncate()` below will take care of1555                            // giving the Token back.1556                            assert!(running_with_own_token > 0);1557                            running_with_own_token -= 1;1558                            main_thread_state = MainThreadState::Lending;1559                        }1560                    }1561                    MainThreadState::Codegenning => bug!(1562                        "codegen worker should not be codegenning after \1563                              codegen was already completed"1564                    ),1565                    MainThreadState::Lending => {1566                        // Already making good use of that token1567                    }1568                }1569            } else {1570                // Don't queue up any more work if codegen was aborted, we're1571                // just waiting for our existing children to finish.1572                assert!(codegen_state == Aborted);1573                if running_with_any_token(main_thread_state, running_with_own_token) == 0 {1574                    break;1575                }1576            }15771578            // Spin up what work we can, only doing this while we've got available1579            // parallelism slots and work left to spawn.1580            if codegen_state != Aborted {1581                while running_with_own_token < tokens.len()1582                    && let Some((item, _)) = work_items.pop()1583                {1584                    spawn_work(1585                        &cgcx,1586                        &prof,1587                        shared_emitter.clone(),1588                        coordinator_send.clone(),1589                        &mut llvm_start_time,1590                        item,1591                        stack_size,1592                    );1593                    running_with_own_token += 1;1594                }1595            }15961597            // Relinquish accidentally acquired extra tokens.1598            tokens.truncate(running_with_own_token);15991600            match coordinator_receive.recv().unwrap() {1601                // Save the token locally and the next turn of the loop will use1602                // this to spawn a new unit of work, or it may get dropped1603                // immediately if we have no more work to spawn.1604                Message::Token(token) => {1605                    match token {1606                        Ok(token) => {1607                            tokens.push(token);16081609                            if main_thread_state == MainThreadState::Lending {1610                                // If the main thread token is used for LLVM work1611                                // at the moment, we turn that thread into a regular1612                                // LLVM worker thread, so the main thread is free1613                                // to react to codegen demand.1614                                main_thread_state = MainThreadState::Idle;1615                                running_with_own_token += 1;1616                            }1617                        }1618                        Err(e) => {1619                            let msg = &format!("failed to acquire jobserver token: {e}");1620                            shared_emitter.fatal(msg);1621                            codegen_state = Aborted;1622                        }1623                    }1624                }16251626                Message::CodegenDone { llvm_work_item, cost } => {1627                    // We keep the queue sorted by estimated processing cost,1628                    // so that more expensive items are processed earlier. This1629                    // is good for throughput as it gives the main thread more1630                    // time to fill up the queue and it avoids scheduling1631                    // expensive items to the end.1632                    // Note, however, that this is not ideal for memory1633                    // consumption, as LLVM module sizes are not evenly1634                    // distributed.1635                    let insertion_index = work_items.binary_search_by_key(&cost, |&(_, cost)| cost);1636                    let insertion_index = match insertion_index {1637                        Ok(idx) | Err(idx) => idx,1638                    };1639                    work_items.insert(insertion_index, (llvm_work_item, cost));16401641                    if let Some(helper) = &jobserver_helper1642                        && running_with_any_token(main_thread_state, running_with_own_token)1643                            < cgcx.parallel.unwrap().get()1644                    {1645                        helper.request_token();1646                    }1647                    assert_eq!(main_thread_state, MainThreadState::Codegenning);1648                    main_thread_state = MainThreadState::Idle;1649                }16501651                Message::CodegenComplete => {1652                    if codegen_state != Aborted {1653                        codegen_state = Completed;1654                    }1655                    assert_eq!(main_thread_state, MainThreadState::Codegenning);1656                    main_thread_state = MainThreadState::Idle;1657                }16581659                // If codegen is aborted that means translation was aborted due1660                // to some normal-ish compiler error. In this situation we want1661                // to exit as soon as possible, but we want to make sure all1662                // existing work has finished. Flag codegen as being done, and1663                // then conditions above will ensure no more work is spawned but1664                // we'll keep executing this loop until `running_with_own_token`1665                // hits 0.1666                Message::CodegenAborted => {1667                    codegen_state = Aborted;1668                }16691670                Message::WorkItem { result } => {1671                    // If a thread exits successfully then we drop a token associated1672                    // with that worker and update our `running_with_own_token` count.1673                    // We may later re-acquire a token to continue running more work.1674                    // We may also not actually drop a token here if the worker was1675                    // running with an "ephemeral token".1676                    if main_thread_state == MainThreadState::Lending {1677                        main_thread_state = MainThreadState::Idle;1678                    } else {1679                        running_with_own_token -= 1;1680                    }16811682                    match result {1683                        Ok(WorkItemResult::Finished(compiled_module)) => {1684                            compiled_modules.push(compiled_module);1685                        }1686                        Ok(WorkItemResult::NeedsFatLto(fat_lto_input)) => {1687                            assert!(needs_thin_lto.is_empty());1688                            needs_fat_lto.push(fat_lto_input);1689                        }1690                        Ok(WorkItemResult::NeedsThinLto(name, thin_buffer)) => {1691                            assert!(needs_fat_lto.is_empty());1692                            needs_thin_lto.push(ThinLtoInput::Red {1693                                name,1694                                buffer: SerializedModule::Local(thin_buffer),1695                            });1696                        }1697                        Err(Some(WorkerFatalError)) => {1698                            // Like `CodegenAborted`, wait for remaining work to finish.1699                            codegen_state = Aborted;1700                        }1701                        Err(None) => {1702                            // If the thread failed that means it panicked, so1703                            // we abort immediately.1704                            bug!("worker thread panicked");1705                        }1706                    }1707                }17081709                Message::AddImportOnlyModule { bitcode_path, work_product } => {1710                    assert_eq!(codegen_state, Ongoing);1711                    assert_eq!(main_thread_state, MainThreadState::Codegenning);1712                    lto_import_only_modules.push((bitcode_path, work_product));1713                    main_thread_state = MainThreadState::Idle;1714                }1715            }1716        }17171718        // Drop to print timings1719        drop(llvm_start_time);17201721        if codegen_state == Aborted {1722            return Err(());1723        }17241725        drop(codegen_state);1726        drop(tokens);1727        drop(jobserver_helper);1728        assert!(work_items.is_empty());17291730        if !needs_fat_lto.is_empty() {1731            assert!(compiled_modules.is_empty());1732            assert!(needs_thin_lto.is_empty());17331734            if let Some(allocator_module) = allocator_module.take() {1735                needs_fat_lto.push(FatLtoInput::InMemory(allocator_module));1736            }17371738            for (bitcode_path, wp) in lto_import_only_modules {1739                needs_fat_lto.push(FatLtoInput::Serialized { name: wp.cgu_name, bitcode_path })1740            }17411742            return Ok(MaybeLtoModules::FatLto { cgcx, needs_fat_lto });1743        } else if !needs_thin_lto.is_empty() || !lto_import_only_modules.is_empty() {1744            assert!(compiled_modules.is_empty());1745            assert!(needs_fat_lto.is_empty());17461747            for (bitcode_path, wp) in lto_import_only_modules {1748                needs_thin_lto.push(ThinLtoInput::Green { wp, bitcode_path })1749            }17501751            if cgcx.lto == Lto::ThinLocal {1752                compiled_modules.extend(do_thin_lto::<B>(1753                    &cgcx,1754                    &prof,1755                    shared_emitter.clone(),1756                    tm_factory,1757                    &exported_symbols_for_lto,1758                    &[],1759                    needs_thin_lto,1760                    stack_size,1761                ));1762            } else {1763                if let Some(allocator_module) = allocator_module.take() {1764                    let thin_buffer = B::serialize_module(allocator_module.module_llvm, true);1765                    needs_thin_lto.push(ThinLtoInput::Red {1766                        name: allocator_module.name,1767                        buffer: SerializedModule::Local(thin_buffer),1768                    });1769                }17701771                return Ok(MaybeLtoModules::ThinLto { cgcx, needs_thin_lto });1772            }1773        }17741775        Ok(MaybeLtoModules::NoLto(CompiledModules {1776            modules: compiled_modules,1777            allocator_module: allocator_module.map(|allocator_module| {1778                B::codegen(&cgcx, &prof, &shared_emitter, allocator_module, &allocator_config)1779            }),1780        }))1781    };1782    return std::thread::Builder::new()1783        .name("coordinator".to_owned())1784        .spawn(f)1785        .expect("failed to spawn coordinator thread");17861787    // A heuristic that determines if we have enough LLVM WorkItems in the1788    // queue so that the main thread can do LLVM work instead of codegen1789    fn queue_full_enough(items_in_queue: usize, workers_running: usize) -> bool {1790        // This heuristic scales ahead-of-time codegen according to available1791        // concurrency, as measured by `workers_running`. The idea is that the1792        // more concurrency we have available, the more demand there will be for1793        // work items, and the fuller the queue should be kept to meet demand.1794        // An important property of this approach is that we codegen ahead of1795        // time only as much as necessary, so as to keep fewer LLVM modules in1796        // memory at once, thereby reducing memory consumption.1797        //1798        // When the number of workers running is less than the max concurrency1799        // available to us, this heuristic can cause us to instruct the main1800        // thread to work on an LLVM item (that is, tell it to "LLVM") instead1801        // of codegen, even though it seems like it *should* be codegenning so1802        // that we can create more work items and spawn more LLVM workers.1803        //1804        // But this is not a problem. When the main thread is told to LLVM,1805        // according to this heuristic and how work is scheduled, there is1806        // always at least one item in the queue, and therefore at least one1807        // pending jobserver token request. If there *is* more concurrency1808        // available, we will immediately receive a token, which will upgrade1809        // the main thread's LLVM worker to a real one (conceptually), and free1810        // up the main thread to codegen if necessary. On the other hand, if1811        // there isn't more concurrency, then the main thread working on an LLVM1812        // item is appropriate, as long as the queue is full enough for demand.1813        //1814        // Speaking of which, how full should we keep the queue? Probably less1815        // full than you'd think. A lot has to go wrong for the queue not to be1816        // full enough and for that to have a negative effect on compile times.1817        //1818        // Workers are unlikely to finish at exactly the same time, so when one1819        // finishes and takes another work item off the queue, we often have1820        // ample time to codegen at that point before the next worker finishes.1821        // But suppose that codegen takes so long that the workers exhaust the1822        // queue, and we have one or more workers that have nothing to work on.1823        // Well, it might not be so bad. Of all the LLVM modules we create and1824        // optimize, one has to finish last. It's not necessarily the case that1825        // by losing some concurrency for a moment, we delay the point at which1826        // that last LLVM module is finished and the rest of compilation can1827        // proceed. Also, when we can't take advantage of some concurrency, we1828        // give tokens back to the job server. That enables some other rustc to1829        // potentially make use of the available concurrency. That could even1830        // *decrease* overall compile time if we're lucky. But yes, if no other1831        // rustc can make use of the concurrency, then we've squandered it.1832        //1833        // However, keeping the queue full is also beneficial when we have a1834        // surge in available concurrency. Then items can be taken from the1835        // queue immediately, without having to wait for codegen.1836        //1837        // So, the heuristic below tries to keep one item in the queue for every1838        // four running workers. Based on limited benchmarking, this appears to1839        // be more than sufficient to avoid increasing compilation times.1840        let quarter_of_workers = workers_running - 3 * workers_running / 4;1841        items_in_queue > 0 && items_in_queue >= quarter_of_workers1842    }1843}18441845/// `FatalError` is explicitly not `Send`.1846#[must_use]1847pub(crate) struct WorkerFatalError;18481849fn spawn_work<'a, B: WriteBackendMethods>(1850    cgcx: &CodegenContext,1851    prof: &'a SelfProfilerRef,1852    shared_emitter: SharedEmitter,1853    coordinator_send: Sender<Message<B>>,1854    llvm_start_time: &mut Option<VerboseTimingGuard<'a>>,1855    work: WorkItem<B>,1856    stack_size: usize,1857) {1858    if llvm_start_time.is_none() {1859        *llvm_start_time = Some(prof.verbose_generic_activity("LLVM_passes"));1860    }18611862    let cgcx = cgcx.clone();1863    let prof = prof.clone();18641865    let name = work.short_description();1866    let f = move || {1867        let _profiler = if cgcx.time_trace { B::thread_profiler() } else { Box::new(()) };18681869        let result = std::panic::catch_unwind(AssertUnwindSafe(|| match work {1870            WorkItem::Optimize(m) => execute_optimize_work_item(&cgcx, &prof, shared_emitter, m),1871            WorkItem::CopyPostLtoArtifacts(m) => WorkItemResult::Finished(1872                execute_copy_from_cache_work_item(&cgcx, &prof, shared_emitter, m),1873            ),1874        }));18751876        let msg = match result {1877            Ok(result) => Message::WorkItem::<B> { result: Ok(result) },18781879            // We ignore any `FatalError` coming out of `execute_work_item`, as a1880            // diagnostic was already sent off to the main thread - just surface1881            // that there was an error in this worker.1882            Err(err) if err.is::<FatalErrorMarker>() => {1883                Message::WorkItem::<B> { result: Err(Some(WorkerFatalError)) }1884            }18851886            Err(_) => Message::WorkItem::<B> { result: Err(None) },1887        };1888        drop(coordinator_send.send(msg));1889    };1890    std::thread::Builder::new()1891        .name(name)1892        .stack_size(stack_size)1893        .spawn(f)1894        .expect("failed to spawn work thread");1895}18961897fn spawn_thin_lto_work<B: WriteBackendMethods>(1898    cgcx: &CodegenContext,1899    prof: &SelfProfilerRef,1900    shared_emitter: SharedEmitter,1901    tm_factory: TargetMachineFactoryFn<B>,1902    coordinator_send: Sender<ThinLtoMessage>,1903    work: ThinLtoWorkItem<B>,1904    stack_size: usize,1905) {1906    let cgcx = cgcx.clone();1907    let prof = prof.clone();19081909    let name = work.short_description();1910    let f = move || {1911        let _profiler = if cgcx.time_trace { B::thread_profiler() } else { Box::new(()) };19121913        let result = std::panic::catch_unwind(AssertUnwindSafe(|| match work {1914            ThinLtoWorkItem::CopyPostLtoArtifacts(m) => {1915                execute_copy_from_cache_work_item(&cgcx, &prof, shared_emitter, m)1916            }1917            ThinLtoWorkItem::ThinLto(m) => {1918                let _timer = prof.generic_activity_with_arg("codegen_module_perform_lto", m.name());1919                B::optimize_and_codegen_thin(&cgcx, &prof, &shared_emitter, tm_factory, m)1920            }1921        }));19221923        let msg = match result {1924            Ok(result) => ThinLtoMessage::WorkItem { result: Ok(result) },19251926            // We ignore any `FatalError` coming out of `execute_work_item`, as a1927            // diagnostic was already sent off to the main thread - just surface1928            // that there was an error in this worker.1929            Err(err) if err.is::<FatalErrorMarker>() => {1930                ThinLtoMessage::WorkItem { result: Err(Some(WorkerFatalError)) }1931            }19321933            Err(_) => ThinLtoMessage::WorkItem { result: Err(None) },1934        };1935        drop(coordinator_send.send(msg));1936    };1937    std::thread::Builder::new()1938        .name(name)1939        .stack_size(stack_size)1940        .spawn(f)1941        .expect("failed to spawn work thread");1942}19431944enum SharedEmitterMessage {1945    Diagnostic(DiagInner),1946    InlineAsmError(InlineAsmError),1947    Fatal(String),1948}19491950pub struct InlineAsmError {1951    // We store byte positions rather than a `Span` because this error is created on a codegen1952    // thread which doesn't have access to the span interner within the session globals. The byte1953    // positions are converted to a `Span` once they reach a thread with access to the span1954    // interner.1955    pub lo: BytePos,1956    pub hi: BytePos,1957    pub msg: String,1958    pub level: Level,1959    pub source: Option<(String, Vec<InnerSpan>)>,1960}19611962#[derive(Clone)]1963pub struct SharedEmitter {1964    sender: Sender<SharedEmitterMessage>,1965}19661967pub struct SharedEmitterMain {1968    receiver: Receiver<SharedEmitterMessage>,1969}19701971impl SharedEmitter {1972    fn new() -> (SharedEmitter, SharedEmitterMain) {1973        let (sender, receiver) = channel();19741975        (SharedEmitter { sender }, SharedEmitterMain { receiver })1976    }19771978    pub fn inline_asm_error(&self, err: InlineAsmError) {1979        drop(self.sender.send(SharedEmitterMessage::InlineAsmError(err)));1980    }19811982    fn fatal(&self, msg: &str) {1983        drop(self.sender.send(SharedEmitterMessage::Fatal(msg.to_string())));1984    }1985}19861987impl Emitter for SharedEmitter {1988    fn emit_diagnostic(&mut self, diag: DiagInner) {1989        drop(self.sender.send(SharedEmitterMessage::Diagnostic(diag)));1990    }19911992    fn source_map(&self) -> Option<&SourceMap> {1993        None1994    }1995}19961997impl SharedEmitterMain {1998    fn check(&self, sess: &Session, blocking: bool) {1999        loop {2000            let message = if blocking {