src/librustc_codegen_ssa/mono_item.rs

   1 use rustc::hir;
   2 use rustc::mir::mono::{Linkage, Visibility};
   3 use rustc::ty::layout::HasTyCtxt;
   4 use std::fmt;
   5 use crate::base;
   6 use crate::traits::*;
   7
   8 pub use rustc::mir::mono::MonoItem;
   9
  10 pub use rustc_mir::monomorphize::item::MonoItemExt as BaseMonoItemExt;
  11
  12 pub trait MonoItemExt<'a, 'tcx: 'a>: fmt::Debug + BaseMonoItemExt<'a, 'tcx> {
  13     fn define<Bx: BuilderMethods<'a, 'tcx>>(&self, cx: &'a Bx::CodegenCx) {
  14         debug!("BEGIN IMPLEMENTING '{} ({})' in cgu {}",
  15                self.to_string(cx.tcx(), true),
  16                self.to_raw_string(),
  17                cx.codegen_unit().name());
  18
  19         match *self.as_mono_item() {
  20             MonoItem::Static(def_id) => {
  21                 cx.codegen_static(def_id, cx.tcx().is_mutable_static(def_id));
  22             }
  23             MonoItem::GlobalAsm(hir_id) => {
  24                 let item = cx.tcx().hir().expect_item_by_hir_id(hir_id);
  25                 if let hir::ItemKind::GlobalAsm(ref ga) = item.node {
  26                     cx.codegen_global_asm(ga);
  27                 } else {
  28                     span_bug!(item.span, "Mismatch between hir::Item type and MonoItem type")
  29                 }
  30             }
  31             MonoItem::Fn(instance) => {
  32                 base::codegen_instance::<Bx>(&cx, instance);
  33             }
  34         }
  35
  36         debug!("END IMPLEMENTING '{} ({})' in cgu {}",
  37                self.to_string(cx.tcx(), true),
  38                self.to_raw_string(),
  39                cx.codegen_unit().name());
  40     }
  41
  42     fn predefine<Bx: BuilderMethods<'a, 'tcx>>(
  43         &self,
  44         cx: &'a Bx::CodegenCx,
  45         linkage: Linkage,
  46         visibility: Visibility
  47     ) {
  48         debug!("BEGIN PREDEFINING '{} ({})' in cgu {}",
  49                self.to_string(cx.tcx(), true),
  50                self.to_raw_string(),
  51                cx.codegen_unit().name());
  52
  53         let symbol_name = self.symbol_name(cx.tcx()).as_str();
  54
  55         debug!("symbol {}", &symbol_name);
  56
  57         match *self.as_mono_item() {
  58             MonoItem::Static(def_id) => {
  59                 cx.predefine_static(def_id, linkage, visibility, &symbol_name);
  60             }
  61             MonoItem::Fn(instance) => {
  62                 cx.predefine_fn(instance, linkage, visibility, &symbol_name);
  63             }
  64             MonoItem::GlobalAsm(..) => {}
  65         }
  66
  67         debug!("END PREDEFINING '{} ({})' in cgu {}",
  68                self.to_string(cx.tcx(), true),
  69                self.to_raw_string(),
  70                cx.codegen_unit().name());
  71     }
  72
  73     fn to_raw_string(&self) -> String {
  74         match *self.as_mono_item() {
  75             MonoItem::Fn(instance) => {
  76                 format!("Fn({:?}, {})",
  77                         instance.def,
  78                         instance.substs.as_ptr() as usize)
  79             }
  80             MonoItem::Static(id) => {
  81                 format!("Static({:?})", id)
  82             }
  83             MonoItem::GlobalAsm(id) => {
  84                 format!("GlobalAsm({:?})", id)
  85             }
  86         }
  87     }
  88 }
  89
  90 impl<'a, 'tcx: 'a> MonoItemExt<'a, 'tcx> for MonoItem<'tcx> {}