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