Generalized mir::codegen_mir (and all subsequent functions)

Author: denismerigoux

src/librustc_codegen_llvm/abi.rs

@@ -17,11 +17,12 @@ use mir::operand::OperandValue;
 use type_::Type;
 use type_of::{LayoutLlvmExt, PointerKind};
 use value::Value;
+use rustc_target::abi::call::ArgType;
 
-use interfaces::{BuilderMethods, ConstMethods, BaseTypeMethods, DerivedTypeMethods};
+use interfaces::*;
 
 use rustc_target::abi::{LayoutOf, Size, TyLayout};
-use rustc::ty::{self, Ty};
+use rustc::ty::{self, Ty, Instance};
 use rustc::ty::layout;
 
 use libc::c_uint;
@@ -279,6 +280,27 @@ impl ArgTypeExt<'ll, 'tcx> for ArgType<'tcx, Ty<'tcx>> {
     }
 }
 
+impl<'a, 'll: 'a, 'tcx: 'll> ArgTypeMethods<'a, 'll, 'tcx> for Builder<'a, 'll, 'tcx, &'ll Value> {
+    fn store_fn_arg(
+        &self,
+        ty: &ArgType<'tcx, Ty<'tcx>>,
+        idx: &mut usize, dst: PlaceRef<'tcx, <Self::CodegenCx as Backend>::Value>
+    ) {
+        ty.store_fn_arg(&self, idx, dst)
+    }
+    fn store_arg_ty(
+        &self,
+        ty: &ArgType<'tcx, Ty<'tcx>>,
+        val: &'ll Value,
+        dst: PlaceRef<'tcx, &'ll Value>
+    ) {
+        ty.store(&self, val, dst)
+    }
+    fn memory_ty(&self, ty: &ArgType<'tcx, Ty<'tcx>>) -> &'ll Type {
+        ty.memory_ty(self.cx())
+    }
+}
+
 pub trait FnTypeExt<'tcx> {
     fn of_instance(cx: &CodegenCx<'ll, 'tcx, &'ll Value>, instance: &ty::Instance<'tcx>) -> Self;
     fn new(cx: &CodegenCx<'ll, 'tcx, &'ll Value>,
@@ -754,3 +776,29 @@ impl<'tcx> FnTypeExt<'tcx> for FnType<'tcx, Ty<'tcx>> {
         }
     }
 }
+
+impl AbiMethods<'tcx> for CodegenCx<'ll, 'tcx, &'ll Value> {
+    fn new_fn_type(&self, sig: ty::FnSig<'tcx>, extra_args: &[Ty<'tcx>]) -> FnType<'tcx, Ty<'tcx>> {
+        FnType::new(&self, sig, extra_args)
+    }
+    fn new_vtable(
+        &self,
+        sig: ty::FnSig<'tcx>,
+        extra_args: &[Ty<'tcx>]
+    ) -> FnType<'tcx, Ty<'tcx>> {
+        FnType::new_vtable(&self, sig, extra_args)
+    }
+    fn fn_type_of_instance(&self, instance: &Instance<'tcx>) -> FnType<'tcx, Ty<'tcx>> {
+        FnType::of_instance(&self, instance)
+    }
+}
+
+impl AbiBuilderMethods<'a, 'll, 'tcx> for Builder<'a, 'll, 'tcx, &'ll Value> {
+    fn apply_attrs_callsite(
+        &self,
+        ty: &FnType<'tcx, Ty<'tcx>>,
+        callsite: <Self::CodegenCx as Backend>::Value
+    ) {
+        ty.apply_attrs_callsite(&self, callsite)
+    }
+}

src/librustc_codegen_llvm/asm.rs

@@ -15,41 +15,43 @@ use builder::Builder;
 use value::Value;
 
 use rustc::hir;
-use interfaces::{BuilderMethods, ConstMethods, BaseTypeMethods};
+use interfaces::*;
 
 use mir::place::PlaceRef;
 use mir::operand::OperandValue;
 
 use std::ffi::CString;
 use libc::{c_uint, c_char};
 
-// Take an inline assembly expression and splat it out via LLVM
-pub fn codegen_inline_asm(
-    bx: &Builder<'a, 'll, 'tcx, &'ll Value>,
-    ia: &hir::InlineAsm,
-    outputs: Vec<PlaceRef<'tcx, &'ll Value>>,
-    mut inputs: Vec<&'ll Value>
-) -> bool {
-    let mut ext_constraints = vec![];
-    let mut output_types = vec![];
-
-    // Prepare the output operands
-    let mut indirect_outputs = vec![];
-    for (i, (out, place)) in ia.outputs.iter().zip(&outputs).enumerate() {
-        if out.is_rw {
-            inputs.push(bx.load_ref(place).immediate());
-            ext_constraints.push(i.to_string());
+
+impl AsmBuilderMethods<'a, 'll, 'tcx> for Builder<'a, 'll, 'tcx, &'ll Value> {
+    // Take an inline assembly expression and splat it out via LLVM
+    fn codegen_inline_asm(
+        &self,
+        ia: &hir::InlineAsm,
+        outputs: Vec<PlaceRef<'tcx, &'ll Value>>,
+        mut inputs: Vec<&'ll Value>
+    ) -> bool {
+        let mut ext_constraints = vec![];
+        let mut output_types = vec![];
+
+        // Prepare the output operands
+        let mut indirect_outputs = vec![];
+        for (i, (out, place)) in ia.outputs.iter().zip(&outputs).enumerate() {
+            if out.is_rw {
+                inputs.push(self.load_ref(place).immediate());
+                ext_constraints.push(i.to_string());
+            }
+            if out.is_indirect {
+                indirect_outputs.push(self.load_ref(place).immediate());
+            } else {
+                output_types.push(place.layout.llvm_type(self.cx()));
+            }
         }
-        if out.is_indirect {
-            indirect_outputs.push(bx.load_ref(place).immediate());
-        } else {
-            output_types.push(place.layout.llvm_type(bx.cx()));
+        if !indirect_outputs.is_empty() {
+            indirect_outputs.extend_from_slice(&inputs);
+            inputs = indirect_outputs;
         }
-    }
-    if !indirect_outputs.is_empty() {
-        indirect_outputs.extend_from_slice(&inputs);
-        inputs = indirect_outputs;
-    }
 
     let clobbers = ia.clobbers.iter()
                               .map(|s| format!("~{{{}}}", &s));
@@ -103,26 +105,28 @@ pub fn codegen_inline_asm(
         OperandValue::Immediate(v).store(bx, place);
     }
 
-    // Store mark in a metadata node so we can map LLVM errors
-    // back to source locations.  See #17552.
-    unsafe {
-        let key = "srcloc";
-        let kind = llvm::LLVMGetMDKindIDInContext(bx.cx().llcx,
-            key.as_ptr() as *const c_char, key.len() as c_uint);
+        // Store mark in a metadata node so we can map LLVM errors
+        // back to source locations.  See #17552.
+        unsafe {
+            let key = "srcloc";
+            let kind = llvm::LLVMGetMDKindIDInContext(self.cx().llcx,
+                key.as_ptr() as *const c_char, key.len() as c_uint);
 
-        let val: &'ll Value = bx.cx().const_i32(ia.ctxt.outer().as_u32() as i32);
+            let val: &'ll Value = self.cx().const_i32(ia.ctxt.outer().as_u32() as i32);
 
-        llvm::LLVMSetMetadata(r, kind,
-            llvm::LLVMMDNodeInContext(bx.cx().llcx, &val, 1));
+            llvm::LLVMSetMetadata(r, kind,
+                llvm::LLVMMDNodeInContext(self.cx().llcx, &val, 1));
+        }
     }
 
     return true;
 }
 
-pub fn codegen_global_asm<'a, 'tcx>(cx: &CodegenCx<'a, 'tcx, &'a Value>,
-                                  ga: &hir::GlobalAsm) {
-    let asm = CString::new(ga.asm.as_str().as_bytes()).unwrap();
-    unsafe {
-        llvm::LLVMRustAppendModuleInlineAsm(cx.llmod, asm.as_ptr());
+impl AsmMethods for CodegenCx<'ll, 'tcx, &'ll Value> {
+    fn codegen_global_asm(&self, ga: &hir::GlobalAsm) {
+        let asm = CString::new(ga.asm.as_str().as_bytes()).unwrap();
+        unsafe {
+            llvm::LLVMRustAppendModuleInlineAsm(self.llmod, asm.as_ptr());
+        }
     }
 }

src/librustc_codegen_llvm/attributes.rs

@@ -16,11 +16,11 @@ use rustc::hir::def_id::{DefId, LOCAL_CRATE};
 use rustc::session::Session;
 use rustc::session::config::Sanitizer;
 use rustc::ty::TyCtxt;
-use rustc::ty::layout::HasTyCtxt;
 use rustc::ty::query::Providers;
 use rustc_data_structures::sync::Lrc;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_target::spec::PanicStrategy;
+use interfaces::*;
 
 use attributes;
 use llvm::{self, Attribute};

src/librustc_codegen_llvm/base.rs

@@ -58,7 +58,6 @@ use rustc_mir::monomorphize::item::DefPathBasedNames;
 use common::{self, IntPredicate, RealPredicate, TypeKind};
 use context::CodegenCx;
 use debuginfo;
-use declare;
 use meth;
 use mir;
 use monomorphize::Instance;
@@ -395,15 +394,18 @@ pub fn wants_msvc_seh(sess: &Session) -> bool {
     sess.target.target.options.is_like_msvc
 }
 
-pub fn call_assume(bx: &Builder<'_, 'll, '_, &'ll Value>, val: &'ll Value) {
+pub fn call_assume<'a, 'll: 'a, 'tcx: 'll, Bx : BuilderMethods<'a, 'll ,'tcx>>(
+    bx: &Bx,
+    val: <Bx::CodegenCx as Backend>::Value
+) {
     let assume_intrinsic = bx.cx().get_intrinsic("llvm.assume");
     bx.call(assume_intrinsic, &[val], None);
 }
 
-pub fn from_immediate<'a, 'll: 'a, 'tcx: 'll, Builder : BuilderMethods<'a, 'll ,'tcx>>(
-    bx: &Builder,
-    val: <Builder::CodegenCx as Backend>::Value
-) -> <Builder::CodegenCx as Backend>::Value {
+pub fn from_immediate<'a, 'll: 'a, 'tcx: 'll, Bx : BuilderMethods<'a, 'll ,'tcx>>(
+    bx: &Bx,
+    val: <Bx::CodegenCx as Backend>::Value
+) -> <Bx::CodegenCx as Backend>::Value {
     if bx.cx().val_ty(val) == bx.cx().type_i1() {
         bx.zext(val, bx.cx().type_i8())
     } else {
@@ -449,7 +451,7 @@ 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, 'tcx>(cx: &CodegenCx<'a, 'tcx, &'a Value>, instance: Instance<'tcx>) {
+pub fn codegen_instance<'a, 'll: 'a, 'tcx: 'll>(cx: &'a CodegenCx<'ll, 'tcx, &'ll Value>, instance: Instance<'tcx>) {
     let _s = if cx.sess().codegen_stats() {
         let mut instance_name = String::new();
         DefPathBasedNames::new(cx.tcx, true, true)
@@ -474,7 +476,7 @@ pub fn codegen_instance<'a, 'tcx>(cx: &CodegenCx<'a, 'tcx, &'a Value>, instance:
     cx.stats.borrow_mut().n_closures += 1;
 
     let mir = cx.tcx.instance_mir(instance.def);
-    mir::codegen_mir(cx, lldecl, &mir, instance, sig);
+    mir::codegen_mir::<'a, 'll, 'tcx, Builder<'a, 'll, 'tcx, &'ll Value>>(cx, lldecl, &mir, instance, sig);
 }
 
 pub fn set_link_section(llval: &Value, attrs: &CodegenFnAttrs) {
@@ -535,15 +537,15 @@ fn maybe_create_entry_wrapper(cx: &CodegenCx<'ll, '_, &'ll Value>) {
             &main_ret_ty.no_late_bound_regions().unwrap(),
         );
 
-        if declare::get_defined_value(cx, "main").is_some() {
+        if cx.get_defined_value("main").is_some() {
             // FIXME: We should be smart and show a better diagnostic here.
             cx.sess().struct_span_err(sp, "entry symbol `main` defined multiple times")
                      .help("did you use #[no_mangle] on `fn main`? Use #[start] instead")
                      .emit();
             cx.sess().abort_if_errors();
             bug!();
         }
-        let llfn = declare::declare_cfn(cx, "main", llfty);
+        let llfn = cx.declare_cfn("main", llfty);
 
         // `main` should respect same config for frame pointer elimination as rest of code
         attributes::set_frame_pointer_elimination(cx, llfn);

src/librustc_codegen_llvm/builder.rs

@@ -18,7 +18,7 @@ use value::Value;
 use libc::{c_uint, c_char};
 use rustc::ty::TyCtxt;
 use rustc::ty::layout::{self, Align, Size};
-use rustc::session::{config, Session};
+use rustc::session::config;
 use rustc_data_structures::small_c_str::SmallCStr;
 use interfaces::*;
 use syntax;
@@ -99,10 +99,6 @@ impl BuilderMethods<'a, 'll, 'tcx>
         Builder::new_block(self.cx, self.llfn(), name)
     }
 
-    fn sess(&self) -> &Session {
-        self.cx.sess()
-    }
-
     fn tcx(&self) -> TyCtxt<'a, 'tcx, 'tcx> {
         self.cx.tcx
     }
@@ -605,7 +601,7 @@ impl BuilderMethods<'a, 'll, 'tcx>
 
 
     fn range_metadata(&self, load: &'ll Value, range: Range<u128>) {
-        if self.sess().target.target.arch == "amdgpu" {
+        if self.cx().sess().target.target.arch == "amdgpu" {
             // amdgpu/LLVM does something weird and thinks a i64 value is
             // split into a v2i32, halving the bitwidth LLVM expects,
             // tripping an assertion. So, for now, just disable this
@@ -1381,7 +1377,7 @@ impl BuilderMethods<'a, 'll, 'tcx>
             return;
         }
         let cx = &self.cx();
-        let ptr_width = &self.sess().target.target.target_pointer_width;
+        let ptr_width = &self.cx().sess().target.target.target_pointer_width;
         let key = format!("llvm.memcpy.p0i8.p0i8.i{}", ptr_width);
         let memcpy = cx.get_intrinsic(&key);
         let src_ptr = &self.pointercast(src, cx.type_i8p());
@@ -1400,7 +1396,7 @@ impl BuilderMethods<'a, 'll, 'tcx>
         align: &'ll Value,
         volatile: bool,
     ) -> &'ll Value {
-        let ptr_width = &self.sess().target.target.target_pointer_width;
+        let ptr_width = &self.cx().sess().target.target.target_pointer_width;
         let intrinsic_key = format!("llvm.memset.p0i8.i{}", ptr_width);
         let llintrinsicfn = &self.cx().get_intrinsic(&intrinsic_key);
         let volatile = &self.cx().const_bool(volatile);
@@ -1425,4 +1421,14 @@ impl BuilderMethods<'a, 'll, 'tcx>
     fn cx(&self) -> &'a CodegenCx<'ll, 'tcx, &'ll Value> {
         &self.cx
     }
+
+    fn delete_basic_block(&self, bb: &'ll BasicBlock) {
+        unsafe {
+            llvm::LLVMDeleteBasicBlock(bb);
+        }
+    }
+
+    fn do_not_inline(&self, llret: &'ll Value) {
+        llvm::Attribute::NoInline.apply_callsite(llvm::AttributePlace::Function, llret);
+    }
 }

src/librustc_codegen_llvm/callee.rs

@@ -15,12 +15,10 @@
 //! closure.
 
 use attributes;
-use common::{self, CodegenCx};
-use consts;
-use declare;
+use common;
 use llvm;
 use monomorphize::Instance;
-use type_of::LayoutLlvmExt;
+use context::CodegenCx;
 use value::Value;
 use interfaces::*;
 
@@ -40,16 +38,16 @@ pub fn get_fn(
     cx: &CodegenCx<'ll, 'tcx, &'ll Value>,
     instance: Instance<'tcx>,
 ) -> &'ll Value {
-    let tcx = cx.tcx;
+    let tcx = cx.tcx();
 
     debug!("get_fn(instance={:?})", instance);
 
     assert!(!instance.substs.needs_infer());
     assert!(!instance.substs.has_escaping_regions());
     assert!(!instance.substs.has_param_types());
 
-    let fn_ty = instance.ty(cx.tcx);
-    if let Some(&llfn) = cx.instances.borrow().get(&instance) {
+    let fn_ty = instance.ty(*cx.tcx());
+    if let Some(&llfn) = cx.instances().borrow().get(&instance) {
         return llfn;
     }
 
@@ -58,9 +56,9 @@ pub fn get_fn(
 
     // Create a fn pointer with the substituted signature.
     let fn_ptr_ty = tcx.mk_fn_ptr(common::ty_fn_sig(cx, fn_ty));
-    let llptrty = cx.layout_of(fn_ptr_ty).llvm_type(cx);
+    let llptrty = cx.backend_type(&cx.layout_of(fn_ptr_ty));
 
-    let llfn = if let Some(llfn) = declare::get_declared_value(cx, &sym) {
+    let llfn = if let Some(llfn) = cx.get_declared_value(&sym) {
         // This is subtle and surprising, but sometimes we have to bitcast
         // the resulting fn pointer.  The reason has to do with external
         // functions.  If you have two crates that both bind the same C
@@ -86,17 +84,17 @@ pub fn get_fn(
         // other weird situations. Annoying.
         if cx.val_ty(llfn) != llptrty {
             debug!("get_fn: casting {:?} to {:?}", llfn, llptrty);
-            consts::ptrcast(llfn, llptrty)
+            cx.static_ptrcast(llfn, llptrty)
         } else {
             debug!("get_fn: not casting pointer!");
             llfn
         }
     } else {
-        let llfn = declare::declare_fn(cx, &sym, fn_ty);
+        let llfn = cx.declare_fn(&sym, fn_ty);
         assert_eq!(cx.val_ty(llfn), llptrty);
         debug!("get_fn: not casting pointer!");
 
-        if instance.def.is_inline(tcx) {
+        if instance.def.is_inline(*tcx) {
             attributes::inline(cx, llfn, attributes::InlineAttr::Hint);
         }
         attributes::from_fn_attrs(cx, llfn, Some(instance.def.def_id()));