Generalized mono_item.rs and base.rs:codegen_instance

denismerigoux · denismerigoux · commit 48af59f49e16 · 2018-10-23T15:40:01.000+02:00
diff --git a/src/librustc_codegen_llvm/base.rs b/src/librustc_codegen_llvm/base.rs
@@ -89,28 +89,33 @@ use value::Value;
 use mir::operand::OperandValue;
 
 use rustc_codegen_utils::check_for_rustc_errors_attr;
+use std::marker::PhantomData;
 
-pub struct StatRecorder<'a, 'll: 'a, 'tcx: 'll> {
-    cx: &'a CodegenCx<'ll, 'tcx, &'ll Value>,
+pub struct StatRecorder<'a, 'll: 'a, 'tcx: 'll, Cx: 'a + CodegenMethods<'ll, 'tcx>> {
+    cx: &'a Cx,
     name: Option<String>,
     istart: usize,
+    phantom: PhantomData<(&'ll (), &'tcx ())>
 }
 
-impl StatRecorder<'a, 'll, 'tcx> {
-    pub fn new(cx: &'a CodegenCx<'ll, 'tcx, &'ll Value>, name: String) -> Self {
-        let istart = cx.stats.borrow().n_llvm_insns;
+impl<'a, 'll: 'a, 'tcx: 'll, Cx: 'a + CodegenMethods<'ll, 'tcx>> StatRecorder<'a, 'll, '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,
+            phantom: PhantomData
         }
     }
 }
 
-impl Drop for StatRecorder<'a, 'll, 'tcx> {
+impl<'a, 'll: 'a, 'tcx: 'll, Cx: 'a + CodegenMethods<'ll, 'tcx>> Drop for
+    StatRecorder<'a, 'll, 'tcx, Cx>
+{
     fn drop(&mut self) {
         if self.cx.sess().codegen_stats() {
-            let mut stats = self.cx.stats.borrow_mut();
+            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;
@@ -451,13 +456,13 @@ pub fn memcpy_ty<'a, 'll: 'a, 'tcx: 'll, Builder : BuilderMethods<'a, 'll, 'tcx>
     bx.call_memcpy(dst, src, bx.cx().const_usize(size), align, flags);
 }
 
-pub fn codegen_instance<'a, 'll: 'a, 'tcx: 'll>(
-    cx: &'a CodegenCx<'ll, 'tcx, &'ll Value>,
+pub fn codegen_instance<'a, 'll: 'a, 'tcx: 'll, Bx: BuilderMethods<'a, 'll, 'tcx>>(
+    cx: &'a Bx::CodegenCx,
     instance: Instance<'tcx>
-) {
+) where &'a Bx::CodegenCx : LayoutOf<Ty = Ty<'tcx>, TyLayout=TyLayout<'tcx>> + HasTyCtxt<'tcx> {
     let _s = if cx.sess().codegen_stats() {
         let mut instance_name = String::new();
-        DefPathBasedNames::new(cx.tcx, true, true)
+        DefPathBasedNames::new(*cx.tcx(), true, true)
             .push_def_path(instance.def_id(), &mut instance_name);
         Some(StatRecorder::new(cx, instance_name))
     } else {
@@ -469,17 +474,17 @@ pub fn codegen_instance<'a, 'll: 'a, 'tcx: 'll>(
     // release builds.
     info!("codegen_instance({})", instance);
 
-    let fn_ty = instance.ty(cx.tcx);
+    let fn_ty = instance.ty(*cx.tcx());
     let sig = common::ty_fn_sig(cx, fn_ty);
-    let sig = cx.tcx.normalize_erasing_late_bound_regions(ty::ParamEnv::reveal_all(), &sig);
+    let sig = cx.tcx().normalize_erasing_late_bound_regions(ty::ParamEnv::reveal_all(), &sig);
 
-    let lldecl = cx.instances.borrow().get(&instance).cloned().unwrap_or_else(||
+    let lldecl = cx.instances().borrow().get(&instance).cloned().unwrap_or_else(||
         bug!("Instance `{:?}` not already declared", instance));
 
-    cx.stats.borrow_mut().n_closures += 1;
+    cx.stats().borrow_mut().n_closures += 1;
 
-    let mir = cx.tcx.instance_mir(instance.def);
-    mir::codegen_mir::<'a, 'll, 'tcx, Builder<'a, 'll, 'tcx, &'ll Value>>(
+    let mir = cx.tcx().instance_mir(instance.def);
+    mir::codegen_mir::<'a, 'll, 'tcx, Bx>(
         cx, lldecl, &mir, instance, sig
     );
 }
diff --git a/src/librustc_codegen_llvm/context.rs b/src/librustc_codegen_llvm/context.rs
@@ -418,6 +418,14 @@ impl MiscMethods<'ll, 'tcx> for CodegenCx<'ll, 'tcx, &'ll Value> {
     fn check_overflow(&self) -> bool {
         self.check_overflow
     }
+
+    fn stats(&self) -> &RefCell<Stats> {
+        &self.stats
+    }
+
+    fn codegen_unit(&self) -> &Arc<CodegenUnit<'tcx>> {
+        &self.codegen_unit
+    }
 }
 
 impl<'ll, 'tcx: 'll> CodegenMethods<'ll, 'tcx> for CodegenCx<'ll, 'tcx, &'ll Value> {}
diff --git a/src/librustc_codegen_llvm/interfaces/declare.rs b/src/librustc_codegen_llvm/interfaces/declare.rs
@@ -10,6 +10,9 @@
 
 use rustc::ty::Ty;
 use super::backend::Backend;
+use rustc::hir::def_id::DefId;
+use rustc::mir::mono::{Linkage, Visibility};
+use monomorphize::Instance;
 
 pub trait DeclareMethods<'ll, 'tcx: 'll> : Backend<'ll> {
     fn declare_global(
@@ -45,3 +48,20 @@ pub trait DeclareMethods<'ll, 'tcx: 'll> : Backend<'ll> {
     fn get_declared_value(&self, name: &str) -> Option<Self::Value>;
     fn get_defined_value(&self, name: &str) -> Option<Self::Value>;
 }
+
+pub trait PreDefineMethods<'ll, 'tcx: 'll> : Backend<'ll> {
+    fn predefine_static(
+        &self,
+        def_id: DefId,
+        linkage: Linkage,
+        visibility: Visibility,
+        symbol_name: &str
+    );
+    fn predefine_fn(
+        &self,
+        instance: Instance<'tcx>,
+        linkage: Linkage,
+        visibility: Visibility,
+        symbol_name: &str
+    );
+}
diff --git a/src/librustc_codegen_llvm/interfaces/misc.rs b/src/librustc_codegen_llvm/interfaces/misc.rs
@@ -14,6 +14,9 @@ use rustc::ty::{Ty, self, Instance};
 use super::backend::Backend;
 use rustc::session::Session;
 use libc::c_uint;
+use rustc::mir::mono::Stats;
+use std::sync::Arc;
+use monomorphize::partitioning::CodegenUnit;
 
 pub trait MiscMethods<'ll, 'tcx: 'll> : Backend<'ll> {
     fn vtables(&self) -> &RefCell<FxHashMap<(Ty<'tcx>,
@@ -25,4 +28,6 @@ pub trait MiscMethods<'ll, 'tcx: 'll> : Backend<'ll> {
     fn eh_personality(&self) -> Self::Value;
     fn eh_unwind_resume(&self) -> Self::Value;
     fn sess(&self) -> &Session;
+    fn stats(&self) -> &RefCell<Stats>;
+    fn codegen_unit(&self) -> &Arc<CodegenUnit<'tcx>>;
 }
diff --git a/src/librustc_codegen_llvm/interfaces/mod.rs b/src/librustc_codegen_llvm/interfaces/mod.rs
@@ -30,14 +30,15 @@ pub use self::statics::StaticMethods;
 pub use self::misc::MiscMethods;
 pub use self::debuginfo::{DebugInfoMethods, DebugInfoBuilderMethods};
 pub use self::abi::{AbiMethods, AbiBuilderMethods};
-pub use self::declare::DeclareMethods;
+pub use self::declare::{DeclareMethods, PreDefineMethods};
 pub use self::asm::{AsmMethods, AsmBuilderMethods};
 
 use std::fmt;
 
 pub trait CodegenMethods<'ll, 'tcx: 'll> :
     Backend<'ll> + TypeMethods<'ll, 'tcx> + MiscMethods<'ll, 'tcx> + ConstMethods<'ll, 'tcx> +
     StaticMethods<'ll> + DebugInfoMethods<'ll, 'tcx> + AbiMethods<'tcx> +
-    IntrinsicDeclarationMethods<'ll> + DeclareMethods<'ll, 'tcx> + AsmMethods {}
+    IntrinsicDeclarationMethods<'ll> + DeclareMethods<'ll, 'tcx> + AsmMethods +
+    PreDefineMethods<'ll, 'tcx> {}
 
 pub trait CodegenObject : Copy + PartialEq + fmt::Debug {}
diff --git a/src/librustc_codegen_llvm/mono_item.rs b/src/librustc_codegen_llvm/mono_item.rs
@@ -24,26 +24,30 @@ use rustc::hir;
 use rustc::hir::def::Def;
 use rustc::hir::def_id::{DefId, LOCAL_CRATE};
 use rustc::mir::mono::{Linkage, Visibility};
-use rustc::ty::TypeFoldable;
-use rustc::ty::layout::LayoutOf;
+use rustc::ty::{TypeFoldable, Ty};
+use rustc::ty::layout::{LayoutOf, HasTyCtxt, TyLayout};
 use std::fmt;
 use value::Value;
+use builder::Builder;
 use interfaces::*;
 
 pub use rustc::mir::mono::MonoItem;
 
 pub use rustc_mir::monomorphize::item::MonoItemExt as BaseMonoItemExt;
 
-pub trait MonoItemExt<'a, 'tcx>: fmt::Debug + BaseMonoItemExt<'a, 'tcx> {
-    fn define(&self, cx: &CodegenCx<'a, 'tcx, &'a Value>) {
+pub trait MonoItemExt<'a, 'll: 'a, 'tcx: 'll, Bx: BuilderMethods<'a, 'll, 'tcx>> :
+    fmt::Debug + BaseMonoItemExt<'ll, 'tcx> where
+    &'a Bx::CodegenCx : LayoutOf<Ty = Ty<'tcx>, TyLayout=TyLayout<'tcx>> + HasTyCtxt<'tcx>
+{
+    fn define(&self, cx: &'a Bx::CodegenCx) {
         debug!("BEGIN IMPLEMENTING '{} ({})' in cgu {}",
-               self.to_string(cx.tcx),
+               self.to_string(*cx.tcx()),
                self.to_raw_string(),
-               cx.codegen_unit.name());
+               cx.codegen_unit().name());
 
         match *self.as_mono_item() {
             MonoItem::Static(def_id) => {
-                let tcx = cx.tcx;
+                let tcx = *cx.tcx();
                 let is_mutable = match tcx.describe_def(def_id) {
                     Some(Def::Static(_, is_mutable)) => is_mutable,
                     Some(other) => {
@@ -56,51 +60,51 @@ pub trait MonoItemExt<'a, 'tcx>: fmt::Debug + BaseMonoItemExt<'a, 'tcx> {
                 cx.codegen_static(def_id, is_mutable);
             }
             MonoItem::GlobalAsm(node_id) => {
-                let item = cx.tcx.hir.expect_item(node_id);
+                let item = cx.tcx().hir.expect_item(node_id);
                 if let hir::ItemKind::GlobalAsm(ref ga) = item.node {
                     cx.codegen_global_asm(ga);
                 } else {
                     span_bug!(item.span, "Mismatch between hir::Item type and MonoItem type")
                 }
             }
             MonoItem::Fn(instance) => {
-                base::codegen_instance(&cx, instance);
+                base::codegen_instance::<'a, 'll, 'tcx, Bx>(&cx, instance);
             }
         }
 
         debug!("END IMPLEMENTING '{} ({})' in cgu {}",
-               self.to_string(cx.tcx),
+               self.to_string(*cx.tcx()),
                self.to_raw_string(),
-               cx.codegen_unit.name());
+               cx.codegen_unit().name());
     }
 
     fn predefine(&self,
-                 cx: &CodegenCx<'a, 'tcx, &'a Value>,
+                 cx: &'a Bx::CodegenCx,
                  linkage: Linkage,
                  visibility: Visibility) {
         debug!("BEGIN PREDEFINING '{} ({})' in cgu {}",
-               self.to_string(cx.tcx),
+               self.to_string(*cx.tcx()),
                self.to_raw_string(),
-               cx.codegen_unit.name());
+               cx.codegen_unit().name());
 
-        let symbol_name = self.symbol_name(cx.tcx).as_str();
+        let symbol_name = self.symbol_name(*cx.tcx()).as_str();
 
         debug!("symbol {}", &symbol_name);
 
         match *self.as_mono_item() {
             MonoItem::Static(def_id) => {
-                predefine_static(cx, def_id, linkage, visibility, &symbol_name);
+                cx.predefine_static(def_id, linkage, visibility, &symbol_name);
             }
             MonoItem::Fn(instance) => {
-                predefine_fn(cx, instance, linkage, visibility, &symbol_name);
+                cx.predefine_fn(instance, linkage, visibility, &symbol_name);
             }
             MonoItem::GlobalAsm(..) => {}
         }
 
         debug!("END PREDEFINING '{} ({})' in cgu {}",
-               self.to_string(cx.tcx),
+               self.to_string(*cx.tcx()),
                self.to_raw_string(),
-               cx.codegen_unit.name());
+               cx.codegen_unit().name());
     }
 
     fn to_raw_string(&self) -> String {
@@ -120,68 +124,71 @@ pub trait MonoItemExt<'a, 'tcx>: fmt::Debug + BaseMonoItemExt<'a, 'tcx> {
     }
 }
 
-impl<'a, 'tcx> MonoItemExt<'a, 'tcx> for MonoItem<'tcx> {}
+impl<'a, 'll:'a, 'tcx: 'll> MonoItemExt<'a, 'll, 'tcx, Builder<'a, 'll, 'tcx, &'ll Value>>
+    for MonoItem<'tcx> {}
 
-fn predefine_static<'a, 'tcx>(cx: &CodegenCx<'a, 'tcx, &'a Value>,
-                              def_id: DefId,
-                              linkage: Linkage,
-                              visibility: Visibility,
-                              symbol_name: &str) {
-    let instance = Instance::mono(cx.tcx, def_id);
-    let ty = instance.ty(cx.tcx);
-    let llty = cx.layout_of(ty).llvm_type(cx);
-
-    let g = cx.define_global(symbol_name, llty).unwrap_or_else(|| {
-        cx.sess().span_fatal(cx.tcx.def_span(def_id),
-            &format!("symbol `{}` is already defined", symbol_name))
-    });
-
-    unsafe {
-        llvm::LLVMRustSetLinkage(g, base::linkage_to_llvm(linkage));
-        llvm::LLVMRustSetVisibility(g, base::visibility_to_llvm(visibility));
-    }
+impl<'ll, 'tcx: 'll> PreDefineMethods<'ll, 'tcx> for CodegenCx<'ll, 'tcx, &'ll Value> {
+    fn predefine_static(&self,
+                                  def_id: DefId,
+                                  linkage: Linkage,
+                                  visibility: Visibility,
+                                  symbol_name: &str) {
+        let instance = Instance::mono(self.tcx, def_id);
+        let ty = instance.ty(self.tcx);
+        let llty = self.layout_of(ty).llvm_type(self);
 
-    cx.instances.borrow_mut().insert(instance, g);
-}
+        let g = self.define_global(symbol_name, llty).unwrap_or_else(|| {
+            self.sess().span_fatal(self.tcx.def_span(def_id),
+                &format!("symbol `{}` is already defined", symbol_name))
+        });
 
-fn predefine_fn<'a, 'tcx>(cx: &CodegenCx<'a, 'tcx, &'a Value>,
-                          instance: Instance<'tcx>,
-                          linkage: Linkage,
-                          visibility: Visibility,
-                          symbol_name: &str) {
-    assert!(!instance.substs.needs_infer() &&
-            !instance.substs.has_param_types());
-
-    let mono_ty = instance.ty(cx.tcx);
-    let attrs = cx.tcx.codegen_fn_attrs(instance.def_id());
-    let lldecl = cx.declare_fn(symbol_name, mono_ty);
-    unsafe { llvm::LLVMRustSetLinkage(lldecl, base::linkage_to_llvm(linkage)) };
-    base::set_link_section(lldecl, &attrs);
-    if linkage == Linkage::LinkOnceODR ||
-        linkage == Linkage::WeakODR {
-        llvm::SetUniqueComdat(cx.llmod, lldecl);
+        unsafe {
+            llvm::LLVMRustSetLinkage(g, base::linkage_to_llvm(linkage));
+            llvm::LLVMRustSetVisibility(g, base::visibility_to_llvm(visibility));
+        }
+
+        self.instances.borrow_mut().insert(instance, g);
     }
 
-    // If we're compiling the compiler-builtins crate, e.g. the equivalent of
-    // compiler-rt, then we want to implicitly compile everything with hidden
-    // visibility as we're going to link this object all over the place but
-    // don't want the symbols to get exported.
-    if linkage != Linkage::Internal && linkage != Linkage::Private &&
-       cx.tcx.is_compiler_builtins(LOCAL_CRATE) {
-        unsafe {
-            llvm::LLVMRustSetVisibility(lldecl, llvm::Visibility::Hidden);
+    fn predefine_fn(&self,
+                              instance: Instance<'tcx>,
+                              linkage: Linkage,
+                              visibility: Visibility,
+                              symbol_name: &str) {
+        assert!(!instance.substs.needs_infer() &&
+                !instance.substs.has_param_types());
+
+        let mono_ty = instance.ty(self.tcx);
+        let attrs = self.tcx.codegen_fn_attrs(instance.def_id());
+        let lldecl = self.declare_fn(symbol_name, mono_ty);
+        unsafe { llvm::LLVMRustSetLinkage(lldecl, base::linkage_to_llvm(linkage)) };
+        base::set_link_section(lldecl, &attrs);
+        if linkage == Linkage::LinkOnceODR ||
+            linkage == Linkage::WeakODR {
+            llvm::SetUniqueComdat(self.llmod, lldecl);
         }
-    } else {
-        unsafe {
-            llvm::LLVMRustSetVisibility(lldecl, base::visibility_to_llvm(visibility));
+
+        // If we're compiling the compiler-builtins crate, e.g. the equivalent of
+        // compiler-rt, then we want to implicitly compile everything with hidden
+        // visibility as we're going to link this object all over the place but
+        // don't want the symbols to get exported.
+        if linkage != Linkage::Internal && linkage != Linkage::Private &&
+           self.tcx.is_compiler_builtins(LOCAL_CRATE) {
+            unsafe {
+                llvm::LLVMRustSetVisibility(lldecl, llvm::Visibility::Hidden);
+            }
+        } else {
+            unsafe {
+                llvm::LLVMRustSetVisibility(lldecl, base::visibility_to_llvm(visibility));
+            }
         }
-    }
 
-    debug!("predefine_fn: mono_ty = {:?} instance = {:?}", mono_ty, instance);
-    if instance.def.is_inline(cx.tcx) {
-        attributes::inline(cx, lldecl, attributes::InlineAttr::Hint);
-    }
-    attributes::from_fn_attrs(cx, lldecl, Some(instance.def.def_id()));
+        debug!("predefine_fn: mono_ty = {:?} instance = {:?}", mono_ty, instance);
+        if instance.def.is_inline(self.tcx) {
+            attributes::inline(self, lldecl, attributes::InlineAttr::Hint);
+        }
+        attributes::from_fn_attrs(self, lldecl, Some(instance.def.def_id()));
 
-    cx.instances.borrow_mut().insert(instance, lldecl);
+        self.instances.borrow_mut().insert(instance, lldecl);
+    }
 }

Original file line number	Diff line number	Diff line change
`@@ -418,6 +418,14 @@ impl MiscMethods<'ll, 'tcx> for CodegenCx<'ll, 'tcx, &'ll Value> {`
`418`	`418`	`fn check_overflow(&self) -> bool {`
`419`	`419`	`self.check_overflow`
`420`	`420`	`}`
	`421`	`+`
	`422`	`+ fn stats(&self) -> &RefCell<Stats> {`
	`423`	`+ &self.stats`
	`424`	`+ }`
	`425`	`+`
	`426`	`+ fn codegen_unit(&self) -> &Arc<CodegenUnit<'tcx>> {`
	`427`	`+ &self.codegen_unit`
	`428`	`+ }`
`421`	`429`	`}`
`422`	`430`
`423`	`431`	`impl<'ll, 'tcx: 'll> CodegenMethods<'ll, 'tcx> for CodegenCx<'ll, 'tcx, &'ll Value> {}`