Prefixed type methods & removed trait impl for write::CodegenContext

Author: denismerigoux

src/librustc_codegen_llvm/abi.rs

@@ -112,16 +112,16 @@ pub trait LlvmType {
 impl LlvmType for Reg {
     fn llvm_type(&self, cx: &CodegenCx<'ll, '_, &'ll Value>) -> &'ll Type {
         match self.kind {
-            RegKind::Integer => cx.ix(self.size.bits()),
+            RegKind::Integer => cx.type_ix(self.size.bits()),
             RegKind::Float => {
                 match self.size.bits() {
-                    32 => cx.f32(),
-                    64 => cx.f64(),
+                    32 => cx.type_f32(),
+                    64 => cx.type_f64(),
                     _ => bug!("unsupported float: {:?}", self)
                 }
             }
             RegKind::Vector => {
-                cx.vector(cx.i8(), self.size.bytes())
+                cx.type_vector(cx.type_i8(), self.size.bytes())
             }
         }
     }
@@ -145,7 +145,7 @@ impl LlvmType for CastTarget {
 
             // Simplify to array when all chunks are the same size and type
             if rem_bytes == 0 {
-                return cx.array(rest_ll_unit, rest_count);
+                return cx.type_array(rest_ll_unit, rest_count);
             }
         }
 
@@ -160,10 +160,10 @@ impl LlvmType for CastTarget {
         if rem_bytes != 0 {
             // Only integers can be really split further.
             assert_eq!(self.rest.unit.kind, RegKind::Integer);
-            args.push(cx.ix(rem_bytes * 8));
+            args.push(cx.type_ix(rem_bytes * 8));
         }
 
-        cx.struct_(&args, false)
+        cx.type_struct(&args, false)
     }
 }
 
@@ -212,7 +212,7 @@ impl ArgTypeExt<'ll, 'tcx> for ArgType<'tcx, Ty<'tcx>> {
             // uses it for i16 -> {i8, i8}, but not for i24 -> {i8, i8, i8}.
             let can_store_through_cast_ptr = false;
             if can_store_through_cast_ptr {
-                let cast_dst = bx.pointercast(dst.llval, cx.ptr_to(cast.llvm_type(cx)));
+                let cast_dst = bx.pointercast(dst.llval, cx.type_ptr_to(cast.llvm_type(cx)));
                 bx.store(val, cast_dst, self.layout.align);
             } else {
                 // The actual return type is a struct, but the ABI
@@ -240,8 +240,8 @@ impl ArgTypeExt<'ll, 'tcx> for ArgType<'tcx, Ty<'tcx>> {
 
                 // ...and then memcpy it to the intended destination.
                 base::call_memcpy(bx,
-                                  bx.pointercast(dst.llval, cx.i8p()),
-                                  bx.pointercast(llscratch, cx.i8p()),
+                                  bx.pointercast(dst.llval, cx.type_i8p()),
+                                  bx.pointercast(llscratch, cx.type_i8p()),
                                   cx.const_usize(self.layout.size.bytes()),
                                   self.layout.align.min(scratch_align),
                                   MemFlags::empty());
@@ -633,14 +633,14 @@ impl<'tcx> FnTypeExt<'tcx> for FnType<'tcx, Ty<'tcx>> {
         );
 
         let llreturn_ty = match self.ret.mode {
-            PassMode::Ignore => cx.void(),
+            PassMode::Ignore => cx.type_void(),
             PassMode::Direct(_) | PassMode::Pair(..) => {
                 self.ret.layout.immediate_llvm_type(cx)
             }
             PassMode::Cast(cast) => cast.llvm_type(cx),
             PassMode::Indirect(..) => {
-                llargument_tys.push(cx.ptr_to(self.ret.memory_ty(cx)));
-                cx.void()
+                llargument_tys.push(cx.type_ptr_to(self.ret.memory_ty(cx)));
+                cx.type_void()
             }
         };
 
@@ -666,15 +666,15 @@ impl<'tcx> FnTypeExt<'tcx> for FnType<'tcx, Ty<'tcx>> {
                     continue;
                 }
                 PassMode::Cast(cast) => cast.llvm_type(cx),
-                PassMode::Indirect(_, None) => cx.ptr_to(arg.memory_ty(cx)),
+                PassMode::Indirect(_, None) => cx.type_ptr_to(arg.memory_ty(cx)),
             };
             llargument_tys.push(llarg_ty);
         }
 
         if self.variadic {
-            cx.variadic_func(&llargument_tys, llreturn_ty)
+            cx.type_variadic_func(&llargument_tys, llreturn_ty)
         } else {
-            cx.func(&llargument_tys, llreturn_ty)
+            cx.type_func(&llargument_tys, llreturn_ty)
         }
     }
 

src/librustc_codegen_llvm/asm.rs

@@ -75,9 +75,9 @@ pub fn codegen_inline_asm(
     // Depending on how many outputs we have, the return type is different
     let num_outputs = output_types.len();
     let output_type = match num_outputs {
-        0 => bx.cx().void(),
+        0 => bx.cx().type_void(),
         1 => output_types[0],
-        _ => bx.cx().struct_(&output_types, false)
+        _ => bx.cx().type_struct(&output_types, false)
     };
 
     let asm = CString::new(ia.asm.as_str().as_bytes()).unwrap();

src/librustc_codegen_llvm/back/write.rs

@@ -24,7 +24,7 @@ use rustc::session::config::{self, OutputFilenames, OutputType, Passes, Sanitize
 use rustc::session::Session;
 use rustc::util::nodemap::FxHashMap;
 use time_graph::{self, TimeGraph, Timeline};
-use llvm::{self, DiagnosticInfo, PassManager, SMDiagnostic, BasicBlock};
+use llvm::{self, DiagnosticInfo, PassManager, SMDiagnostic};
 use llvm_util;
 use {CodegenResults, ModuleCodegen, CompiledModule, ModuleKind, // ModuleLlvm,
      CachedModuleCodegen};
@@ -46,7 +46,6 @@ use syntax_pos::MultiSpan;
 use syntax_pos::symbol::Symbol;
 use type_::Type;
 use context::{is_pie_binary, get_reloc_model};
-use interfaces::{Backend, CommonWriteMethods};
 use common;
 use jobserver::{Client, Acquired};
 use rustc_demangle;
@@ -425,15 +424,8 @@ impl CodegenContext<'ll> {
     }
 }
 
-impl<'ll> Backend for CodegenContext<'ll> {
-    type Value = &'ll Value;
-    type BasicBlock = &'ll BasicBlock;
-    type Type = &'ll Type;
-    type Context = &'ll llvm::Context;
-    type TypeKind = llvm::TypeKind;
-}
 
-impl CommonWriteMethods for CodegenContext<'ll> {
+impl CodegenContext<'ll> {
     fn val_ty(&self, v: &'ll Value) -> &'ll Type {
         common::val_ty(v)
     }
@@ -442,18 +434,7 @@ impl CommonWriteMethods for CodegenContext<'ll> {
         common::const_bytes_in_context(llcx, bytes)
     }
 
-    fn const_struct_in_context(
-        &self,
-        llcx: &'a llvm::Context,
-        elts: &[&'a Value],
-        packed: bool,
-    ) -> &'a Value {
-        common::const_struct_in_context(llcx, elts, packed)
-    }
-}
-
-impl CodegenContext<'ll> {
-    pub fn ptr_to(&self, ty: &'ll Type) -> &'ll Type {
+    pub fn type_ptr_to(&self, ty: &'ll Type) -> &'ll Type {
         unsafe {
             llvm::LLVMPointerType(ty, 0)
         }

src/librustc_codegen_llvm/base.rs

@@ -235,13 +235,13 @@ pub fn unsize_thin_ptr(
         (&ty::RawPtr(ty::TypeAndMut { ty: a, .. }),
          &ty::RawPtr(ty::TypeAndMut { ty: b, .. })) => {
             assert!(bx.cx().type_is_sized(a));
-            let ptr_ty = bx.cx().ptr_to(bx.cx().layout_of(b).llvm_type(bx.cx()));
+            let ptr_ty = bx.cx().type_ptr_to(bx.cx().layout_of(b).llvm_type(bx.cx()));
             (bx.pointercast(src, ptr_ty), unsized_info(bx.cx(), a, b, None))
         }
         (&ty::Adt(def_a, _), &ty::Adt(def_b, _)) if def_a.is_box() && def_b.is_box() => {
             let (a, b) = (src_ty.boxed_ty(), dst_ty.boxed_ty());
             assert!(bx.cx().type_is_sized(a));
-            let ptr_ty = bx.cx().ptr_to(bx.cx().layout_of(b).llvm_type(bx.cx()));
+            let ptr_ty = bx.cx().type_ptr_to(bx.cx().layout_of(b).llvm_type(bx.cx()));
             (bx.pointercast(src, ptr_ty), unsized_info(bx.cx(), a, b, None))
         }
         (&ty::Adt(def_a, _), &ty::Adt(def_b, _)) => {
@@ -354,10 +354,10 @@ fn cast_shift_rhs<'ll, F, G>(bx: &Builder<'_, 'll, '_, &'ll Value>,
     if op.is_shift() {
         let mut rhs_llty = bx.cx().val_ty(rhs);
         let mut lhs_llty = bx.cx().val_ty(lhs);
-        if bx.cx().kind(rhs_llty) == TypeKind::Vector {
+        if bx.cx().type_kind(rhs_llty) == TypeKind::Vector {
             rhs_llty = bx.cx().element_type(rhs_llty)
         }
-        if bx.cx().kind(lhs_llty) == TypeKind::Vector {
+        if bx.cx().type_kind(lhs_llty) == TypeKind::Vector {
             lhs_llty = bx.cx().element_type(lhs_llty)
         }
         let rhs_sz = bx.cx().int_width(rhs_llty);
@@ -394,8 +394,8 @@ pub fn from_immediate<'a, 'll: 'a, 'tcx: 'll>(
     bx: &Builder<'_ ,'ll, '_, &'ll Value>,
     val: &'ll Value
 ) -> &'ll Value {
-    if bx.cx().val_ty(val) == bx.cx().i1() {
-        bx.zext(val, bx.cx().i8())
+    if bx.cx().val_ty(val) == bx.cx().type_i1() {
+        bx.zext(val, bx.cx().type_i8())
     } else {
         val
     }
@@ -418,7 +418,7 @@ pub fn to_immediate_scalar(
     scalar: &layout::Scalar,
 ) -> &'ll Value {
     if scalar.is_bool() {
-        return bx.trunc(val, bx.cx().i1());
+        return bx.trunc(val, bx.cx().type_i1());
     }
     val
 }
@@ -434,16 +434,16 @@ pub fn call_memcpy<'a, 'll: 'a, 'tcx: 'll>(
     if flags.contains(MemFlags::NONTEMPORAL) {
         // HACK(nox): This is inefficient but there is no nontemporal memcpy.
         let val = bx.load(src, align);
-        let ptr = bx.pointercast(dst, bx.cx().ptr_to(bx.cx().val_ty(val)));
+        let ptr = bx.pointercast(dst, bx.cx().type_ptr_to(bx.cx().val_ty(val)));
         bx.store_with_flags(val, ptr, align, flags);
         return;
     }
     let cx = bx.cx();
     let ptr_width = &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 = bx.pointercast(src, cx.i8p());
-    let dst_ptr = bx.pointercast(dst, cx.i8p());
+    let src_ptr = bx.pointercast(src, cx.type_i8p());
+    let dst_ptr = bx.pointercast(dst, cx.type_i8p());
     let size = bx.intcast(n_bytes, cx.isize_ty, false);
     let align = cx.const_i32(align.abi() as i32);
     let volatile = cx.const_bool(flags.contains(MemFlags::VOLATILE));
@@ -554,7 +554,7 @@ fn maybe_create_entry_wrapper(cx: &CodegenCx<'ll, '_, &'ll Value>) {
         use_start_lang_item: bool,
     ) {
         let llfty =
-            cx.func(&[cx.t_int(), cx.ptr_to(cx.i8p())], cx.t_int());
+            cx.type_func(&[cx.type_int(), cx.type_ptr_to(cx.type_i8p())], cx.type_int());
 
         let main_ret_ty = cx.tcx.fn_sig(rust_main_def_id).output();
         // Given that `main()` has no arguments,
@@ -597,15 +597,15 @@ fn maybe_create_entry_wrapper(cx: &CodegenCx<'ll, '_, &'ll Value>) {
                 start_def_id,
                 cx.tcx.intern_substs(&[main_ret_ty.into()]),
             );
-            (start_fn, vec![bx.pointercast(rust_main, cx.ptr_to(cx.i8p())),
+            (start_fn, vec![bx.pointercast(rust_main, cx.type_ptr_to(cx.type_i8p())),
                             arg_argc, arg_argv])
         } else {
             debug!("using user-defined start fn");
             (rust_main, vec![arg_argc, arg_argv])
         };
 
         let result = bx.call(start_fn, &args, None);
-        bx.ret(bx.intcast(result, cx.t_int(), true));
+        bx.ret(bx.intcast(result, cx.type_int(), true));
     }
 }
 
@@ -1154,7 +1154,10 @@ 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 = cx.const_array(&cx.ptr_to(cx.i8()), &*cx.used_statics.borrow());
+                let array = cx.const_array(
+                    &cx.type_ptr_to(cx.type_i8()),
+                    &*cx.used_statics.borrow()
+                );
 
                 unsafe {
                     let g = llvm::LLVMAddGlobal(cx.llmod,

src/librustc_codegen_llvm/builder.rs

@@ -783,7 +783,7 @@ impl BuilderMethods<'a, 'll, 'tcx>
         }).collect::<Vec<_>>();
 
         debug!("Asm Output Type: {:?}", output);
-        let fty = &self.cx().func(&argtys[..], output);
+        let fty = &self.cx().type_func(&argtys[..], output);
         unsafe {
             // Ask LLVM to verify that the constraints are well-formed.
             let constraints_ok = llvm::LLVMRustInlineAsmVerify(fty, cons);
@@ -861,9 +861,9 @@ impl BuilderMethods<'a, 'll, 'tcx>
     fn vector_splat(&self, num_elts: usize, elt: &'ll Value) -> &'ll Value {
         unsafe {
             let elt_ty = self.cx.val_ty(elt);
-            let undef = llvm::LLVMGetUndef(&self.cx().vector(elt_ty, num_elts as u64));
+            let undef = llvm::LLVMGetUndef(&self.cx().type_vector(elt_ty, num_elts as u64));
             let vec = self.insert_element(undef, elt, self.cx.const_i32(0));
-            let vec_i32_ty = &self.cx().vector(&self.cx().i32(), num_elts as u64);
+            let vec_i32_ty = &self.cx().type_vector(&self.cx().type_i32(), num_elts as u64);
             self.shuffle_vector(vec, undef, self.cx().const_null(vec_i32_ty))
         }
     }
@@ -1173,9 +1173,9 @@ impl BuilderMethods<'a, 'll, 'tcx>
                        ptr: &'ll Value) -> &'ll Value {
         let dest_ptr_ty = self.cx.val_ty(ptr);
         let stored_ty = self.cx.val_ty(val);
-        let stored_ptr_ty = self.cx.ptr_to(stored_ty);
+        let stored_ptr_ty = self.cx.type_ptr_to(stored_ty);
 
-        assert_eq!(self.cx.kind(dest_ptr_ty), llvm::TypeKind::Pointer);
+        assert_eq!(self.cx.type_kind(dest_ptr_ty), llvm::TypeKind::Pointer);
 
         if dest_ptr_ty == stored_ptr_ty {
             ptr
@@ -1194,14 +1194,14 @@ impl BuilderMethods<'a, 'll, 'tcx>
                       args: &'b [&'ll Value]) -> Cow<'b, [&'ll Value]> {
         let mut fn_ty = self.cx.val_ty(llfn);
         // Strip off pointers
-        while self.cx.kind(fn_ty) == llvm::TypeKind::Pointer {
+        while self.cx.type_kind(fn_ty) == llvm::TypeKind::Pointer {
             fn_ty = self.cx.element_type(fn_ty);
         }
 
-        assert!(self.cx.kind(fn_ty) == llvm::TypeKind::Function,
+        assert!(self.cx.type_kind(fn_ty) == llvm::TypeKind::Function,
                 "builder::{} not passed a function, but {:?}", typ, fn_ty);
 
-        let param_tys = self.cx.func_params(fn_ty);
+        let param_tys = self.cx.func_params_types(fn_ty);
 
         let all_args_match = param_tys.iter()
             .zip(args.iter().map(|&v| self.cx().val_ty(v)))
@@ -1258,7 +1258,7 @@ impl BuilderMethods<'a, 'll, 'tcx>
 
         let lifetime_intrinsic = self.cx.get_intrinsic(intrinsic);
 
-        let ptr = self.pointercast(ptr, self.cx.i8p());
+        let ptr = self.pointercast(ptr, self.cx.type_i8p());
         self.call(lifetime_intrinsic, &[self.cx.const_u64(size), ptr], None);
     }
 

src/librustc_codegen_llvm/common.rs

@@ -236,19 +236,19 @@ impl<'ll, 'tcx : 'll> CommonMethods for CodegenCx<'ll, 'tcx, &'ll Value> {
     }
 
     fn const_bool(&self, val: bool) -> &'ll Value {
-        &self.const_uint(&self.i1(), val as u64)
+        &self.const_uint(&self.type_i1(), val as u64)
     }
 
     fn const_i32(&self, i: i32) -> &'ll Value {
-        &self.const_int(&self.i32(), i as i64)
+        &self.const_int(&self.type_i32(), i as i64)
     }
 
     fn const_u32(&self, i: u32) -> &'ll Value {
-        &self.const_uint(&self.i32(), i as u64)
+        &self.const_uint(&self.type_i32(), i as u64)
     }
 
     fn const_u64(&self, i: u64) -> &'ll Value {
-        &self.const_uint(&self.i64(), i)
+        &self.const_uint(&self.type_i64(), i)
     }
 
     fn const_usize(&self, i: u64) -> &'ll Value {
@@ -262,7 +262,7 @@ impl<'ll, 'tcx : 'll> CommonMethods for CodegenCx<'ll, 'tcx, &'ll Value> {
     }
 
     fn const_u8(&self, i: u8) -> &'ll Value {
-        &self.const_uint(&self.i8(), i as u64)
+        &self.const_uint(&self.type_i8(), i as u64)
     }
 
 
@@ -300,7 +300,7 @@ impl<'ll, 'tcx : 'll> CommonMethods for CodegenCx<'ll, 'tcx, &'ll Value> {
     fn const_str_slice(&self, s: LocalInternedString) -> &'ll Value {
         let len = s.len();
         let cs = consts::ptrcast(&self.const_cstr(s, false),
-            &self.ptr_to(&self.layout_of(&self.tcx.mk_str()).llvm_type(&self)));
+            &self.type_ptr_to(&self.layout_of(&self.tcx.mk_str()).llvm_type(&self)));
         &self.const_fat_ptr(cs, &self.const_usize(len as u64))
     }
 
@@ -505,7 +505,7 @@ pub fn shift_mask_val(
     mask_llty: &'ll Type,
     invert: bool
 ) -> &'ll Value {
-    let kind = bx.cx().kind(llty);
+    let kind = bx.cx().type_kind(llty);
     match kind {
         TypeKind::Integer => {
             // i8/u8 can shift by at most 7, i16/u16 by at most 15, etc.