src/driver/mod.rs

   1 use std::any::Any;
   2
   3 use rustc_middle::middle::cstore::EncodedMetadata;
   4 use rustc_middle::mir::mono::{Linkage as RLinkage, MonoItem, Visibility};
   5
   6 use crate::prelude::*;
   7
   8 mod aot;
   9 #[cfg(feature = "jit")]
  10 mod jit;
  11
  12 pub(crate) fn codegen_crate(
  13     tcx: TyCtxt<'_>,
  14     metadata: EncodedMetadata,
  15     need_metadata_module: bool,
  16 ) -> Box<dyn Any> {
  17     tcx.sess.abort_if_errors();
  18
  19     if std::env::var("CG_CLIF_JIT").is_ok()
  20         && tcx.sess.crate_types().contains(&rustc_session::config::CrateType::Executable)
  21     {
  22         #[cfg(feature = "jit")]
  23         let _: ! = jit::run_jit(tcx);
  24
  25         #[cfg(not(feature = "jit"))]
  26         tcx.sess.fatal("jit support was disabled when compiling rustc_codegen_cranelift");
  27     }
  28
  29     aot::run_aot(tcx, metadata, need_metadata_module)
  30 }
  31
  32 fn codegen_mono_items<'tcx>(
  33     cx: &mut crate::CodegenCx<'tcx, impl Backend + 'static>,
  34     mono_items: Vec<(MonoItem<'tcx>, (RLinkage, Visibility))>,
  35 ) {
  36     cx.tcx.sess.time("predefine functions", || {
  37         for &(mono_item, (linkage, visibility)) in &mono_items {
  38             match mono_item {
  39                 MonoItem::Fn(instance) => {
  40                     let (name, sig) =
  41                         get_function_name_and_sig(cx.tcx, cx.module.isa().triple(), instance, false);
  42                     let linkage = crate::linkage::get_clif_linkage(mono_item, linkage, visibility);
  43                     cx.module.declare_function(&name, linkage, &sig).unwrap();
  44                 }
  45                 MonoItem::Static(_) | MonoItem::GlobalAsm(_) => {}
  46             }
  47         }
  48     });
  49
  50     for (mono_item, (linkage, visibility)) in mono_items {
  51         let linkage = crate::linkage::get_clif_linkage(mono_item, linkage, visibility);
  52         trans_mono_item(cx, mono_item, linkage);
  53     }
  54 }
  55
  56 fn trans_mono_item<'tcx, B: Backend + 'static>(
  57     cx: &mut crate::CodegenCx<'tcx, B>,
  58     mono_item: MonoItem<'tcx>,
  59     linkage: Linkage,
  60 ) {
  61     let tcx = cx.tcx;
  62     match mono_item {
  63         MonoItem::Fn(inst) => {
  64             let _inst_guard =
  65                 crate::PrintOnPanic(|| format!("{:?} {}", inst, tcx.symbol_name(inst).name));
  66             debug_assert!(!inst.substs.needs_infer());
  67             let _mir_guard = crate::PrintOnPanic(|| {
  68                 match inst.def {
  69                     InstanceDef::Item(_)
  70                     | InstanceDef::DropGlue(_, _)
  71                     | InstanceDef::Virtual(_, _) => {
  72                         let mut mir = ::std::io::Cursor::new(Vec::new());
  73                         crate::rustc_mir::util::write_mir_pretty(
  74                             tcx,
  75                             Some(inst.def_id()),
  76                             &mut mir,
  77                         )
  78                         .unwrap();
  79                         String::from_utf8(mir.into_inner()).unwrap()
  80                     }
  81                     _ => {
  82                         // FIXME fix write_mir_pretty for these instances
  83                         format!("{:#?}", tcx.instance_mir(inst.def))
  84                     }
  85                 }
  86             });
  87
  88             tcx.sess.time("codegen fn", || crate::base::trans_fn(cx, inst, linkage));
  89         }
  90         MonoItem::Static(def_id) => {
  91             crate::constant::codegen_static(&mut cx.constants_cx, def_id);
  92         }
  93         MonoItem::GlobalAsm(hir_id) => {
  94             let item = tcx.hir().expect_item(hir_id);
  95             if let rustc_hir::ItemKind::GlobalAsm(rustc_hir::GlobalAsm { asm }) = item.kind {
  96                 cx.global_asm.push_str(&*asm.as_str());
  97                 cx.global_asm.push_str("\n\n");
  98             } else {
  99                 bug!("Expected GlobalAsm found {:?}", item);
 100             }
 101         }
 102     }
 103 }
 104
 105 fn time<R>(tcx: TyCtxt<'_>, name: &'static str, f: impl FnOnce() -> R) -> R {
 106     if std::env::var("CG_CLIF_DISPLAY_CG_TIME").as_ref().map(|val| &**val) == Ok("1") {
 107         println!("[{:<30}: {}] start", tcx.crate_name(LOCAL_CRATE), name);
 108         let before = std::time::Instant::now();
 109         let res = tcx.sess.time(name, f);
 110         let after = std::time::Instant::now();
 111         println!("[{:<30}: {}] end time: {:?}", tcx.crate_name(LOCAL_CRATE), name, after - before);
 112         res
 113     } else {
 114         tcx.sess.time(name, f)
 115     }
 116 }