src/librustc_codegen_ssa/mono_item.rs

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