use rustc::middle::cstore::EncodedMetadata;
use rustc::middle::lang_items::StartFnLangItem;
use rustc::middle::weak_lang_items;
-use rustc::mir::mono::{Stats, CodegenUnitNameBuilder};
-use rustc::ty::{self, Ty, TyCtxt};
+use rustc::mir::mono::{CodegenUnitNameBuilder, CodegenUnit, MonoItem};
+use rustc::ty::{self, Ty, TyCtxt, Instance};
use rustc::ty::layout::{self, Align, TyLayout, LayoutOf, VariantIdx, HasTyCtxt};
use rustc::ty::query::Providers;
use rustc::middle::cstore::{self, LinkagePreference};
use rustc::util::common::{time, print_time_passes_entry};
use rustc::session::config::{self, EntryFnType, Lto};
use rustc::session::Session;
-use rustc_mir::monomorphize::item::DefPathBasedNames;
-use rustc_mir::monomorphize::Instance;
-use rustc_mir::monomorphize::partitioning::{CodegenUnit, CodegenUnitExt};
use rustc::util::nodemap::FxHashMap;
use rustc_data_structures::indexed_vec::Idx;
use rustc_codegen_utils::{symbol_names_test, check_for_rustc_errors_attr};
use crate::common::{RealPredicate, TypeKind, IntPredicate};
use crate::meth;
use crate::mir;
-use crate::mono_item::MonoItem;
use crate::traits::*;
use crate::mir::operand::OperandValue;
-use std::marker::PhantomData;
-
-pub struct StatRecorder<'a, 'tcx, Cx: 'a + CodegenMethods<'tcx>> {
- cx: &'a Cx,
- name: Option<String>,
- istart: usize,
- _marker: PhantomData<&'tcx ()>,
-}
-
-impl<'a, 'tcx, Cx: CodegenMethods<'tcx>> StatRecorder<'a, 'tcx, Cx> {
- pub fn new(cx: &'a Cx, name: String) -> Self {
- let istart = cx.stats().borrow().n_llvm_insns;
- StatRecorder {
- cx,
- name: Some(name),
- istart,
- _marker: PhantomData,
- }
- }
-}
-
-impl<'a, 'tcx, Cx: CodegenMethods<'tcx>> Drop for StatRecorder<'a, 'tcx, Cx> {
- fn drop(&mut self) {
- if self.cx.sess().codegen_stats() {
- let mut stats = self.cx.stats().borrow_mut();
- let iend = stats.n_llvm_insns;
- stats.fn_stats.push((self.name.take().unwrap(), iend - self.istart));
- stats.n_fns += 1;
- // Reset LLVM insn count to avoid compound costs.
- stats.n_llvm_insns = self.istart;
- }
- }
-}
-
pub fn bin_op_to_icmp_predicate(op: hir::BinOpKind,
signed: bool)
-> IntPredicate {
cx: &'a Bx::CodegenCx,
instance: Instance<'tcx>,
) {
- let _s = if cx.sess().codegen_stats() {
- let mut instance_name = String::new();
- DefPathBasedNames::new(cx.tcx(), true, true)
- .push_def_path(instance.def_id(), &mut instance_name);
- Some(StatRecorder::new(cx, instance_name))
- } else {
- None
- };
-
// this is an info! to allow collecting monomorphization statistics
// and to allow finding the last function before LLVM aborts from
// release builds.
let lldecl = cx.instances().borrow().get(&instance).cloned().unwrap_or_else(||
bug!("Instance `{:?}` not already declared", instance));
- cx.stats().borrow_mut().n_closures += 1;
-
let mir = cx.tcx().instance_mir(instance.def);
mir::codegen_mir::<Bx>(cx, lldecl, &mir, instance, sig);
}
pub fn codegen_crate<B: ExtraBackendMethods>(
backend: B,
- tcx: TyCtxt<'a, 'tcx, 'tcx>,
+ tcx: TyCtxt<'tcx, 'tcx>,
metadata: EncodedMetadata,
need_metadata_module: bool,
- rx: mpsc::Receiver<Box<dyn Any + Send>>
+ rx: mpsc::Receiver<Box<dyn Any + Send>>,
) -> OngoingCodegen<B> {
-
check_for_rustc_errors_attr(tcx);
// Skip crate items and just output metadata in -Z no-codegen mode.
};
let mut total_codegen_time = Duration::new(0, 0);
- let mut all_stats = Stats::default();
for cgu in codegen_units.into_iter() {
ongoing_codegen.wait_for_signal_to_codegen_item();
CguReuse::No => {
tcx.sess.profiler(|p| p.start_activity(format!("codegen {}", cgu.name())));
let start_time = Instant::now();
- let stats = backend.compile_codegen_unit(tcx, *cgu.name());
- all_stats.extend(stats);
+ backend.compile_codegen_unit(tcx, *cgu.name());
total_codegen_time += start_time.elapsed();
tcx.sess.profiler(|p| p.end_activity(format!("codegen {}", cgu.name())));
false
symbol_names_test::report_symbol_names(tcx);
- if tcx.sess.codegen_stats() {
- println!("--- codegen stats ---");
- println!("n_glues_created: {}", all_stats.n_glues_created);
- println!("n_null_glues: {}", all_stats.n_null_glues);
- println!("n_real_glues: {}", all_stats.n_real_glues);
-
- println!("n_fns: {}", all_stats.n_fns);
- println!("n_inlines: {}", all_stats.n_inlines);
- println!("n_closures: {}", all_stats.n_closures);
- println!("fn stats:");
- all_stats.fn_stats.sort_by_key(|&(_, insns)| insns);
- for &(ref name, insns) in all_stats.fn_stats.iter() {
- println!("{} insns, {}", insns, *name);
- }
- }
-
- if tcx.sess.count_llvm_insns() {
- for (k, v) in all_stats.llvm_insns.iter() {
- println!("{:7} {}", *v, *k);
- }
- }
-
ongoing_codegen.check_for_errors(tcx.sess);
assert_and_save_dep_graph(tcx);
}
}
-fn assert_and_save_dep_graph<'ll, 'tcx>(tcx: TyCtxt<'ll, 'tcx, 'tcx>) {
+fn assert_and_save_dep_graph<'tcx>(tcx: TyCtxt<'tcx, 'tcx>) {
time(tcx.sess,
"assert dep graph",
|| ::rustc_incremental::assert_dep_graph(tcx));
}
impl CrateInfo {
- pub fn new(tcx: TyCtxt<'_, '_, '_>) -> CrateInfo {
+ pub fn new(tcx: TyCtxt<'_, '_>) -> CrateInfo {
let mut info = CrateInfo {
panic_runtime: None,
compiler_builtins: None,
info.missing_lang_items.insert(cnum, missing);
}
- return info
+ return info;
}
}
-fn is_codegened_item(tcx: TyCtxt<'_, '_, '_>, id: DefId) -> bool {
+fn is_codegened_item(tcx: TyCtxt<'_, '_>, id: DefId) -> bool {
let (all_mono_items, _) =
tcx.collect_and_partition_mono_items(LOCAL_CRATE);
all_mono_items.contains(&id)
};
}
-fn determine_cgu_reuse<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
- cgu: &CodegenUnit<'tcx>)
- -> CguReuse {
+fn determine_cgu_reuse<'tcx>(tcx: TyCtxt<'tcx, 'tcx>, cgu: &CodegenUnit<'tcx>) -> CguReuse {
if !tcx.dep_graph.is_fully_enabled() {
return CguReuse::No
}
projects / rust.git / blobdiff