1use std::marker::PhantomData;2use std::panic::AssertUnwindSafe;3use std::path::{Path, PathBuf};4use std::sync::Arc;5use std::sync::mpsc::{Receiver, Sender, channel};6use std::{assert_matches, fs, io, mem, str, thread};78use rustc_abi::Size;9use rustc_data_structures::jobserver::{self, Acquired};10use rustc_data_structures::profiling::{SelfProfilerRef, VerboseTimingGuard};11use rustc_errors::emitter::Emitter;12use rustc_errors::{13 Diag, DiagArgMap, DiagCtxt, DiagCtxtHandle, DiagMessage, ErrCode, FatalError, FatalErrorMarker,14 Level, MultiSpan, Style, Suggestions, catch_fatal_errors,15};16use rustc_fs_util::link_or_copy;17use rustc_hir::find_attr;18use rustc_incremental::{19 copy_cgu_workproduct_to_incr_comp_cache_dir, in_incr_comp_dir, in_incr_comp_dir_sess,20};21use rustc_macros::{Decodable, Encodable};22use rustc_metadata::fs::copy_to_stdout;23use rustc_middle::bug;24use rustc_middle::dep_graph::{WorkProduct, WorkProductMap};25use rustc_middle::ty::TyCtxt;26use rustc_session::Session;27use rustc_session::config::{28 self, CrateType, Lto, OptLevel, OutFileName, OutputFilenames, OutputType, Passes,29 SwitchWithOptPath,30};31use rustc_span::source_map::SourceMap;32use rustc_span::{FileName, InnerSpan, Span, SpanData};33use rustc_target::spec::{MergeFunctions, SanitizerSet};34use tracing::debug;3536use crate::back::link::ensure_removed;37use crate::back::lto::{self, SerializedModule, check_lto_allowed};38use crate::errors::ErrorCreatingRemarkDir;39use crate::traits::*;40use crate::{41 CachedModuleCodegen, CompiledModule, CompiledModules, CrateInfo, ModuleCodegen, ModuleKind,42 errors,43};4445const PRE_LTO_BC_EXT: &str = "pre-lto.bc";4647/// What kind of object file to emit.48#[derive(Clone, Copy, PartialEq, Encodable, Decodable)]49pub enum EmitObj {50 // No object file.51 None,5253 // Just uncompressed llvm bitcode. Provides easy compatibility with54 // emscripten's ecc compiler, when used as the linker.55 Bitcode,5657 // Object code, possibly augmented with a bitcode section.58 ObjectCode(BitcodeSection),59}6061/// What kind of llvm bitcode section to embed in an object file.62#[derive(Clone, Copy, PartialEq, Encodable, Decodable)]63pub enum BitcodeSection {64 // No bitcode section.65 None,6667 // A full, uncompressed bitcode section.68 Full,69}7071/// Module-specific configuration for `optimize_and_codegen`.72#[derive(Encodable, Decodable)]73pub struct ModuleConfig {74 /// Names of additional optimization passes to run.75 pub passes: Vec<String>,76 /// Some(level) to optimize at a certain level, or None to run77 /// absolutely no optimizations (used for the allocator module).78 pub opt_level: Option<config::OptLevel>,7980 pub pgo_gen: SwitchWithOptPath,81 pub pgo_use: Option<PathBuf>,82 pub pgo_sample_use: Option<PathBuf>,83 pub debug_info_for_profiling: bool,84 pub instrument_coverage: bool,8586 pub sanitizer: SanitizerSet,87 pub sanitizer_recover: SanitizerSet,88 pub sanitizer_dataflow_abilist: Vec<String>,89 pub sanitizer_memory_track_origins: usize,9091 // Flags indicating which outputs to produce.92 pub emit_pre_lto_bc: bool,93 pub emit_bc: bool,94 pub emit_ir: bool,95 pub emit_asm: bool,96 pub emit_obj: EmitObj,97 pub emit_thin_lto_summary: bool,9899 // Miscellaneous flags. These are mostly copied from command-line100 // options.101 pub verify_llvm_ir: bool,102 pub lint_llvm_ir: bool,103 pub no_prepopulate_passes: bool,104 pub no_builtins: bool,105 pub vectorize_loop: bool,106 pub vectorize_slp: bool,107 pub merge_functions: bool,108 pub emit_lifetime_markers: bool,109 pub llvm_plugins: Vec<String>,110 pub autodiff: Vec<config::AutoDiff>,111 pub offload: Vec<config::Offload>,112}113114impl ModuleConfig {115 fn new(kind: ModuleKind, tcx: TyCtxt<'_>, no_builtins: bool) -> ModuleConfig {116 // If it's a regular module, use `$regular`, otherwise use `$other`.117 // `$regular` and `$other` are evaluated lazily.118 macro_rules! if_regular {119 ($regular: expr, $other: expr) => {120 if let ModuleKind::Regular = kind { $regular } else { $other }121 };122 }123124 let sess = tcx.sess;125 let opt_level_and_size = if_regular!(Some(sess.opts.optimize), None);126127 let save_temps = sess.opts.cg.save_temps;128129 let should_emit_obj = sess.opts.output_types.contains_key(&OutputType::Exe)130 || match kind {131 ModuleKind::Regular => sess.opts.output_types.contains_key(&OutputType::Object),132 ModuleKind::Allocator => false,133 };134135 let emit_obj = if !should_emit_obj {136 EmitObj::None137 } else if sess.target.obj_is_bitcode138 || (sess.opts.cg.linker_plugin_lto.enabled()139 && (!no_builtins || tcx.sess.is_sanitizer_cfi_enabled()))140 {141 // This case is selected if the target uses objects as bitcode, or142 // if linker plugin LTO is enabled. In the linker plugin LTO case143 // the assumption is that the final link-step will read the bitcode144 // and convert it to object code. This may be done by either the145 // native linker or rustc itself.146 //147 // By default this branch is skipped for `#![no_builtins]` crates so148 // they emit native object files (machine code), not LLVM bitcode149 // objects for the linker (see rust-lang/rust#146133).150 //151 // However, when LLVM CFI is enabled (`-Zsanitizer=cfi`), this152 // breaks LLVM's expected pipeline: LLVM emits `llvm.type.test`153 // intrinsics and related metadata that must be lowered by LLVM's154 // `LowerTypeTests` pass before instruction selection during155 // link-time LTO. Otherwise, `llvm.type.test` intrinsics and related156 // metadata are not lowered by LLVM's `LowerTypeTests` pass before157 // reaching the target backend, and LLVM may abort during codegen158 // (for example in SelectionDAG type legalization) (see159 // rust-lang/rust#142284).160 //161 // Therefore, with `-Clinker-plugin-lto` and `-Zsanitizer=cfi`, a162 // `#![no_builtins]` crate must still use rustc's `EmitObj::Bitcode`163 // path (and emit LLVM bitcode in the `.o` for linker-based LTO).164 EmitObj::Bitcode165 } else if need_bitcode_in_object(tcx) || sess.target.requires_lto {166 EmitObj::ObjectCode(BitcodeSection::Full)167 } else {168 EmitObj::ObjectCode(BitcodeSection::None)169 };170171 ModuleConfig {172 passes: if_regular!(sess.opts.cg.passes.clone(), vec![]),173174 opt_level: opt_level_and_size,175176 pgo_gen: if_regular!(177 sess.opts.cg.profile_generate.clone(),178 SwitchWithOptPath::Disabled179 ),180 pgo_use: if_regular!(sess.opts.cg.profile_use.clone(), None),181 pgo_sample_use: if_regular!(sess.opts.unstable_opts.profile_sample_use.clone(), None),182 debug_info_for_profiling: sess.opts.unstable_opts.debuginfo_for_profiling,183 instrument_coverage: if_regular!(sess.instrument_coverage(), false),184185 sanitizer: if_regular!(sess.sanitizers(), SanitizerSet::empty()),186 sanitizer_dataflow_abilist: if_regular!(187 sess.opts.unstable_opts.sanitizer_dataflow_abilist.clone(),188 Vec::new()189 ),190 sanitizer_recover: if_regular!(191 sess.opts.unstable_opts.sanitizer_recover,192 SanitizerSet::empty()193 ),194 sanitizer_memory_track_origins: if_regular!(195 sess.opts.unstable_opts.sanitizer_memory_track_origins,196 0197 ),198199 emit_pre_lto_bc: if_regular!(200 save_temps || need_pre_lto_bitcode_for_incr_comp(sess),201 false202 ),203 emit_bc: if_regular!(204 save_temps || sess.opts.output_types.contains_key(&OutputType::Bitcode),205 save_temps206 ),207 emit_ir: if_regular!(208 sess.opts.output_types.contains_key(&OutputType::LlvmAssembly),209 false210 ),211 emit_asm: if_regular!(212 sess.opts.output_types.contains_key(&OutputType::Assembly),213 false214 ),215 emit_obj,216 emit_thin_lto_summary: if_regular!(217 sess.opts.output_types.contains_key(&OutputType::ThinLinkBitcode),218 false219 ),220221 verify_llvm_ir: sess.verify_llvm_ir(),222 lint_llvm_ir: sess.opts.unstable_opts.lint_llvm_ir,223 no_prepopulate_passes: sess.opts.cg.no_prepopulate_passes,224 no_builtins: no_builtins || sess.target.no_builtins,225226 // Copy what clang does by turning on loop vectorization at O2 and227 // slp vectorization at O3.228 vectorize_loop: !sess.opts.cg.no_vectorize_loops229 && (sess.opts.optimize == config::OptLevel::More230 || sess.opts.optimize == config::OptLevel::Aggressive),231 vectorize_slp: !sess.opts.cg.no_vectorize_slp232 && sess.opts.optimize == config::OptLevel::Aggressive,233234 // Some targets (namely, NVPTX) interact badly with the235 // MergeFunctions pass. This is because MergeFunctions can generate236 // new function calls which may interfere with the target calling237 // convention; e.g. for the NVPTX target, PTX kernels should not238 // call other PTX kernels. MergeFunctions can also be configured to239 // generate aliases instead, but aliases are not supported by some240 // backends (again, NVPTX). Therefore, allow targets to opt out of241 // the MergeFunctions pass, but otherwise keep the pass enabled (at242 // O2 and O3) since it can be useful for reducing code size.243 merge_functions: match sess244 .opts245 .unstable_opts246 .merge_functions247 .unwrap_or(sess.target.merge_functions)248 {249 MergeFunctions::Disabled => false,250 MergeFunctions::Trampolines | MergeFunctions::Aliases => {251 use config::OptLevel::*;252 match sess.opts.optimize {253 Aggressive | More | SizeMin | Size => true,254 Less | No => false,255 }256 }257 },258259 emit_lifetime_markers: sess.emit_lifetime_markers(),260 llvm_plugins: if_regular!(sess.opts.unstable_opts.llvm_plugins.clone(), vec![]),261 autodiff: if_regular!(sess.opts.unstable_opts.autodiff.clone(), vec![]),262 offload: if_regular!(sess.opts.unstable_opts.offload.clone(), vec![]),263 }264 }265266 pub fn bitcode_needed(&self) -> bool {267 self.emit_bc268 || self.emit_thin_lto_summary269 || self.emit_obj == EmitObj::Bitcode270 || self.emit_obj == EmitObj::ObjectCode(BitcodeSection::Full)271 }272273 pub fn embed_bitcode(&self) -> bool {274 self.emit_obj == EmitObj::ObjectCode(BitcodeSection::Full)275 }276}277278/// Configuration passed to the function returned by the `target_machine_factory`.279pub struct TargetMachineFactoryConfig {280 /// Split DWARF is enabled in LLVM by checking that `TM.MCOptions.SplitDwarfFile` isn't empty,281 /// so the path to the dwarf object has to be provided when we create the target machine.282 /// This can be ignored by backends which do not need it for their Split DWARF support.283 pub split_dwarf_file: Option<PathBuf>,284285 /// The name of the output object file. Used for setting OutputFilenames in target options286 /// so that LLVM can emit the CodeView S_OBJNAME record in pdb files287 pub output_obj_file: Option<PathBuf>,288}289290impl TargetMachineFactoryConfig {291 pub fn new(cgcx: &CodegenContext, module_name: &str) -> TargetMachineFactoryConfig {292 let split_dwarf_file = if cgcx.target_can_use_split_dwarf {293 cgcx.output_filenames.split_dwarf_path(294 cgcx.split_debuginfo,295 cgcx.split_dwarf_kind,296 module_name,297 )298 } else {299 None300 };301302 let output_obj_file =303 Some(cgcx.output_filenames.temp_path_for_cgu(OutputType::Object, module_name));304 TargetMachineFactoryConfig { split_dwarf_file, output_obj_file }305 }306}307308pub type TargetMachineFactoryFn<B> = Arc<309 dyn Fn(310 DiagCtxtHandle<'_>,311 TargetMachineFactoryConfig,312 ) -> <B as WriteBackendMethods>::TargetMachine313 + Send314 + Sync,315>;316317/// Additional resources used by optimize_and_codegen (not module specific)318#[derive(Clone, Encodable, Decodable)]319pub struct CodegenContext {320 // Resources needed when running LTO321 pub lto: Lto,322 pub use_linker_plugin_lto: bool,323 pub dylib_lto: bool,324 pub prefer_dynamic: bool,325 pub save_temps: bool,326 pub fewer_names: bool,327 pub time_trace: bool,328 pub crate_types: Vec<CrateType>,329 pub output_filenames: Arc<OutputFilenames>,330 pub module_config: Arc<ModuleConfig>,331 pub opt_level: OptLevel,332 pub backend_features: Vec<String>,333 pub msvc_imps_needed: bool,334 pub is_pe_coff: bool,335 pub target_can_use_split_dwarf: bool,336 pub target_arch: String,337 pub target_is_like_darwin: bool,338 pub target_is_like_aix: bool,339 pub target_is_like_gpu: bool,340 pub split_debuginfo: rustc_target::spec::SplitDebuginfo,341 pub split_dwarf_kind: rustc_session::config::SplitDwarfKind,342 pub pointer_size: Size,343344 /// LLVM optimizations for which we want to print remarks.345 pub remark: Passes,346 /// Directory into which should the LLVM optimization remarks be written.347 /// If `None`, they will be written to stderr.348 pub remark_dir: Option<PathBuf>,349 /// The incremental compilation session directory, or None if we are not350 /// compiling incrementally351 pub incr_comp_session_dir: Option<PathBuf>,352 /// `true` if the codegen should be run in parallel.353 ///354 /// Depends on [`WriteBackendMethods::supports_parallel()`] and `-Zno_parallel_backend`.355 pub parallel: bool,356}357358fn generate_thin_lto_work<B: WriteBackendMethods>(359 cgcx: &CodegenContext,360 prof: &SelfProfilerRef,361 dcx: DiagCtxtHandle<'_>,362 exported_symbols_for_lto: &[String],363 each_linked_rlib_for_lto: &[PathBuf],364 needs_thin_lto: Vec<ThinLtoInput<B>>,365) -> Vec<(ThinLtoWorkItem<B>, u64)> {366 let _prof_timer = prof.generic_activity("codegen_thin_generate_lto_work");367368 let (lto_modules, copy_jobs) = B::run_thin_lto(369 cgcx,370 prof,371 dcx,372 exported_symbols_for_lto,373 each_linked_rlib_for_lto,374 needs_thin_lto,375 );376 lto_modules377 .into_iter()378 .map(|module| {379 let cost = module.cost();380 (ThinLtoWorkItem::ThinLto(module), cost)381 })382 .chain(copy_jobs.into_iter().map(|wp| {383 (384 ThinLtoWorkItem::CopyPostLtoArtifacts(CachedModuleCodegen {385 name: wp.cgu_name.clone(),386 source: wp,387 }),388 0, // copying is very cheap389 )390 }))391 .collect()392}393394enum MaybeLtoModules<B: WriteBackendMethods> {395 NoLto(CompiledModules),396 FatLto { cgcx: CodegenContext, needs_fat_lto: Vec<FatLtoInput<B>> },397 ThinLto { cgcx: CodegenContext, needs_thin_lto: Vec<ThinLtoInput<B>> },398}399400fn need_bitcode_in_object(tcx: TyCtxt<'_>) -> bool {401 let sess = tcx.sess;402 sess.opts.cg.embed_bitcode403 && tcx.crate_types().contains(&CrateType::Rlib)404 && sess.opts.output_types.contains_key(&OutputType::Exe)405}406407fn need_pre_lto_bitcode_for_incr_comp(sess: &Session) -> bool {408 if sess.opts.incremental.is_none() {409 return false;410 }411412 match sess.lto() {413 Lto::No => false,414 Lto::Fat | Lto::Thin | Lto::ThinLocal => true,415 }416}417418pub(crate) fn start_async_codegen<B: WriteBackendMethods>(419 backend: B,420 tcx: TyCtxt<'_>,421 allocator_module: Option<ModuleCodegen<B::Module>>,422) -> OngoingCodegen<B> {423 let (coordinator_send, coordinator_receive) = channel();424425 let no_builtins = find_attr!(tcx, crate, NoBuiltins);426427 let regular_config = ModuleConfig::new(ModuleKind::Regular, tcx, no_builtins);428 let allocator_config = ModuleConfig::new(ModuleKind::Allocator, tcx, no_builtins);429430 let (shared_emitter, shared_emitter_main) = SharedEmitter::new();431 let (codegen_worker_send, codegen_worker_receive) = channel();432433 let coordinator_thread = start_executing_work(434 backend.clone(),435 tcx,436 shared_emitter,437 codegen_worker_send,438 coordinator_receive,439 Arc::new(regular_config),440 Arc::new(allocator_config),441 allocator_module,442 coordinator_send.clone(),443 );444445 OngoingCodegen {446 backend,447448 codegen_worker_receive,449 shared_emitter_main,450 coordinator: Coordinator {451 sender: coordinator_send,452 future: Some(coordinator_thread),453 phantom: PhantomData,454 },455 output_filenames: Arc::clone(tcx.output_filenames(())),456 }457}458459fn copy_all_cgu_workproducts_to_incr_comp_cache_dir(460 sess: &Session,461 compiled_modules: &CompiledModules,462) -> WorkProductMap {463 let mut work_products = WorkProductMap::default();464465 if sess.opts.incremental.is_none() || sess.opts.unstable_opts.disable_incr_comp_backend_caching466 {467 return work_products;468 }469470 let _timer = sess.timer("copy_all_cgu_workproducts_to_incr_comp_cache_dir");471472 for module in compiled_modules.modules.iter().filter(|m| m.kind == ModuleKind::Regular) {473 let mut files = Vec::new();474 if let Some(object_file_path) = &module.object {475 files.push((OutputType::Object.extension(), object_file_path.as_path()));476 }477 if let Some(global_asm_object_file_path) = &module.global_asm_object {478 files.push(("asm.o", global_asm_object_file_path.as_path()));479 }480 if let Some(dwarf_object_file_path) = &module.dwarf_object {481 files.push(("dwo", dwarf_object_file_path.as_path()));482 }483 if let Some(path) = &module.assembly {484 files.push((OutputType::Assembly.extension(), path.as_path()));485 }486 if let Some(path) = &module.llvm_ir {487 files.push((OutputType::LlvmAssembly.extension(), path.as_path()));488 }489 if let Some(path) = &module.bytecode {490 files.push((OutputType::Bitcode.extension(), path.as_path()));491 }492 let (id, product) = copy_cgu_workproduct_to_incr_comp_cache_dir(493 sess,494 &module.name,495 files.as_slice(),496 &module.links_from_incr_cache,497 );498 work_products.insert(id, product);499 }500501 work_products502}503504pub fn produce_final_output_artifacts(505 sess: &Session,506 compiled_modules: &CompiledModules,507 crate_output: &OutputFilenames,508) {509 let mut user_wants_bitcode = false;510 let mut user_wants_objects = false;511512 // Produce final compile outputs.513 let copy_gracefully = |from: &Path, to: &OutFileName| match to {514 OutFileName::Stdout if let Err(e) = copy_to_stdout(from) => {515 sess.dcx().emit_err(errors::CopyPath::new(from, to.as_path(), e));516 }517 OutFileName::Real(path) if let Err(e) = fs::copy(from, path) => {518 sess.dcx().emit_err(errors::CopyPath::new(from, path, e));519 }520 _ => {}521 };522523 let copy_if_one_unit = |output_type: OutputType, keep_numbered: bool| {524 if let [module] = &compiled_modules.modules[..] {525 // 1) Only one codegen unit. In this case it's no difficulty526 // to copy `foo.0.x` to `foo.x`.527 let path = crate_output.temp_path_for_cgu(output_type, &module.name);528 let output = crate_output.path(output_type);529 if !output_type.is_text_output() && output.is_tty() {530 sess.dcx()531 .emit_err(errors::BinaryOutputToTty { shorthand: output_type.shorthand() });532 } else {533 copy_gracefully(&path, &output);534 }535 if !sess.opts.cg.save_temps && !keep_numbered {536 // The user just wants `foo.x`, not `foo.#module-name#.x`.537 ensure_removed(sess.dcx(), &path);538 }539 } else {540 if crate_output.outputs.contains_explicit_name(&output_type) {541 // 2) Multiple codegen units, with `--emit foo=some_name`. We have542 // no good solution for this case, so warn the user.543 sess.dcx()544 .emit_warn(errors::IgnoringEmitPath { extension: output_type.extension() });545 } else if crate_output.single_output_file.is_some() {546 // 3) Multiple codegen units, with `-o some_name`. We have547 // no good solution for this case, so warn the user.548 sess.dcx().emit_warn(errors::IgnoringOutput { extension: output_type.extension() });549 } else {550 // 4) Multiple codegen units, but no explicit name. We551 // just leave the `foo.0.x` files in place.552 // (We don't have to do any work in this case.)553 }554 }555 };556557 // Flag to indicate whether the user explicitly requested bitcode.558 // Otherwise, we produced it only as a temporary output, and will need559 // to get rid of it.560 for output_type in crate_output.outputs.keys() {561 match *output_type {562 OutputType::Bitcode => {563 user_wants_bitcode = true;564 // Copy to .bc, but always keep the .0.bc. There is a later565 // check to figure out if we should delete .0.bc files, or keep566 // them for making an rlib.567 copy_if_one_unit(OutputType::Bitcode, true);568 }569 OutputType::ThinLinkBitcode => {570 copy_if_one_unit(OutputType::ThinLinkBitcode, false);571 }572 OutputType::LlvmAssembly => {573 copy_if_one_unit(OutputType::LlvmAssembly, false);574 }575 OutputType::Assembly => {576 copy_if_one_unit(OutputType::Assembly, false);577 }578 OutputType::Object => {579 user_wants_objects = true;580 copy_if_one_unit(OutputType::Object, true);581 }582 OutputType::Mir | OutputType::Metadata | OutputType::Exe | OutputType::DepInfo => {}583 }584 }585586 // Clean up unwanted temporary files.587588 // We create the following files by default:589 // - #crate#.#module-name#.rcgu.bc590 // - #crate#.#module-name#.rcgu.o591 // - #crate#.o (linked from crate.##.rcgu.o)592 // - #crate#.bc (copied from crate.##.rcgu.bc)593 // We may create additional files if requested by the user (through594 // `-C save-temps` or `--emit=` flags).595596 if !sess.opts.cg.save_temps {597 // Remove the temporary .#module-name#.rcgu.o objects. If the user didn't598 // explicitly request bitcode (with --emit=bc), and the bitcode is not599 // needed for building an rlib, then we must remove .#module-name#.bc as600 // well.601602 // Specific rules for keeping .#module-name#.rcgu.bc:603 // - If the user requested bitcode (`user_wants_bitcode`), and604 // codegen_units > 1, then keep it.605 // - If the user requested bitcode but codegen_units == 1, then we606 // can toss .#module-name#.rcgu.bc because we copied it to .bc earlier.607 // - If we're not building an rlib and the user didn't request608 // bitcode, then delete .#module-name#.rcgu.bc.609 // If you change how this works, also update back::link::link_rlib,610 // where .#module-name#.rcgu.bc files are (maybe) deleted after making an611 // rlib.612 let needs_crate_object = crate_output.outputs.contains_key(&OutputType::Exe);613614 let keep_numbered_bitcode = user_wants_bitcode && sess.codegen_units().as_usize() > 1;615616 let keep_numbered_objects =617 needs_crate_object || (user_wants_objects && sess.codegen_units().as_usize() > 1);618619 for module in compiled_modules.modules.iter() {620 if !keep_numbered_objects {621 if let Some(ref path) = module.object {622 ensure_removed(sess.dcx(), path);623 }624625 if let Some(ref path) = module.global_asm_object {626 ensure_removed(sess.dcx(), path);627 }628629 if let Some(ref path) = module.dwarf_object {630 ensure_removed(sess.dcx(), path);631 }632 }633634 if let Some(ref path) = module.bytecode {635 if !keep_numbered_bitcode {636 ensure_removed(sess.dcx(), path);637 }638 }639 }640641 if !user_wants_bitcode642 && let Some(ref allocator_module) = compiled_modules.allocator_module643 && let Some(ref path) = allocator_module.bytecode644 {645 ensure_removed(sess.dcx(), path);646 }647 }648649 if sess.opts.json_artifact_notifications {650 if let [module] = &compiled_modules.modules[..] {651 module.for_each_output(|_path, ty| {652 if sess.opts.output_types.contains_key(&ty) {653 let descr = ty.shorthand();654 // for single cgu file is renamed to drop cgu specific suffix655 // so we regenerate it the same way656 let path = crate_output.path(ty);657 sess.dcx().emit_artifact_notification(path.as_path(), descr);658 }659 });660 } else {661 for module in &compiled_modules.modules {662 module.for_each_output(|path, ty| {663 if sess.opts.output_types.contains_key(&ty) {664 let descr = ty.shorthand();665 sess.dcx().emit_artifact_notification(&path, descr);666 }667 });668 }669 }670 }671672 // We leave the following files around by default:673 // - #crate#.o674 // - #crate#.bc675 // These are used in linking steps and will be cleaned up afterward.676}677678pub(crate) enum WorkItem<B: WriteBackendMethods> {679 /// Optimize a newly codegened, totally unoptimized module.680 Optimize(ModuleCodegen<B::Module>),681 /// Copy the post-LTO artifacts from the incremental cache to the output682 /// directory.683 CopyPostLtoArtifacts(CachedModuleCodegen),684}685686enum ThinLtoWorkItem<B: WriteBackendMethods> {687 /// Copy the post-LTO artifacts from the incremental cache to the output688 /// directory.689 CopyPostLtoArtifacts(CachedModuleCodegen),690 /// Performs thin-LTO on the given module.691 ThinLto(lto::ThinModule<B>),692}693694// `pthread_setname()` on *nix ignores anything beyond the first 15695// bytes. Use short descriptions to maximize the space available for696// the module name.697#[cfg(not(windows))]698fn desc(short: &str, _long: &str, name: &str) -> String {699 // The short label is three bytes, and is followed by a space. That700 // leaves 11 bytes for the CGU name. How we obtain those 11 bytes701 // depends on the CGU name form.702 //703 // - Non-incremental, e.g. `regex.f10ba03eb5ec7975-cgu.0`: the part704 // before the `-cgu.0` is the same for every CGU, so use the705 // `cgu.0` part. The number suffix will be different for each706 // CGU.707 //708 // - Incremental (normal), e.g. `2i52vvl2hco29us0`: use the whole709 // name because each CGU will have a unique ASCII hash, and the710 // first 11 bytes will be enough to identify it.711 //712 // - Incremental (with `-Zhuman-readable-cgu-names`), e.g.713 // `regex.f10ba03eb5ec7975-re_builder.volatile`: use the whole714 // name. The first 11 bytes won't be enough to uniquely identify715 // it, but no obvious substring will, and this is a rarely used716 // option so it doesn't matter much.717 //718 assert_eq!(short.len(), 3);719 let name = if let Some(index) = name.find("-cgu.") {720 &name[index + 1..] // +1 skips the leading '-'.721 } else {722 name723 };724 format!("{short} {name}")725}726727// Windows has no thread name length limit, so use more descriptive names.728#[cfg(windows)]729fn desc(_short: &str, long: &str, name: &str) -> String {730 format!("{long} {name}")731}732733impl<B: WriteBackendMethods> WorkItem<B> {734 /// Generate a short description of this work item suitable for use as a thread name.735 fn short_description(&self) -> String {736 match self {737 WorkItem::Optimize(m) => desc("opt", "optimize module", &m.name),738 WorkItem::CopyPostLtoArtifacts(m) => desc("cpy", "copy LTO artifacts for", &m.name),739 }740 }741}742743impl<B: WriteBackendMethods> ThinLtoWorkItem<B> {744 /// Generate a short description of this work item suitable for use as a thread name.745 fn short_description(&self) -> String {746 match self {747 ThinLtoWorkItem::CopyPostLtoArtifacts(m) => {748 desc("cpy", "copy LTO artifacts for", &m.name)749 }750 ThinLtoWorkItem::ThinLto(m) => desc("lto", "thin-LTO module", m.name()),751 }752 }753}754755/// A result produced by the backend.756pub(crate) enum WorkItemResult<B: WriteBackendMethods> {757 /// The backend has finished compiling a CGU, nothing more required.758 Finished(CompiledModule),759760 /// The backend has finished compiling a CGU, which now needs to go through761 /// fat LTO.762 NeedsFatLto(FatLtoInput<B>),763764 /// The backend has finished compiling a CGU, which now needs to go through765 /// thin LTO.766 NeedsThinLto(String, B::ModuleBuffer),767}768769pub enum FatLtoInput<B: WriteBackendMethods> {770 Serialized { name: String, bitcode_path: PathBuf },771 InMemory(ModuleCodegen<B::Module>),772}773774pub enum ThinLtoInput<B: WriteBackendMethods> {775 Red { name: String, buffer: SerializedModule<B::ModuleBuffer> },776 Green { wp: WorkProduct, bitcode_path: PathBuf },777}778779/// Actual LTO type we end up choosing based on multiple factors.780pub(crate) enum ComputedLtoType {781 No,782 Thin,783 Fat,784}785786pub(crate) fn compute_per_cgu_lto_type(787 sess_lto: &Lto,788 linker_does_lto: bool,789 sess_crate_types: &[CrateType],790) -> ComputedLtoType {791 // If the linker does LTO, we don't have to do it. Note that we792 // keep doing full LTO, if it is requested, as not to break the793 // assumption that the output will be a single module.794795 // We ignore a request for full crate graph LTO if the crate type796 // is only an rlib, as there is no full crate graph to process,797 // that'll happen later.798 //799 // This use case currently comes up primarily for targets that800 // require LTO so the request for LTO is always unconditionally801 // passed down to the backend, but we don't actually want to do802 // anything about it yet until we've got a final product.803 let is_rlib = matches!(sess_crate_types, [CrateType::Rlib]);804805 match sess_lto {806 Lto::ThinLocal if !linker_does_lto => ComputedLtoType::Thin,807 Lto::Thin if !linker_does_lto && !is_rlib => ComputedLtoType::Thin,808 Lto::Fat if !is_rlib => ComputedLtoType::Fat,809 _ => ComputedLtoType::No,810 }811}812813fn execute_optimize_work_item<B: WriteBackendMethods>(814 cgcx: &CodegenContext,815 prof: &SelfProfilerRef,816 shared_emitter: SharedEmitter,817 mut module: ModuleCodegen<B::Module>,818) -> WorkItemResult<B> {819 let _timer = prof.generic_activity_with_arg("codegen_module_optimize", &*module.name);820821 B::optimize(cgcx, prof, &shared_emitter, &mut module, &cgcx.module_config);822823 // After we've done the initial round of optimizations we need to824 // decide whether to synchronously codegen this module or ship it825 // back to the coordinator thread for further LTO processing (which826 // has to wait for all the initial modules to be optimized).827828 let lto_type =829 compute_per_cgu_lto_type(&cgcx.lto, cgcx.use_linker_plugin_lto, &cgcx.crate_types);830831 // If we're doing some form of incremental LTO then we need to be sure to832 // save our module to disk first.833 let bitcode = if cgcx.module_config.emit_pre_lto_bc {834 let filename = pre_lto_bitcode_filename(&module.name);835 cgcx.incr_comp_session_dir.as_ref().map(|path| path.join(&filename))836 } else {837 None838 };839840 match lto_type {841 ComputedLtoType::No => {842 let module = B::codegen(cgcx, &prof, &shared_emitter, module, &cgcx.module_config);843 WorkItemResult::Finished(module)844 }845 ComputedLtoType::Thin => {846 let thin_buffer = B::serialize_module(module.module_llvm, true);847 if let Some(path) = bitcode {848 fs::write(&path, thin_buffer.data()).unwrap_or_else(|e| {849 panic!("Error writing pre-lto-bitcode file `{}`: {}", path.display(), e);850 });851 }852 WorkItemResult::NeedsThinLto(module.name, thin_buffer)853 }854 ComputedLtoType::Fat => match bitcode {855 Some(path) => {856 let buffer = B::serialize_module(module.module_llvm, false);857 fs::write(&path, buffer.data()).unwrap_or_else(|e| {858 panic!("Error writing pre-lto-bitcode file `{}`: {}", path.display(), e);859 });860 WorkItemResult::NeedsFatLto(FatLtoInput::Serialized {861 name: module.name,862 bitcode_path: path,863 })864 }865 None => WorkItemResult::NeedsFatLto(FatLtoInput::InMemory(module)),866 },867 }868}869870fn execute_copy_from_cache_work_item(871 cgcx: &CodegenContext,872 prof: &SelfProfilerRef,873 shared_emitter: SharedEmitter,874 module: CachedModuleCodegen,875) -> CompiledModule {876 let _timer =877 prof.generic_activity_with_arg("codegen_copy_artifacts_from_incr_cache", &*module.name);878879 let dcx = DiagCtxt::new(Box::new(shared_emitter));880 let dcx = dcx.handle();881882 let incr_comp_session_dir = cgcx.incr_comp_session_dir.as_ref().unwrap();883884 let mut links_from_incr_cache = Vec::new();885886 let mut load_from_incr_comp_dir = |output_path: PathBuf, saved_path: &str| {887 let source_file = in_incr_comp_dir(incr_comp_session_dir, saved_path);888 debug!(889 "copying preexisting module `{}` from {:?} to {}",890 module.name,891 source_file,892 output_path.display()893 );894 match link_or_copy(&source_file, &output_path) {895 Ok(_) => {896 links_from_incr_cache.push(source_file);897 Some(output_path)898 }899 Err(error) => {900 dcx.emit_err(errors::CopyPathBuf { source_file, output_path, error });901 None902 }903 }904 };905906 let dwarf_object =907 module.source.saved_files.get("dwo").as_ref().and_then(|saved_dwarf_object_file| {908 let dwarf_obj_out = cgcx909 .output_filenames910 .split_dwarf_path(cgcx.split_debuginfo, cgcx.split_dwarf_kind, &module.name)911 .expect(912 "saved dwarf object in work product but `split_dwarf_path` returned `None`",913 );914 load_from_incr_comp_dir(dwarf_obj_out, saved_dwarf_object_file)915 });916917 let mut load_from_incr_cache = |perform, output_type: OutputType| {918 if perform {919 let saved_file = module.source.saved_files.get(output_type.extension())?;920 let output_path = cgcx.output_filenames.temp_path_for_cgu(output_type, &module.name);921 load_from_incr_comp_dir(output_path, &saved_file)922 } else {923 None924 }925 };926927 let module_config = &cgcx.module_config;928 let should_emit_obj = module_config.emit_obj != EmitObj::None;929 let assembly = load_from_incr_cache(module_config.emit_asm, OutputType::Assembly);930 let llvm_ir = load_from_incr_cache(module_config.emit_ir, OutputType::LlvmAssembly);931 let bytecode = load_from_incr_cache(module_config.emit_bc, OutputType::Bitcode);932 let object = load_from_incr_cache(should_emit_obj, OutputType::Object);933 let global_asm_object =934 if should_emit_obj && let Some(saved_file) = module.source.saved_files.get("asm.o") {935 let output_path = cgcx.output_filenames.temp_path_ext_for_cgu("asm.o", &module.name);936 load_from_incr_comp_dir(output_path, &saved_file)937 } else {938 None939 };940 if should_emit_obj && object.is_none() {941 dcx.emit_fatal(errors::NoSavedObjectFile { cgu_name: &module.name })942 }943944 CompiledModule {945 links_from_incr_cache,946 kind: ModuleKind::Regular,947 name: module.name,948 object,949 global_asm_object,950 dwarf_object,951 bytecode,952 assembly,953 llvm_ir,954 }955}956957fn do_fat_lto<B: WriteBackendMethods>(958 sess: &Session,959 cgcx: &CodegenContext,960 shared_emitter: SharedEmitter,961 tm_factory: TargetMachineFactoryFn<B>,962 exported_symbols_for_lto: &[String],963 each_linked_rlib_for_lto: &[PathBuf],964 needs_fat_lto: Vec<FatLtoInput<B>>,965) -> CompiledModule {966 let _timer = sess.prof.verbose_generic_activity("LLVM_fatlto");967968 let dcx = DiagCtxt::new(Box::new(shared_emitter.clone()));969 let dcx = dcx.handle();970971 check_lto_allowed(&cgcx, dcx);972973 B::optimize_and_codegen_fat_lto(974 sess,975 cgcx,976 &shared_emitter,977 tm_factory,978 exported_symbols_for_lto,979 each_linked_rlib_for_lto,980 needs_fat_lto,981 )982}983984fn do_thin_lto<B: WriteBackendMethods>(985 cgcx: &CodegenContext,986 prof: &SelfProfilerRef,987 shared_emitter: SharedEmitter,988 tm_factory: TargetMachineFactoryFn<B>,989 exported_symbols_for_lto: &[String],990 each_linked_rlib_for_lto: &[PathBuf],991 needs_thin_lto: Vec<ThinLtoInput<B>>,992) -> Vec<CompiledModule> {993 let _timer = prof.verbose_generic_activity("LLVM_thinlto");994995 let dcx = DiagCtxt::new(Box::new(shared_emitter.clone()));996 let dcx = dcx.handle();997998 check_lto_allowed(&cgcx, dcx);9991000 let (coordinator_send, coordinator_receive) = channel();10011002 // First up, convert our jobserver into a helper thread so we can use normal1003 // mpsc channels to manage our messages and such.1004 // After we've requested tokens then we'll, when we can,1005 // get tokens on `coordinator_receive` which will1006 // get managed in the main loop below.1007 let coordinator_send2 = coordinator_send.clone();1008 let helper = jobserver::client()1009 .into_helper_thread(move |token| {1010 drop(coordinator_send2.send(ThinLtoMessage::Token(token)));1011 })1012 .expect("failed to spawn helper thread");10131014 let mut work_items = vec![];10151016 // We have LTO work to do. Perform the serial work here of1017 // figuring out what we're going to LTO and then push a1018 // bunch of work items onto our queue to do LTO. This all1019 // happens on the coordinator thread but it's very quick so1020 // we don't worry about tokens.1021 for (work, cost) in generate_thin_lto_work::<B>(1022 cgcx,1023 prof,1024 dcx,1025 &exported_symbols_for_lto,1026 &each_linked_rlib_for_lto,1027 needs_thin_lto,1028 ) {1029 let insertion_index =1030 work_items.binary_search_by_key(&cost, |&(_, cost)| cost).unwrap_or_else(|e| e);1031 work_items.insert(insertion_index, (work, cost));1032 if cgcx.parallel {1033 helper.request_token();1034 }1035 }10361037 let mut codegen_aborted = None;10381039 // These are the Jobserver Tokens we currently hold. Does not include1040 // the implicit Token the compiler process owns no matter what.1041 let mut tokens = vec![];10421043 // Amount of tokens that are used (including the implicit token).1044 let mut used_token_count = 0;10451046 let mut compiled_modules = vec![];10471048 // Run the message loop while there's still anything that needs message1049 // processing. Note that as soon as codegen is aborted we simply want to1050 // wait for all existing work to finish, so many of the conditions here1051 // only apply if codegen hasn't been aborted as they represent pending1052 // work to be done.1053 loop {1054 if codegen_aborted.is_none() {1055 if used_token_count == 0 && work_items.is_empty() {1056 // All codegen work is done.1057 break;1058 }10591060 // Spin up what work we can, only doing this while we've got available1061 // parallelism slots and work left to spawn.1062 while used_token_count < tokens.len() + 11063 && let Some((item, _)) = work_items.pop()1064 {1065 spawn_thin_lto_work(1066 &cgcx,1067 prof,1068 shared_emitter.clone(),1069 Arc::clone(&tm_factory),1070 coordinator_send.clone(),1071 item,1072 );1073 used_token_count += 1;1074 }1075 } else {1076 // Don't queue up any more work if codegen was aborted, we're1077 // just waiting for our existing children to finish.1078 if used_token_count == 0 {1079 break;1080 }1081 }10821083 // Relinquish accidentally acquired extra tokens. Subtract 1 for the implicit token.1084 tokens.truncate(used_token_count.saturating_sub(1));10851086 match coordinator_receive.recv().unwrap() {1087 // Save the token locally and the next turn of the loop will use1088 // this to spawn a new unit of work, or it may get dropped1089 // immediately if we have no more work to spawn.1090 ThinLtoMessage::Token(token) => match token {1091 Ok(token) => {1092 tokens.push(token);1093 }1094 Err(e) => {1095 let msg = &format!("failed to acquire jobserver token: {e}");1096 shared_emitter.fatal(msg);1097 codegen_aborted = Some(FatalError);1098 }1099 },11001101 ThinLtoMessage::WorkItem { result } => {1102 // If a thread exits successfully then we drop a token associated1103 // with that worker and update our `used_token_count` count.1104 // We may later re-acquire a token to continue running more work.1105 // We may also not actually drop a token here if the worker was1106 // running with an "ephemeral token".1107 used_token_count -= 1;11081109 match result {1110 Ok(compiled_module) => compiled_modules.push(compiled_module),1111 Err(Some(WorkerFatalError)) => {1112 // Like `CodegenAborted`, wait for remaining work to finish.1113 codegen_aborted = Some(FatalError);1114 }1115 Err(None) => {1116 // If the thread failed that means it panicked, so1117 // we abort immediately.1118 bug!("worker thread panicked");1119 }1120 }1121 }1122 }1123 }11241125 if let Some(codegen_aborted) = codegen_aborted {1126 codegen_aborted.raise();1127 }11281129 compiled_modules1130}11311132/// Messages sent to the coordinator.1133pub(crate) enum Message<B: WriteBackendMethods> {1134 /// A jobserver token has become available. Sent from the jobserver helper1135 /// thread.1136 Token(io::Result<Acquired>),11371138 /// The backend has finished processing a work item for a codegen unit.1139 /// Sent from a backend worker thread.1140 WorkItem { result: Result<WorkItemResult<B>, Option<WorkerFatalError>> },11411142 /// The frontend has finished generating something (backend IR or a1143 /// post-LTO artifact) for a codegen unit, and it should be passed to the1144 /// backend. Sent from the main thread.1145 CodegenDone { llvm_work_item: WorkItem<B>, cost: u64 },11461147 /// Similar to `CodegenDone`, but for reusing a pre-LTO artifact1148 /// Sent from the main thread.1149 AddImportOnlyModule { bitcode_path: PathBuf, work_product: WorkProduct },11501151 /// The frontend has finished generating everything for all codegen units.1152 /// Sent from the main thread.1153 CodegenComplete,11541155 /// Some normal-ish compiler error occurred, and codegen should be wound1156 /// down. Sent from the main thread.1157 CodegenAborted,1158}11591160/// Messages sent to the coordinator.1161pub(crate) enum ThinLtoMessage {1162 /// A jobserver token has become available. Sent from the jobserver helper1163 /// thread.1164 Token(io::Result<Acquired>),11651166 /// The backend has finished processing a work item for a codegen unit.1167 /// Sent from a backend worker thread.1168 WorkItem { result: Result<CompiledModule, Option<WorkerFatalError>> },1169}11701171/// A message sent from the coordinator thread to the main thread telling it to1172/// process another codegen unit.1173pub struct CguMessage;11741175// A cut-down version of `rustc_errors::DiagInner` that impls `Send`, which1176// can be used to send diagnostics from codegen threads to the main thread.1177// It's missing the following fields from `rustc_errors::DiagInner`.1178// - `span`: it doesn't impl `Send`.1179// - `suggestions`: it doesn't impl `Send`, and isn't used for codegen1180// diagnostics.1181// - `sort_span`: it doesn't impl `Send`.1182// - `is_lint`: lints aren't relevant during codegen.1183// - `emitted_at`: not used for codegen diagnostics.1184struct Diagnostic {1185 span: Vec<SpanData>,1186 level: Level,1187 messages: Vec<(DiagMessage, Style)>,1188 code: Option<ErrCode>,1189 children: Vec<Subdiagnostic>,1190 args: DiagArgMap,1191}11921193// A cut-down version of `rustc_errors::Subdiag` that impls `Send`. It's1194// missing the following fields from `rustc_errors::Subdiag`.1195// - `span`: it doesn't impl `Send`.1196struct Subdiagnostic {1197 level: Level,1198 messages: Vec<(DiagMessage, Style)>,1199}12001201#[derive(PartialEq, Clone, Copy, Debug)]1202enum MainThreadState {1203 /// Doing nothing.1204 Idle,12051206 /// Doing codegen, i.e. MIR-to-LLVM-IR conversion.1207 Codegenning,12081209 /// Idle, but lending the compiler process's Token to an LLVM thread so it can do useful work.1210 Lending,1211}12121213fn start_executing_work<B: WriteBackendMethods>(1214 backend: B,1215 tcx: TyCtxt<'_>,1216 shared_emitter: SharedEmitter,1217 codegen_worker_send: Sender<CguMessage>,1218 coordinator_receive: Receiver<Message<B>>,1219 regular_config: Arc<ModuleConfig>,1220 allocator_config: Arc<ModuleConfig>,1221 mut allocator_module: Option<ModuleCodegen<B::Module>>,1222 coordinator_send: Sender<Message<B>>,1223) -> thread::JoinHandle<Result<MaybeLtoModules<B>, ()>> {1224 let sess = tcx.sess;1225 let prof = sess.prof.clone();12261227 // Compute the set of symbols we need to retain when doing thin local LTO (if we need to)1228 let exported_symbols_for_lto =1229 if sess.lto() == Lto::ThinLocal { lto::exported_symbols_for_lto(tcx, &[]) } else { vec![] };12301231 // First up, convert our jobserver into a helper thread so we can use normal1232 // mpsc channels to manage our messages and such.1233 // After we've requested tokens then we'll, when we can,1234 // get tokens on `coordinator_receive` which will1235 // get managed in the main loop below.1236 let coordinator_send2 = coordinator_send.clone();1237 let helper = jobserver::client()1238 .into_helper_thread(move |token| {1239 drop(coordinator_send2.send(Message::Token::<B>(token)));1240 })1241 .expect("failed to spawn helper thread");12421243 let opt_level = tcx.backend_optimization_level(());1244 let backend_features = tcx.global_backend_features(()).clone();1245 let tm_factory = backend.target_machine_factory(tcx.sess, opt_level, &backend_features);12461247 let remark_dir = if let Some(ref dir) = sess.opts.unstable_opts.remark_dir {1248 let result = fs::create_dir_all(dir).and_then(|_| dir.canonicalize());1249 match result {1250 Ok(dir) => Some(dir),1251 Err(error) => sess.dcx().emit_fatal(ErrorCreatingRemarkDir { error }),1252 }1253 } else {1254 None1255 };12561257 let cgcx = CodegenContext {1258 crate_types: tcx.crate_types().to_vec(),1259 lto: sess.lto(),1260 use_linker_plugin_lto: sess.opts.cg.linker_plugin_lto.enabled(),1261 dylib_lto: sess.opts.unstable_opts.dylib_lto,1262 prefer_dynamic: sess.opts.cg.prefer_dynamic,1263 fewer_names: sess.fewer_names(),1264 save_temps: sess.opts.cg.save_temps,1265 time_trace: sess.opts.unstable_opts.llvm_time_trace,1266 remark: sess.opts.cg.remark.clone(),1267 remark_dir,1268 incr_comp_session_dir: sess.incr_comp_session_dir_opt().map(|r| r.clone()),1269 output_filenames: Arc::clone(tcx.output_filenames(())),1270 module_config: regular_config,1271 opt_level,1272 backend_features,1273 msvc_imps_needed: msvc_imps_needed(tcx),1274 is_pe_coff: tcx.sess.target.is_like_windows,1275 target_can_use_split_dwarf: tcx.sess.target_can_use_split_dwarf(),1276 target_arch: tcx.sess.target.arch.to_string(),1277 target_is_like_darwin: tcx.sess.target.is_like_darwin,1278 target_is_like_aix: tcx.sess.target.is_like_aix,1279 target_is_like_gpu: tcx.sess.target.is_like_gpu,1280 split_debuginfo: tcx.sess.split_debuginfo(),1281 split_dwarf_kind: tcx.sess.opts.unstable_opts.split_dwarf_kind,1282 parallel: backend.supports_parallel() && !sess.opts.unstable_opts.no_parallel_backend,1283 pointer_size: tcx.data_layout.pointer_size(),1284 };12851286 // This is the "main loop" of parallel work happening for parallel codegen.1287 // It's here that we manage parallelism, schedule work, and work with1288 // messages coming from clients.1289 //1290 // There are a few environmental pre-conditions that shape how the system1291 // is set up:1292 //1293 // - Error reporting can only happen on the main thread because that's the1294 // only place where we have access to the compiler `Session`.1295 // - LLVM work can be done on any thread.1296 // - Codegen can only happen on the main thread.1297 // - Each thread doing substantial work must be in possession of a `Token`1298 // from the `Jobserver`.1299 // - The compiler process always holds one `Token`. Any additional `Tokens`1300 // have to be requested from the `Jobserver`.1301 //1302 // Error Reporting1303 // ===============1304 // The error reporting restriction is handled separately from the rest: We1305 // set up a `SharedEmitter` that holds an open channel to the main thread.1306 // When an error occurs on any thread, the shared emitter will send the1307 // error message to the receiver main thread (`SharedEmitterMain`). The1308 // main thread will periodically query this error message queue and emit1309 // any error messages it has received. It might even abort compilation if1310 // it has received a fatal error. In this case we rely on all other threads1311 // being torn down automatically with the main thread.1312 // Since the main thread will often be busy doing codegen work, error1313 // reporting will be somewhat delayed, since the message queue can only be1314 // checked in between two work packages.1315 //1316 // Work Processing Infrastructure1317 // ==============================1318 // The work processing infrastructure knows three major actors:1319 //1320 // - the coordinator thread,1321 // - the main thread, and1322 // - LLVM worker threads1323 //1324 // The coordinator thread is running a message loop. It instructs the main1325 // thread about what work to do when, and it will spawn off LLVM worker1326 // threads as open LLVM WorkItems become available.1327 //1328 // The job of the main thread is to codegen CGUs into LLVM work packages1329 // (since the main thread is the only thread that can do this). The main1330 // thread will block until it receives a message from the coordinator, upon1331 // which it will codegen one CGU, send it to the coordinator and block1332 // again. This way the coordinator can control what the main thread is1333 // doing.1334 //1335 // The coordinator keeps a queue of LLVM WorkItems, and when a `Token` is1336 // available, it will spawn off a new LLVM worker thread and let it process1337 // a WorkItem. When a LLVM worker thread is done with its WorkItem,1338 // it will just shut down, which also frees all resources associated with1339 // the given LLVM module, and sends a message to the coordinator that the1340 // WorkItem has been completed.1341 //1342 // Work Scheduling1343 // ===============1344 // The scheduler's goal is to minimize the time it takes to complete all1345 // work there is, however, we also want to keep memory consumption low1346 // if possible. These two goals are at odds with each other: If memory1347 // consumption were not an issue, we could just let the main thread produce1348 // LLVM WorkItems at full speed, assuring maximal utilization of1349 // Tokens/LLVM worker threads. However, since codegen is usually faster1350 // than LLVM processing, the queue of LLVM WorkItems would fill up and each1351 // WorkItem potentially holds on to a substantial amount of memory.1352 //1353 // So the actual goal is to always produce just enough LLVM WorkItems as1354 // not to starve our LLVM worker threads. That means, once we have enough1355 // WorkItems in our queue, we can block the main thread, so it does not1356 // produce more until we need them.1357 //1358 // Doing LLVM Work on the Main Thread1359 // ----------------------------------1360 // Since the main thread owns the compiler process's implicit `Token`, it is1361 // wasteful to keep it blocked without doing any work. Therefore, what we do1362 // in this case is: We spawn off an additional LLVM worker thread that helps1363 // reduce the queue. The work it is doing corresponds to the implicit1364 // `Token`. The coordinator will mark the main thread as being busy with1365 // LLVM work. (The actual work happens on another OS thread but we just care1366 // about `Tokens`, not actual threads).1367 //1368 // When any LLVM worker thread finishes while the main thread is marked as1369 // "busy with LLVM work", we can do a little switcheroo: We give the Token1370 // of the just finished thread to the LLVM worker thread that is working on1371 // behalf of the main thread's implicit Token, thus freeing up the main1372 // thread again. The coordinator can then again decide what the main thread1373 // should do. This allows the coordinator to make decisions at more points1374 // in time.1375 //1376 // Striking a Balance between Throughput and Memory Consumption1377 // ------------------------------------------------------------1378 // Since our two goals, (1) use as many Tokens as possible and (2) keep1379 // memory consumption as low as possible, are in conflict with each other,1380 // we have to find a trade off between them. Right now, the goal is to keep1381 // all workers busy, which means that no worker should find the queue empty1382 // when it is ready to start.1383 // How do we do achieve this? Good question :) We actually never know how1384 // many `Tokens` are potentially available so it's hard to say how much to1385 // fill up the queue before switching the main thread to LLVM work. Also we1386 // currently don't have a means to estimate how long a running LLVM worker1387 // will still be busy with it's current WorkItem. However, we know the1388 // maximal count of available Tokens that makes sense (=the number of CPU1389 // cores), so we can take a conservative guess. The heuristic we use here1390 // is implemented in the `queue_full_enough()` function.1391 //1392 // Some Background on Jobservers1393 // -----------------------------1394 // It's worth also touching on the management of parallelism here. We don't1395 // want to just spawn a thread per work item because while that's optimal1396 // parallelism it may overload a system with too many threads or violate our1397 // configuration for the maximum amount of cpu to use for this process. To1398 // manage this we use the `jobserver` crate.1399 //1400 // Job servers are an artifact of GNU make and are used to manage1401 // parallelism between processes. A jobserver is a glorified IPC semaphore1402 // basically. Whenever we want to run some work we acquire the semaphore,1403 // and whenever we're done with that work we release the semaphore. In this1404 // manner we can ensure that the maximum number of parallel workers is1405 // capped at any one point in time.1406 //1407 // LTO and the coordinator thread1408 // ------------------------------1409 //1410 // The final job the coordinator thread is responsible for is managing LTO1411 // and how that works. When LTO is requested what we'll do is collect all1412 // optimized LLVM modules into a local vector on the coordinator. Once all1413 // modules have been codegened and optimized we hand this to the `lto`1414 // module for further optimization. The `lto` module will return back a list1415 // of more modules to work on, which the coordinator will continue to spawn1416 // work for.1417 //1418 // Each LLVM module is automatically sent back to the coordinator for LTO if1419 // necessary. There's already optimizations in place to avoid sending work1420 // back to the coordinator if LTO isn't requested.1421 let f = move || {1422 let _profiler = if cgcx.time_trace { B::thread_profiler() } else { Box::new(()) };14231424 // This is where we collect codegen units that have gone all the way1425 // through codegen and LLVM.1426 let mut compiled_modules = vec![];1427 let mut needs_fat_lto = Vec::new();1428 let mut needs_thin_lto = Vec::new();1429 let mut lto_import_only_modules = Vec::new();14301431 /// Possible state transitions:1432 /// - Ongoing -> Completed1433 /// - Ongoing -> Aborted1434 /// - Completed -> Aborted1435 #[derive(Debug, PartialEq)]1436 enum CodegenState {1437 Ongoing,1438 Completed,1439 Aborted,1440 }1441 use CodegenState::*;1442 let mut codegen_state = Ongoing;14431444 // This is the queue of LLVM work items that still need processing.1445 let mut work_items = Vec::<(WorkItem<B>, u64)>::new();14461447 // This are the Jobserver Tokens we currently hold. Does not include1448 // the implicit Token the compiler process owns no matter what.1449 let mut tokens = Vec::new();14501451 let mut main_thread_state = MainThreadState::Idle;14521453 // How many LLVM worker threads are running while holding a Token. This1454 // *excludes* any that the main thread is lending a Token to.1455 let mut running_with_own_token = 0;14561457 // How many LLVM worker threads are running in total. This *includes*1458 // any that the main thread is lending a Token to.1459 let running_with_any_token = |main_thread_state, running_with_own_token| {1460 running_with_own_token1461 + if main_thread_state == MainThreadState::Lending { 1 } else { 0 }1462 };14631464 let mut llvm_start_time: Option<VerboseTimingGuard<'_>> = None;14651466 if let Some(allocator_module) = &mut allocator_module {1467 B::optimize(&cgcx, &prof, &shared_emitter, allocator_module, &allocator_config);1468 }14691470 // Run the message loop while there's still anything that needs message1471 // processing. Note that as soon as codegen is aborted we simply want to1472 // wait for all existing work to finish, so many of the conditions here1473 // only apply if codegen hasn't been aborted as they represent pending1474 // work to be done.1475 loop {1476 // While there are still CGUs to be codegened, the coordinator has1477 // to decide how to utilize the compiler processes implicit Token:1478 // For codegenning more CGU or for running them through LLVM.1479 if codegen_state == Ongoing {1480 if main_thread_state == MainThreadState::Idle {1481 // Compute the number of workers that will be running once we've taken as many1482 // items from the work queue as we can, plus one for the main thread. It's not1483 // critically important that we use this instead of just1484 // `running_with_own_token`, but it prevents the `queue_full_enough` heuristic1485 // from fluctuating just because a worker finished up and we decreased the1486 // `running_with_own_token` count, even though we're just going to increase it1487 // right after this when we put a new worker to work.1488 let extra_tokens = tokens.len().checked_sub(running_with_own_token).unwrap();1489 let additional_running = std::cmp::min(extra_tokens, work_items.len());1490 let anticipated_running = running_with_own_token + additional_running + 1;14911492 if !queue_full_enough(work_items.len(), anticipated_running) {1493 // The queue is not full enough, process more codegen units:1494 if codegen_worker_send.send(CguMessage).is_err() {1495 panic!("Could not send CguMessage to main thread")1496 }1497 main_thread_state = MainThreadState::Codegenning;1498 } else {1499 // The queue is full enough to not let the worker1500 // threads starve. Use the implicit Token to do some1501 // LLVM work too.1502 let (item, _) =1503 work_items.pop().expect("queue empty - queue_full_enough() broken?");1504 main_thread_state = MainThreadState::Lending;1505 spawn_work(1506 &cgcx,1507 &prof,1508 shared_emitter.clone(),1509 coordinator_send.clone(),1510 &mut llvm_start_time,1511 item,1512 );1513 }1514 }1515 } else if codegen_state == Completed {1516 if running_with_any_token(main_thread_state, running_with_own_token) == 01517 && work_items.is_empty()1518 {1519 // All codegen work is done.1520 break;1521 }15221523 // In this branch, we know that everything has been codegened,1524 // so it's just a matter of determining whether the implicit1525 // Token is free to use for LLVM work.1526 match main_thread_state {1527 MainThreadState::Idle => {1528 if let Some((item, _)) = work_items.pop() {1529 main_thread_state = MainThreadState::Lending;1530 spawn_work(1531 &cgcx,1532 &prof,1533 shared_emitter.clone(),1534 coordinator_send.clone(),1535 &mut llvm_start_time,1536 item,1537 );1538 } else {1539 // There is no unstarted work, so let the main thread1540 // take over for a running worker. Otherwise the1541 // implicit token would just go to waste.1542 // We reduce the `running` counter by one. The1543 // `tokens.truncate()` below will take care of1544 // giving the Token back.1545 assert!(running_with_own_token > 0);1546 running_with_own_token -= 1;1547 main_thread_state = MainThreadState::Lending;1548 }1549 }1550 MainThreadState::Codegenning => bug!(1551 "codegen worker should not be codegenning after \1552 codegen was already completed"1553 ),1554 MainThreadState::Lending => {1555 // Already making good use of that token1556 }1557 }1558 } else {1559 // Don't queue up any more work if codegen was aborted, we're1560 // just waiting for our existing children to finish.1561 assert!(codegen_state == Aborted);1562 if running_with_any_token(main_thread_state, running_with_own_token) == 0 {1563 break;1564 }1565 }15661567 // Spin up what work we can, only doing this while we've got available1568 // parallelism slots and work left to spawn.1569 if codegen_state != Aborted {1570 while running_with_own_token < tokens.len()1571 && let Some((item, _)) = work_items.pop()1572 {1573 spawn_work(1574 &cgcx,1575 &prof,1576 shared_emitter.clone(),1577 coordinator_send.clone(),1578 &mut llvm_start_time,1579 item,1580 );1581 running_with_own_token += 1;1582 }1583 }15841585 // Relinquish accidentally acquired extra tokens.1586 tokens.truncate(running_with_own_token);15871588 match coordinator_receive.recv().unwrap() {1589 // Save the token locally and the next turn of the loop will use1590 // this to spawn a new unit of work, or it may get dropped1591 // immediately if we have no more work to spawn.1592 Message::Token(token) => {1593 match token {1594 Ok(token) => {1595 tokens.push(token);15961597 if main_thread_state == MainThreadState::Lending {1598 // If the main thread token is used for LLVM work1599 // at the moment, we turn that thread into a regular1600 // LLVM worker thread, so the main thread is free1601 // to react to codegen demand.1602 main_thread_state = MainThreadState::Idle;1603 running_with_own_token += 1;1604 }1605 }1606 Err(e) => {1607 let msg = &format!("failed to acquire jobserver token: {e}");1608 shared_emitter.fatal(msg);1609 codegen_state = Aborted;1610 }1611 }1612 }16131614 Message::CodegenDone { llvm_work_item, cost } => {1615 // We keep the queue sorted by estimated processing cost,1616 // so that more expensive items are processed earlier. This1617 // is good for throughput as it gives the main thread more1618 // time to fill up the queue and it avoids scheduling1619 // expensive items to the end.1620 // Note, however, that this is not ideal for memory1621 // consumption, as LLVM module sizes are not evenly1622 // distributed.1623 let insertion_index = work_items.binary_search_by_key(&cost, |&(_, cost)| cost);1624 let insertion_index = match insertion_index {1625 Ok(idx) | Err(idx) => idx,1626 };1627 work_items.insert(insertion_index, (llvm_work_item, cost));16281629 if cgcx.parallel {1630 helper.request_token();1631 }1632 assert_eq!(main_thread_state, MainThreadState::Codegenning);1633 main_thread_state = MainThreadState::Idle;1634 }16351636 Message::CodegenComplete => {1637 if codegen_state != Aborted {1638 codegen_state = Completed;1639 }1640 assert_eq!(main_thread_state, MainThreadState::Codegenning);1641 main_thread_state = MainThreadState::Idle;1642 }16431644 // If codegen is aborted that means translation was aborted due1645 // to some normal-ish compiler error. In this situation we want1646 // to exit as soon as possible, but we want to make sure all1647 // existing work has finished. Flag codegen as being done, and1648 // then conditions above will ensure no more work is spawned but1649 // we'll keep executing this loop until `running_with_own_token`1650 // hits 0.1651 Message::CodegenAborted => {1652 codegen_state = Aborted;1653 }16541655 Message::WorkItem { result } => {1656 // If a thread exits successfully then we drop a token associated1657 // with that worker and update our `running_with_own_token` count.1658 // We may later re-acquire a token to continue running more work.1659 // We may also not actually drop a token here if the worker was1660 // running with an "ephemeral token".1661 if main_thread_state == MainThreadState::Lending {1662 main_thread_state = MainThreadState::Idle;1663 } else {1664 running_with_own_token -= 1;1665 }16661667 match result {1668 Ok(WorkItemResult::Finished(compiled_module)) => {1669 compiled_modules.push(compiled_module);1670 }1671 Ok(WorkItemResult::NeedsFatLto(fat_lto_input)) => {1672 assert!(needs_thin_lto.is_empty());1673 needs_fat_lto.push(fat_lto_input);1674 }1675 Ok(WorkItemResult::NeedsThinLto(name, thin_buffer)) => {1676 assert!(needs_fat_lto.is_empty());1677 needs_thin_lto.push(ThinLtoInput::Red {1678 name,1679 buffer: SerializedModule::Local(thin_buffer),1680 });1681 }1682 Err(Some(WorkerFatalError)) => {1683 // Like `CodegenAborted`, wait for remaining work to finish.1684 codegen_state = Aborted;1685 }1686 Err(None) => {1687 // If the thread failed that means it panicked, so1688 // we abort immediately.1689 bug!("worker thread panicked");1690 }1691 }1692 }16931694 Message::AddImportOnlyModule { bitcode_path, work_product } => {1695 assert_eq!(codegen_state, Ongoing);1696 assert_eq!(main_thread_state, MainThreadState::Codegenning);1697 lto_import_only_modules.push((bitcode_path, work_product));1698 main_thread_state = MainThreadState::Idle;1699 }1700 }1701 }17021703 // Drop to print timings1704 drop(llvm_start_time);17051706 if codegen_state == Aborted {1707 return Err(());1708 }17091710 drop(codegen_state);1711 drop(tokens);1712 drop(helper);1713 assert!(work_items.is_empty());17141715 if !needs_fat_lto.is_empty() {1716 assert!(compiled_modules.is_empty());1717 assert!(needs_thin_lto.is_empty());17181719 if let Some(allocator_module) = allocator_module.take() {1720 needs_fat_lto.push(FatLtoInput::InMemory(allocator_module));1721 }17221723 for (bitcode_path, wp) in lto_import_only_modules {1724 needs_fat_lto.push(FatLtoInput::Serialized { name: wp.cgu_name, bitcode_path })1725 }17261727 return Ok(MaybeLtoModules::FatLto { cgcx, needs_fat_lto });1728 } else if !needs_thin_lto.is_empty() || !lto_import_only_modules.is_empty() {1729 assert!(compiled_modules.is_empty());1730 assert!(needs_fat_lto.is_empty());17311732 for (bitcode_path, wp) in lto_import_only_modules {1733 needs_thin_lto.push(ThinLtoInput::Green { wp, bitcode_path })1734 }17351736 if cgcx.lto == Lto::ThinLocal {1737 compiled_modules.extend(do_thin_lto::<B>(1738 &cgcx,1739 &prof,1740 shared_emitter.clone(),1741 tm_factory,1742 &exported_symbols_for_lto,1743 &[],1744 needs_thin_lto,1745 ));1746 } else {1747 if let Some(allocator_module) = allocator_module.take() {1748 let thin_buffer = B::serialize_module(allocator_module.module_llvm, true);1749 needs_thin_lto.push(ThinLtoInput::Red {1750 name: allocator_module.name,1751 buffer: SerializedModule::Local(thin_buffer),1752 });1753 }17541755 return Ok(MaybeLtoModules::ThinLto { cgcx, needs_thin_lto });1756 }1757 }17581759 Ok(MaybeLtoModules::NoLto(CompiledModules {1760 modules: compiled_modules,1761 allocator_module: allocator_module.map(|allocator_module| {1762 B::codegen(&cgcx, &prof, &shared_emitter, allocator_module, &allocator_config)1763 }),1764 }))1765 };1766 return std::thread::Builder::new()1767 .name("coordinator".to_owned())1768 .spawn(f)1769 .expect("failed to spawn coordinator thread");17701771 // A heuristic that determines if we have enough LLVM WorkItems in the1772 // queue so that the main thread can do LLVM work instead of codegen1773 fn queue_full_enough(items_in_queue: usize, workers_running: usize) -> bool {1774 // This heuristic scales ahead-of-time codegen according to available1775 // concurrency, as measured by `workers_running`. The idea is that the1776 // more concurrency we have available, the more demand there will be for1777 // work items, and the fuller the queue should be kept to meet demand.1778 // An important property of this approach is that we codegen ahead of1779 // time only as much as necessary, so as to keep fewer LLVM modules in1780 // memory at once, thereby reducing memory consumption.1781 //1782 // When the number of workers running is less than the max concurrency1783 // available to us, this heuristic can cause us to instruct the main1784 // thread to work on an LLVM item (that is, tell it to "LLVM") instead1785 // of codegen, even though it seems like it *should* be codegenning so1786 // that we can create more work items and spawn more LLVM workers.1787 //1788 // But this is not a problem. When the main thread is told to LLVM,1789 // according to this heuristic and how work is scheduled, there is1790 // always at least one item in the queue, and therefore at least one1791 // pending jobserver token request. If there *is* more concurrency1792 // available, we will immediately receive a token, which will upgrade1793 // the main thread's LLVM worker to a real one (conceptually), and free1794 // up the main thread to codegen if necessary. On the other hand, if1795 // there isn't more concurrency, then the main thread working on an LLVM1796 // item is appropriate, as long as the queue is full enough for demand.1797 //1798 // Speaking of which, how full should we keep the queue? Probably less1799 // full than you'd think. A lot has to go wrong for the queue not to be1800 // full enough and for that to have a negative effect on compile times.1801 //1802 // Workers are unlikely to finish at exactly the same time, so when one1803 // finishes and takes another work item off the queue, we often have1804 // ample time to codegen at that point before the next worker finishes.1805 // But suppose that codegen takes so long that the workers exhaust the1806 // queue, and we have one or more workers that have nothing to work on.1807 // Well, it might not be so bad. Of all the LLVM modules we create and1808 // optimize, one has to finish last. It's not necessarily the case that1809 // by losing some concurrency for a moment, we delay the point at which1810 // that last LLVM module is finished and the rest of compilation can1811 // proceed. Also, when we can't take advantage of some concurrency, we1812 // give tokens back to the job server. That enables some other rustc to1813 // potentially make use of the available concurrency. That could even1814 // *decrease* overall compile time if we're lucky. But yes, if no other1815 // rustc can make use of the concurrency, then we've squandered it.1816 //1817 // However, keeping the queue full is also beneficial when we have a1818 // surge in available concurrency. Then items can be taken from the1819 // queue immediately, without having to wait for codegen.1820 //1821 // So, the heuristic below tries to keep one item in the queue for every1822 // four running workers. Based on limited benchmarking, this appears to1823 // be more than sufficient to avoid increasing compilation times.1824 let quarter_of_workers = workers_running - 3 * workers_running / 4;1825 items_in_queue > 0 && items_in_queue >= quarter_of_workers1826 }1827}18281829/// `FatalError` is explicitly not `Send`.1830#[must_use]1831pub(crate) struct WorkerFatalError;18321833fn spawn_work<'a, B: WriteBackendMethods>(1834 cgcx: &CodegenContext,1835 prof: &'a SelfProfilerRef,1836 shared_emitter: SharedEmitter,1837 coordinator_send: Sender<Message<B>>,1838 llvm_start_time: &mut Option<VerboseTimingGuard<'a>>,1839 work: WorkItem<B>,1840) {1841 if llvm_start_time.is_none() {1842 *llvm_start_time = Some(prof.verbose_generic_activity("LLVM_passes"));1843 }18441845 let cgcx = cgcx.clone();1846 let prof = prof.clone();18471848 let name = work.short_description();1849 let f = move || {1850 let _profiler = if cgcx.time_trace { B::thread_profiler() } else { Box::new(()) };18511852 let result = std::panic::catch_unwind(AssertUnwindSafe(|| match work {1853 WorkItem::Optimize(m) => execute_optimize_work_item(&cgcx, &prof, shared_emitter, m),1854 WorkItem::CopyPostLtoArtifacts(m) => WorkItemResult::Finished(1855 execute_copy_from_cache_work_item(&cgcx, &prof, shared_emitter, m),1856 ),1857 }));18581859 let msg = match result {1860 Ok(result) => Message::WorkItem::<B> { result: Ok(result) },18611862 // We ignore any `FatalError` coming out of `execute_work_item`, as a1863 // diagnostic was already sent off to the main thread - just surface1864 // that there was an error in this worker.1865 Err(err) if err.is::<FatalErrorMarker>() => {1866 Message::WorkItem::<B> { result: Err(Some(WorkerFatalError)) }1867 }18681869 Err(_) => Message::WorkItem::<B> { result: Err(None) },1870 };1871 drop(coordinator_send.send(msg));1872 };1873 std::thread::Builder::new().name(name).spawn(f).expect("failed to spawn work thread");1874}18751876fn spawn_thin_lto_work<B: WriteBackendMethods>(1877 cgcx: &CodegenContext,1878 prof: &SelfProfilerRef,1879 shared_emitter: SharedEmitter,1880 tm_factory: TargetMachineFactoryFn<B>,1881 coordinator_send: Sender<ThinLtoMessage>,1882 work: ThinLtoWorkItem<B>,1883) {1884 let cgcx = cgcx.clone();1885 let prof = prof.clone();18861887 let name = work.short_description();1888 let f = move || {1889 let _profiler = if cgcx.time_trace { B::thread_profiler() } else { Box::new(()) };18901891 let result = std::panic::catch_unwind(AssertUnwindSafe(|| match work {1892 ThinLtoWorkItem::CopyPostLtoArtifacts(m) => {1893 execute_copy_from_cache_work_item(&cgcx, &prof, shared_emitter, m)1894 }1895 ThinLtoWorkItem::ThinLto(m) => {1896 let _timer = prof.generic_activity_with_arg("codegen_module_perform_lto", m.name());1897 B::optimize_and_codegen_thin(&cgcx, &prof, &shared_emitter, tm_factory, m)1898 }1899 }));19001901 let msg = match result {1902 Ok(result) => ThinLtoMessage::WorkItem { result: Ok(result) },19031904 // We ignore any `FatalError` coming out of `execute_work_item`, as a1905 // diagnostic was already sent off to the main thread - just surface1906 // that there was an error in this worker.1907 Err(err) if err.is::<FatalErrorMarker>() => {1908 ThinLtoMessage::WorkItem { result: Err(Some(WorkerFatalError)) }1909 }19101911 Err(_) => ThinLtoMessage::WorkItem { result: Err(None) },1912 };1913 drop(coordinator_send.send(msg));1914 };1915 std::thread::Builder::new().name(name).spawn(f).expect("failed to spawn work thread");1916}19171918enum SharedEmitterMessage {1919 Diagnostic(Diagnostic),1920 InlineAsmError(InlineAsmError),1921 Fatal(String),1922}19231924pub struct InlineAsmError {1925 pub span: SpanData,1926 pub msg: String,1927 pub level: Level,1928 pub source: Option<(String, Vec<InnerSpan>)>,1929}19301931#[derive(Clone)]1932pub struct SharedEmitter {1933 sender: Sender<SharedEmitterMessage>,1934}19351936pub struct SharedEmitterMain {1937 receiver: Receiver<SharedEmitterMessage>,1938}19391940impl SharedEmitter {1941 fn new() -> (SharedEmitter, SharedEmitterMain) {1942 let (sender, receiver) = channel();19431944 (SharedEmitter { sender }, SharedEmitterMain { receiver })1945 }19461947 pub fn inline_asm_error(&self, err: InlineAsmError) {1948 drop(self.sender.send(SharedEmitterMessage::InlineAsmError(err)));1949 }19501951 fn fatal(&self, msg: &str) {1952 drop(self.sender.send(SharedEmitterMessage::Fatal(msg.to_string())));1953 }1954}19551956impl Emitter for SharedEmitter {1957 fn emit_diagnostic(&mut self, mut diag: rustc_errors::DiagInner) {1958 // Check that we aren't missing anything interesting when converting to1959 // the cut-down local `DiagInner`.1960 assert!(!diag.span.has_span_labels());1961 assert_eq!(diag.suggestions, Suggestions::Enabled(vec![]));1962 assert_eq!(diag.sort_span, rustc_span::DUMMY_SP);1963 assert_eq!(diag.is_lint, None);1964 // No sensible check for `diag.emitted_at`.19651966 let args = mem::take(&mut diag.args);1967 drop(1968 self.sender.send(SharedEmitterMessage::Diagnostic(Diagnostic {1969 span: diag.span.primary_spans().iter().map(|span| span.data()).collect::<Vec<_>>(),1970 level: diag.level(),1971 messages: diag.messages,1972 code: diag.code,1973 children: diag1974 .children1975 .into_iter()1976 .map(|child| Subdiagnostic { level: child.level, messages: child.messages })1977 .collect(),1978 args,1979 })),1980 );1981 }19821983 fn source_map(&self) -> Option<&SourceMap> {1984 None1985 }1986}19871988impl SharedEmitterMain {1989 fn check(&self, sess: &Session, blocking: bool) {1990 loop {1991 let message = if blocking {1992 match self.receiver.recv() {1993 Ok(message) => Ok(message),1994 Err(_) => Err(()),1995 }1996 } else {1997 match self.receiver.try_recv() {1998 Ok(message) => Ok(message),1999 Err(_) => Err(()),2000 }
Same data, no extra tab — call code_get_file + code_get_findings over MCP from Claude/Cursor/Copilot.