rustc_codegen_llvm: traitification of LLVM-specific CodegenCx and Builder methods

src/librustc_codegen_llvm/abi.rs

@@ -11,14 +11,15 @@
 use llvm::{self, AttributePlace};
 use base;
 use builder::{Builder, MemFlags};
-use common::C_usize;
 use context::CodegenCx;
 use mir::place::PlaceRef;
 use mir::operand::OperandValue;
 use type_::Type;
 use type_of::{LayoutLlvmExt, PointerKind};
 use value::Value;
 
+use interfaces::{BuilderMethods, CommonMethods};
+
 use rustc_target::abi::{HasDataLayout, LayoutOf, Size, TyLayout, Abi as LayoutAbi};
 use rustc::ty::{self, Ty};
 use rustc::ty::layout;
@@ -167,8 +168,18 @@ impl LlvmType for CastTarget {
 
 pub trait ArgTypeExt<'ll, 'tcx> {
     fn memory_ty(&self, cx: &CodegenCx<'ll, 'tcx>) -> &'ll Type;
-    fn store(&self, bx: &Builder<'_, 'll, 'tcx>, val: &'ll Value, dst: PlaceRef<'ll, 'tcx>);
-    fn store_fn_arg(&self, bx: &Builder<'_, 'll, 'tcx>, idx: &mut usize, dst: PlaceRef<'ll, 'tcx>);
+    fn store(
+        &self,
+        bx: &Builder<'_, 'll, 'tcx>,
+        val: &'ll Value,
+        dst: PlaceRef<'tcx, &'ll Value>,
+    );
+    fn store_fn_arg(
+        &self,
+        bx: &Builder<'_, 'll, 'tcx>,
+        idx: &mut usize,
+        dst: PlaceRef<'tcx, &'ll Value>,
+    );
 }
 
 impl ArgTypeExt<'ll, 'tcx> for ArgType<'tcx, Ty<'tcx>> {
@@ -182,7 +193,12 @@ impl ArgTypeExt<'ll, 'tcx> for ArgType<'tcx, Ty<'tcx>> {
     /// place for the original Rust type of this argument/return.
     /// Can be used for both storing formal arguments into Rust variables
     /// or results of call/invoke instructions into their destinations.
-    fn store(&self, bx: &Builder<'_, 'll, 'tcx>, val: &'ll Value, dst: PlaceRef<'ll, 'tcx>) {
+    fn store(
+        &self,
+        bx: &Builder<'_, 'll, 'tcx>,
+        val: &'ll Value,
+        dst: PlaceRef<'tcx, &'ll Value>,
+    ) {
         if self.is_ignore() {
             return;
         }
@@ -228,7 +244,7 @@ impl ArgTypeExt<'ll, 'tcx> for ArgType<'tcx, Ty<'tcx>> {
                                   self.layout.align,
                                   bx.pointercast(llscratch, Type::i8p(cx)),
                                   scratch_align,
-                                  C_usize(cx, self.layout.size.bytes()),
+                                  CodegenCx::c_usize(cx, self.layout.size.bytes()),
                                   MemFlags::empty());
 
                 bx.lifetime_end(llscratch, scratch_size);
@@ -238,7 +254,12 @@ impl ArgTypeExt<'ll, 'tcx> for ArgType<'tcx, Ty<'tcx>> {
         }
     }
 
-    fn store_fn_arg(&self, bx: &Builder<'a, 'll, 'tcx>, idx: &mut usize, dst: PlaceRef<'ll, 'tcx>) {
+    fn store_fn_arg(
+        &self,
+        bx: &Builder<'a, 'll, 'tcx>,
+        idx: &mut usize,
+        dst: PlaceRef<'tcx, &'ll Value>,
+    ) {
         let mut next = || {
             let val = llvm::get_param(bx.llfn(), *idx as c_uint);
             *idx += 1;

src/librustc_codegen_llvm/asm.rs

@@ -9,26 +9,26 @@
 // except according to those terms.
 
 use llvm;
-use common::*;
+use context::CodegenCx;
 use type_::Type;
 use type_of::LayoutLlvmExt;
 use builder::Builder;
 use value::Value;
 
 use rustc::hir;
+use interfaces::{BuilderMethods, CommonMethods};
 
 use mir::place::PlaceRef;
 use mir::operand::OperandValue;
 
 use std::ffi::CString;
-use syntax::ast::AsmDialect;
 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>,
     ia: &hir::InlineAsm,
-    outputs: Vec<PlaceRef<'ll, 'tcx>>,
+    outputs: Vec<PlaceRef<'tcx, &'ll Value>>,
     mut inputs: Vec<&'ll Value>
 ) -> bool {
     let mut ext_constraints = vec![];
@@ -81,11 +81,6 @@ pub fn codegen_inline_asm(
         _ => Type::struct_(bx.cx, &output_types, false)
     };
 
-    let dialect = match ia.dialect {
-        AsmDialect::Att   => llvm::AsmDialect::Att,
-        AsmDialect::Intel => llvm::AsmDialect::Intel,
-    };
-
     let asm = CString::new(ia.asm.as_str().as_bytes()).unwrap();
     let constraint_cstr = CString::new(all_constraints).unwrap();
     let r = bx.inline_asm_call(
@@ -95,7 +90,7 @@ pub fn codegen_inline_asm(
         output_type,
         ia.volatile,
         ia.alignstack,
-        dialect
+        ia.dialect
     );
     if r.is_none() {
         return false;
@@ -116,7 +111,7 @@ pub fn codegen_inline_asm(
         let kind = llvm::LLVMGetMDKindIDInContext(bx.cx.llcx,
             key.as_ptr() as *const c_char, key.len() as c_uint);
 
-        let val: &'ll Value = C_i32(bx.cx, ia.ctxt.outer().as_u32() as i32);
+        let val: &'ll Value = CodegenCx::c_i32(bx.cx, ia.ctxt.outer().as_u32() as i32);
 
         llvm::LLVMSetMetadata(r, kind,
             llvm::LLVMMDNodeInContext(bx.cx.llcx, &val, 1));

src/librustc_codegen_llvm/back/link.rs

@@ -740,7 +740,7 @@ fn link_natively(sess: &Session,
     // with some thread pool working in the background. It seems that no one
     // currently knows a fix for this so in the meantime we're left with this...
     info!("{:?}", &cmd);
-    let retry_on_segfault = env::var("RUSTC_RETRY_LINKER_ON_SEGFAULT").is_ok();
+    let retry_on_segfault = env::var("RUSTc_RETRY_LINKER_ON_SEGFAULT").is_ok();
     let mut prog;
     let mut i = 0;
     loop {

src/librustc_codegen_llvm/back/write.rs

@@ -45,8 +45,8 @@ use syntax::ext::hygiene::Mark;
 use syntax_pos::MultiSpan;
 use syntax_pos::symbol::Symbol;
 use type_::Type;
-use context::{is_pie_binary, get_reloc_model};
-use common::{C_bytes_in_context, val_ty};
+use context::{is_pie_binary, get_reloc_model, CodegenCx};
+use interfaces::CommonMethods;
 use jobserver::{Client, Acquired};
 use rustc_demangle;
 
@@ -884,10 +884,10 @@ unsafe fn embed_bitcode(cgcx: &CodegenContext,
                         llcx: &llvm::Context,
                         llmod: &llvm::Module,
                         bitcode: Option<&[u8]>) {
-    let llconst = C_bytes_in_context(llcx, bitcode.unwrap_or(&[]));
+    let llconst = CodegenCx::c_bytes_in_context(llcx, bitcode.unwrap_or(&[]));
     let llglobal = llvm::LLVMAddGlobal(
         llmod,
-        val_ty(llconst),
+        CodegenCx::val_ty(llconst),
         "rustc.embedded.module\0".as_ptr() as *const _,
     );
     llvm::LLVMSetInitializer(llglobal, llconst);
@@ -904,10 +904,10 @@ unsafe fn embed_bitcode(cgcx: &CodegenContext,
     llvm::LLVMRustSetLinkage(llglobal, llvm::Linkage::PrivateLinkage);
     llvm::LLVMSetGlobalConstant(llglobal, llvm::True);
 
-    let llconst = C_bytes_in_context(llcx, &[]);
+    let llconst = CodegenCx::c_bytes_in_context(llcx, &[]);
     let llglobal = llvm::LLVMAddGlobal(
         llmod,
-        val_ty(llconst),
+        CodegenCx::val_ty(llconst),
         "rustc.embedded.cmdline\0".as_ptr() as *const _,
     );
     llvm::LLVMSetInitializer(llglobal, llconst);

src/librustc_codegen_llvm/base.rs

@@ -53,9 +53,8 @@ use mir::place::PlaceRef;
 use attributes;
 use builder::{Builder, MemFlags};
 use callee;
-use common::{C_bool, C_bytes_in_context, C_usize};
 use rustc_mir::monomorphize::item::DefPathBasedNames;
-use common::{C_struct_in_context, C_array, val_ty};
+use common::{IntPredicate, RealPredicate};
 use consts;
 use context::CodegenCx;
 use debuginfo;
@@ -75,6 +74,8 @@ use rustc_data_structures::small_c_str::SmallCStr;
 use rustc_data_structures::sync::Lrc;
 use rustc_data_structures::indexed_vec::Idx;
 
+use interfaces::{BuilderMethods, CommonMethods};
+
 use std::any::Any;
 use std::cmp;
 use std::ffi::CString;
@@ -124,14 +125,14 @@ impl Drop for StatRecorder<'a, 'll, 'tcx> {
 
 pub fn bin_op_to_icmp_predicate(op: hir::BinOpKind,
                                 signed: bool)
-                                -> llvm::IntPredicate {
+                                -> IntPredicate {
     match op {
-        hir::BinOpKind::Eq => llvm::IntEQ,
-        hir::BinOpKind::Ne => llvm::IntNE,
-        hir::BinOpKind::Lt => if signed { llvm::IntSLT } else { llvm::IntULT },
-        hir::BinOpKind::Le => if signed { llvm::IntSLE } else { llvm::IntULE },
-        hir::BinOpKind::Gt => if signed { llvm::IntSGT } else { llvm::IntUGT },
-        hir::BinOpKind::Ge => if signed { llvm::IntSGE } else { llvm::IntUGE },
+        hir::BinOpKind::Eq => IntPredicate::IntEQ,
+        hir::BinOpKind::Ne => IntPredicate::IntNE,
+        hir::BinOpKind::Lt => if signed { IntPredicate::IntSLT } else { IntPredicate::IntULT },
+        hir::BinOpKind::Le => if signed { IntPredicate::IntSLE } else { IntPredicate::IntULE },
+        hir::BinOpKind::Gt => if signed { IntPredicate::IntSGT } else { IntPredicate::IntUGT },
+        hir::BinOpKind::Ge => if signed { IntPredicate::IntSGE } else { IntPredicate::IntUGE },
         op => {
             bug!("comparison_op_to_icmp_predicate: expected comparison operator, \
                   found {:?}",
@@ -140,14 +141,14 @@ pub fn bin_op_to_icmp_predicate(op: hir::BinOpKind,
     }
 }
 
-pub fn bin_op_to_fcmp_predicate(op: hir::BinOpKind) -> llvm::RealPredicate {
+pub fn bin_op_to_fcmp_predicate(op: hir::BinOpKind) -> RealPredicate {
     match op {
-        hir::BinOpKind::Eq => llvm::RealOEQ,
-        hir::BinOpKind::Ne => llvm::RealUNE,
-        hir::BinOpKind::Lt => llvm::RealOLT,
-        hir::BinOpKind::Le => llvm::RealOLE,
-        hir::BinOpKind::Gt => llvm::RealOGT,
-        hir::BinOpKind::Ge => llvm::RealOGE,
+        hir::BinOpKind::Eq => RealPredicate::RealOEQ,
+        hir::BinOpKind::Ne => RealPredicate::RealUNE,
+        hir::BinOpKind::Lt => RealPredicate::RealOLT,
+        hir::BinOpKind::Le => RealPredicate::RealOLE,
+        hir::BinOpKind::Gt => RealPredicate::RealOGT,
+        hir::BinOpKind::Ge => RealPredicate::RealOGE,
         op => {
             bug!("comparison_op_to_fcmp_predicate: expected comparison operator, \
                   found {:?}",
@@ -197,7 +198,7 @@ pub fn unsized_info(
     let (source, target) = cx.tcx.struct_lockstep_tails(source, target);
     match (&source.sty, &target.sty) {
         (&ty::Array(_, len), &ty::Slice(_)) => {
-            C_usize(cx, len.unwrap_usize(cx.tcx))
+            CodegenCx::c_usize(cx, len.unwrap_usize(cx.tcx))
         }
         (&ty::Dynamic(..), &ty::Dynamic(..)) => {
             // For now, upcasts are limited to changes in marker
@@ -275,8 +276,8 @@ pub fn unsize_thin_ptr(
 /// to a value of type `dst_ty` and store the result in `dst`
 pub fn coerce_unsized_into(
     bx: &Builder<'a, 'll, 'tcx>,
-    src: PlaceRef<'ll, 'tcx>,
-    dst: PlaceRef<'ll, 'tcx>
+    src: PlaceRef<'tcx, &'ll Value>,
+    dst: PlaceRef<'tcx, &'ll Value>
 ) {
     let src_ty = src.layout.ty;
     let dst_ty = dst.layout.ty;
@@ -349,8 +350,8 @@ fn cast_shift_rhs<'ll, F, G>(op: hir::BinOpKind,
 {
     // Shifts may have any size int on the rhs
     if op.is_shift() {
-        let mut rhs_llty = val_ty(rhs);
-        let mut lhs_llty = val_ty(lhs);
+        let mut rhs_llty = CodegenCx::val_ty(rhs);
+        let mut lhs_llty = CodegenCx::val_ty(lhs);
         if rhs_llty.kind() == TypeKind::Vector {
             rhs_llty = rhs_llty.element_type()
         }
@@ -387,9 +388,12 @@ pub fn call_assume(bx: &Builder<'_, 'll, '_>, val: &'ll Value) {
     bx.call(assume_intrinsic, &[val], None);
 }
 
-pub fn from_immediate(bx: &Builder<'_, 'll, '_>, val: &'ll Value) -> &'ll Value {
-    if val_ty(val) == Type::i1(bx.cx) {
-        bx.zext(val, Type::i8(bx.cx))
+pub fn from_immediate<'a, 'll: 'a, 'tcx: 'll>(
+    bx: &Builder<'_ ,'ll, '_, &'ll Value>,
+    val: &'ll Value
+) -> &'ll Value {
+    if CodegenCx::val_ty(val) == Type::i1(bx.cx()) {
+        bx.zext(val, Type::i8(bx.cx()))
     } else {
         val
     }
@@ -417,8 +421,8 @@ pub fn to_immediate_scalar(
     val
 }
 
-pub fn call_memcpy(
-    bx: &Builder<'_, 'll, '_>,
+pub fn call_memcpy<'a, 'll: 'a, 'tcx: 'll>(
+    bx: &Builder<'_ ,'ll, '_, &'ll Value>,
     dst: &'ll Value,
     dst_align: Align,
     src: &'ll Value,
@@ -429,20 +433,20 @@ pub fn call_memcpy(
     if flags.contains(MemFlags::NONTEMPORAL) {
         // HACK(nox): This is inefficient but there is no nontemporal memcpy.
         let val = bx.load(src, src_align);
-        let ptr = bx.pointercast(dst, val_ty(val).ptr_to());
+        let ptr = bx.pointercast(dst, CodegenCx::val_ty(val).ptr_to());
         bx.store_with_flags(val, ptr, dst_align, flags);
         return;
     }
-    let cx = bx.cx;
+    let cx = bx.cx();
     let src_ptr = bx.pointercast(src, Type::i8p(cx));
     let dst_ptr = bx.pointercast(dst, Type::i8p(cx));
     let size = bx.intcast(n_bytes, cx.isize_ty, false);
     let volatile = flags.contains(MemFlags::VOLATILE);
     bx.memcpy(dst_ptr, dst_align.abi(), src_ptr, src_align.abi(), size, volatile);
 }
 
-pub fn memcpy_ty(
-    bx: &Builder<'_, 'll, 'tcx>,
+pub fn memcpy_ty<'a, 'll: 'a, 'tcx: 'll>(
+    bx: &Builder<'_ ,'ll, '_, &'ll Value>,
     dst: &'ll Value,
     dst_align: Align,
     src: &'ll Value,
@@ -455,7 +459,7 @@ pub fn memcpy_ty(
         return;
     }
 
-    call_memcpy(bx, dst, dst_align, src, src_align, C_usize(bx.cx, size), flags);
+    call_memcpy(bx, dst, dst_align, src, src_align, CodegenCx::c_usize(bx.cx(), size), flags);
 }
 
 pub fn call_memset(
@@ -469,7 +473,7 @@ pub fn call_memset(
     let ptr_width = &bx.cx.sess().target.target.target_pointer_width;
     let intrinsic_key = format!("llvm.memset.p0i8.i{}", ptr_width);
     let llintrinsicfn = bx.cx.get_intrinsic(&intrinsic_key);
-    let volatile = C_bool(bx.cx, volatile);
+    let volatile = CodegenCx::c_bool(bx.cx, volatile);
     bx.call(llintrinsicfn, &[ptr, fill_byte, size, align, volatile], None)
 }
 
@@ -545,7 +549,8 @@ fn maybe_create_entry_wrapper(cx: &CodegenCx) {
         rust_main_def_id: DefId,
         use_start_lang_item: bool,
     ) {
-        let llfty = Type::func(&[Type::c_int(cx), Type::i8p(cx).ptr_to()], Type::c_int(cx));
+        let llfty =
+            Type::func(&[Type::c_int(cx), Type::i8p(cx).ptr_to()], Type::c_int(cx));
 
         let main_ret_ty = cx.tcx.fn_sig(rust_main_def_id).output();
         // Given that `main()` has no arguments,
@@ -643,12 +648,12 @@ fn write_metadata<'a, 'gcx>(tcx: TyCtxt<'a, 'gcx, 'gcx>,
     DeflateEncoder::new(&mut compressed, Compression::fast())
         .write_all(&metadata.raw_data).unwrap();
 
-    let llmeta = C_bytes_in_context(metadata_llcx, &compressed);
-    let llconst = C_struct_in_context(metadata_llcx, &[llmeta], false);
+    let llmeta = CodegenCx::c_bytes_in_context(metadata_llcx, &compressed);
+    let llconst = CodegenCx::c_struct_in_context(metadata_llcx, &[llmeta], false);
     let name = exported_symbols::metadata_symbol_name(tcx);
     let buf = CString::new(name).unwrap();
     let llglobal = unsafe {
-        llvm::LLVMAddGlobal(metadata_llmod, val_ty(llconst), buf.as_ptr())
+        llvm::LLVMAddGlobal(metadata_llmod, CodegenCx::val_ty(llconst), buf.as_ptr())
     };
     unsafe {
         llvm::LLVMSetInitializer(llglobal, llconst);
@@ -1134,7 +1139,7 @@ fn compile_codegen_unit<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
             // Run replace-all-uses-with for statics that need it
             for &(old_g, new_g) in cx.statics_to_rauw.borrow().iter() {
                 unsafe {
-                    let bitcast = llvm::LLVMConstPointerCast(new_g, val_ty(old_g));
+                    let bitcast = llvm::LLVMConstPointerCast(new_g, CodegenCx::val_ty(old_g));
                     llvm::LLVMReplaceAllUsesWith(old_g, bitcast);
                     llvm::LLVMDeleteGlobal(old_g);
                 }
@@ -1145,11 +1150,11 @@ fn compile_codegen_unit<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
             if !cx.used_statics.borrow().is_empty() {
                 let name = const_cstr!("llvm.used");
                 let section = const_cstr!("llvm.metadata");
-                let array = C_array(Type::i8(&cx).ptr_to(), &*cx.used_statics.borrow());
+                let array = CodegenCx::c_array(Type::i8(&cx).ptr_to(), &*cx.used_statics.borrow());
 
                 unsafe {
                     let g = llvm::LLVMAddGlobal(cx.llmod,
-                                                val_ty(array),
+                                                CodegenCx::val_ty(array),
                                                 name.as_ptr());
                     llvm::LLVMSetInitializer(g, array);
                     llvm::LLVMRustSetLinkage(g, llvm::Linkage::AppendingLinkage);