second_half.iter().rev().interleave(first_half).copied().collect()
};
+ // Calculate the CGU reuse
+ let cgu_reuse = tcx.sess.time("find_cgu_reuse", || {
+ codegen_units.iter().map(|cgu| determine_cgu_reuse(tcx, &cgu)).collect::<Vec<_>>()
+ });
+
// The non-parallel compiler can only translate codegen units to LLVM IR
// on a single thread, leading to a staircase effect where the N LLVM
// threads have to wait on the single codegen threads to generate work
// non-parallel compiler anymore, we can compile CGUs end-to-end in
// parallel and get rid of the complicated scheduling logic.
#[cfg(parallel_compiler)]
- let pre_compile_cgus = |cgu_reuse: &[CguReuse]| {
+ let pre_compile_cgus = || {
tcx.sess.time("compile_first_CGU_batch", || {
// Try to find one CGU to compile per thread.
let cgus: Vec<_> = cgu_reuse
};
#[cfg(not(parallel_compiler))]
- let pre_compile_cgus = |_: &[CguReuse]| (FxHashMap::default(), Duration::new(0, 0));
+ let pre_compile_cgus = || (FxHashMap::default(), Duration::new(0, 0));
- let mut cgu_reuse = Vec::new();
let mut pre_compiled_cgus: Option<FxHashMap<usize, _>> = None;
let mut total_codegen_time = Duration::new(0, 0);
let start_rss = tcx.sess.time_passes().then(|| get_resident_set_size());
// Do some setup work in the first iteration
if pre_compiled_cgus.is_none() {
- // Calculate the CGU reuse
- cgu_reuse = tcx.sess.time("find_cgu_reuse", || {
- codegen_units.iter().map(|cgu| determine_cgu_reuse(tcx, &cgu)).collect()
- });
// Pre compile some CGUs
- let (compiled_cgus, codegen_time) = pre_compile_cgus(&cgu_reuse);
+ let (compiled_cgus, codegen_time) = pre_compile_cgus();
pre_compiled_cgus = Some(compiled_cgus);
total_codegen_time += codegen_time;
}
missing_lang_items: Default::default(),
dependency_formats: tcx.dependency_formats(()).clone(),
windows_subsystem,
+ debugger_visualizers: Default::default(),
};
+ let debugger_visualizers = tcx.debugger_visualizers(LOCAL_CRATE).clone();
+ if !debugger_visualizers.is_empty() {
+ info.debugger_visualizers.insert(LOCAL_CRATE, debugger_visualizers);
+ }
+
let lang_items = tcx.lang_items();
let crates = tcx.crates(());
info.native_libraries
.insert(cnum, tcx.native_libraries(cnum).iter().map(Into::into).collect());
info.crate_name.insert(cnum, tcx.crate_name(cnum));
- info.used_crate_source.insert(cnum, tcx.used_crate_source(cnum).clone());
+
+ let used_crate_source = tcx.used_crate_source(cnum);
+ info.used_crate_source.insert(cnum, used_crate_source.clone());
if tcx.is_compiler_builtins(cnum) {
info.compiler_builtins = Some(cnum);
}
let missing =
missing.iter().cloned().filter(|&l| lang_items::required(tcx, l)).collect();
info.missing_lang_items.insert(cnum, missing);
+
+ // Only include debugger visualizer files from crates that will be statically linked.
+ if used_crate_source.rlib.is_some() || used_crate_source.rmeta.is_some() {
+ let debugger_visualizers = tcx.debugger_visualizers(cnum).clone();
+ if !debugger_visualizers.is_empty() {
+ info.debugger_visualizers.insert(cnum, debugger_visualizers);
+ }
+ }
}
info