Traitification of type_ methods

The methods are now attached to CodegenCx instead of Type

Author: denismerigoux

src/librustc_codegen_llvm/abi.rs

@@ -19,7 +19,7 @@ use type_::Type;
 use type_of::{LayoutLlvmExt, PointerKind};
 use value::Value;
 
-use interfaces::{BuilderMethods, CommonMethods};
+use interfaces::{BuilderMethods, CommonMethods, TypeMethods};
 
 use rustc_target::abi::{LayoutOf, Size, TyLayout};
 use rustc::ty::{self, Ty};
@@ -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 => Type::ix(cx, self.size.bits()),
+            RegKind::Integer => cx.ix(self.size.bits()),
             RegKind::Float => {
                 match self.size.bits() {
-                    32 => Type::f32(cx),
-                    64 => Type::f64(cx),
+                    32 => cx.f32(),
+                    64 => cx.f64(),
                     _ => bug!("unsupported float: {:?}", self)
                 }
             }
             RegKind::Vector => {
-                Type::vector(Type::i8(cx), self.size.bytes())
+                cx.vector(cx.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 Type::array(rest_ll_unit, rest_count);
+                return cx.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(Type::ix(cx, rem_bytes * 8));
+            args.push(cx.ix(rem_bytes * 8));
         }
 
-        Type::struct_(cx, &args, false)
+        cx.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, cast.llvm_type(cx).ptr_to());
+                let cast_dst = bx.pointercast(dst.llval, cx.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, Type::i8p(cx)),
-                                  bx.pointercast(llscratch, Type::i8p(cx)),
+                                  bx.pointercast(dst.llval, cx.i8p()),
+                                  bx.pointercast(llscratch, cx.i8p()),
                                   cx.c_usize(self.layout.size.bytes()),
                                   self.layout.align.min(scratch_align),
                                   MemFlags::empty());
@@ -605,14 +605,14 @@ impl<'tcx> FnTypeExt<'tcx> for FnType<'tcx, Ty<'tcx>> {
         );
 
         let llreturn_ty = match self.ret.mode {
-            PassMode::Ignore => Type::void(cx),
+            PassMode::Ignore => cx.void(),
             PassMode::Direct(_) | PassMode::Pair(..) => {
                 self.ret.layout.immediate_llvm_type(cx)
             }
             PassMode::Cast(cast) => cast.llvm_type(cx),
             PassMode::Indirect(..) => {
-                llargument_tys.push(self.ret.memory_ty(cx).ptr_to());
-                Type::void(cx)
+                llargument_tys.push(cx.ptr_to(self.ret.memory_ty(cx)));
+                cx.void()
             }
         };
 
@@ -638,15 +638,15 @@ impl<'tcx> FnTypeExt<'tcx> for FnType<'tcx, Ty<'tcx>> {
                     continue;
                 }
                 PassMode::Cast(cast) => cast.llvm_type(cx),
-                PassMode::Indirect(_, None) => arg.memory_ty(cx).ptr_to(),
+                PassMode::Indirect(_, None) => cx.ptr_to(arg.memory_ty(cx)),
             };
             llargument_tys.push(llarg_ty);
         }
 
         if self.variadic {
-            Type::variadic_func(&llargument_tys, llreturn_ty)
+            cx.variadic_func(&llargument_tys, llreturn_ty)
         } else {
-            Type::func(&llargument_tys, llreturn_ty)
+            cx.func(&llargument_tys, llreturn_ty)
         }
     }
 

src/librustc_codegen_llvm/asm.rs

@@ -10,13 +10,12 @@
 
 use llvm;
 use context::CodegenCx;
-use type_::Type;
 use type_of::LayoutLlvmExt;
 use builder::Builder;
 use value::Value;
 
 use rustc::hir;
-use interfaces::{BuilderMethods, CommonMethods};
+use interfaces::{BuilderMethods, CommonMethods, TypeMethods};
 
 use mir::place::PlaceRef;
 use mir::operand::OperandValue;
@@ -76,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 => Type::void(bx.cx()),
+        0 => bx.cx().void(),
         1 => output_types[0],
-        _ => Type::struct_(bx.cx(), &output_types, false)
+        _ => bx.cx().struct_(&output_types, false)
     };
 
     let asm = CString::new(ia.asm.as_str().as_bytes()).unwrap();

src/librustc_codegen_llvm/back/write.rs

@@ -452,6 +452,14 @@ impl CommonWriteMethods for CodegenContext<'ll> {
     }
 }
 
+impl CodegenContext<'ll> {
+    pub fn ptr_to(&self, ty: &'ll Type) -> &'ll Type {
+        unsafe {
+            llvm::LLVMPointerType(ty, 0)
+        }
+    }
+}
+
 
 pub struct DiagnosticHandlers<'a> {
     data: *mut (&'a CodegenContext<'a>, &'a Handler),
@@ -2579,7 +2587,7 @@ fn create_msvc_imps(cgcx: &CodegenContext, llcx: &llvm::Context, llmod: &llvm::M
         "\x01__imp_"
     };
     unsafe {
-        let i8p_ty = Type::i8p_llcx(llcx);
+        let i8p_ty = Type::i8p_llcx(cgcx, llcx);
         let globals = base::iter_globals(llmod)
             .filter(|&val| {
                 llvm::LLVMRustGetLinkage(val) == llvm::Linkage::ExternalLinkage &&

src/librustc_codegen_llvm/base.rs

@@ -74,7 +74,7 @@ use CrateInfo;
 use rustc_data_structures::small_c_str::SmallCStr;
 use rustc_data_structures::sync::Lrc;
 
-use interfaces::{BuilderMethods, CommonMethods, CommonWriteMethods};
+use interfaces::{BuilderMethods, CommonMethods, CommonWriteMethods, TypeMethods};
 
 use std::any::Any;
 use std::ffi::CString;
@@ -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().layout_of(b).llvm_type(bx.cx()).ptr_to();
+            let ptr_ty = bx.cx().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().layout_of(b).llvm_type(bx.cx()).ptr_to();
+            let ptr_ty = bx.cx().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,14 +354,14 @@ 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 rhs_llty.kind() == TypeKind::Vector {
-            rhs_llty = rhs_llty.element_type()
+        if bx.cx().kind(rhs_llty) == TypeKind::Vector {
+            rhs_llty = bx.cx().element_type(rhs_llty)
         }
-        if lhs_llty.kind() == TypeKind::Vector {
-            lhs_llty = lhs_llty.element_type()
+        if bx.cx().kind(lhs_llty) == TypeKind::Vector {
+            lhs_llty = bx.cx().element_type(lhs_llty)
         }
-        let rhs_sz = rhs_llty.int_width();
-        let lhs_sz = lhs_llty.int_width();
+        let rhs_sz = bx.cx().int_width(rhs_llty);
+        let lhs_sz = bx.cx().int_width(lhs_llty);
         if lhs_sz < rhs_sz {
             trunc(rhs, lhs_llty)
         } else if lhs_sz > rhs_sz {
@@ -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) == Type::i1(bx.cx()) {
-        bx.zext(val, Type::i8(bx.cx()))
+    if bx.cx().val_ty(val) == bx.cx().i1() {
+        bx.zext(val, bx.cx().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, Type::i1(bx.cx()));
+        return bx.trunc(val, bx.cx().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().val_ty(val).ptr_to());
+        let ptr = bx.pointercast(dst, bx.cx().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, Type::i8p(cx));
-    let dst_ptr = bx.pointercast(dst, Type::i8p(cx));
+    let src_ptr = bx.pointercast(src, cx.i8p());
+    let dst_ptr = bx.pointercast(dst, cx.i8p());
     let size = bx.intcast(n_bytes, cx.isize_ty, false);
     let align = cx.c_i32(align.abi() as i32);
     let volatile = cx.c_bool(flags.contains(MemFlags::VOLATILE));
@@ -557,7 +557,7 @@ fn maybe_create_entry_wrapper(cx: &CodegenCx<'ll, '_, &'ll Value>) {
         use_start_lang_item: bool,
     ) {
         let llfty =
-            Type::func(&[Type::c_int(cx), Type::i8p(cx).ptr_to()], Type::c_int(cx));
+            cx.func(&[cx.t_int(), cx.ptr_to(cx.i8p())], cx.t_int());
 
         let main_ret_ty = cx.tcx.fn_sig(rust_main_def_id).output();
         // Given that `main()` has no arguments,
@@ -600,15 +600,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, Type::i8p(cx).ptr_to()),
+            (start_fn, vec![bx.pointercast(rust_main, cx.ptr_to(cx.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, Type::c_int(cx), true));
+        bx.ret(bx.intcast(result, cx.t_int(), true));
     }
 }
 
@@ -1247,7 +1247,7 @@ 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.c_array(Type::i8(&cx).ptr_to(), &*cx.used_statics.borrow());
+                let array = cx.c_array(&cx.ptr_to(cx.i8()), &*cx.used_statics.borrow());
 
                 unsafe {
                     let g = llvm::LLVMAddGlobal(cx.llmod,

src/librustc_codegen_llvm/builder.rs

@@ -19,7 +19,7 @@ use rustc::ty::TyCtxt;
 use rustc::ty::layout::{Align, Size};
 use rustc::session::{config, Session};
 use rustc_data_structures::small_c_str::SmallCStr;
-use interfaces::{BuilderMethods, Backend, CommonMethods, CommonWriteMethods};
+use interfaces::{BuilderMethods, Backend, CommonMethods, CommonWriteMethods, TypeMethods};
 use syntax;
 
 use std::borrow::Cow;
@@ -786,7 +786,7 @@ impl BuilderMethods<'a, 'll, 'tcx>
         }).collect::<Vec<_>>();
 
         debug!("Asm Output Type: {:?}", output);
-        let fty = type_::Type::func(&argtys[..], output);
+        let fty = &self.cx().func(&argtys[..], output);
         unsafe {
             // Ask LLVM to verify that the constraints are well-formed.
             let constraints_ok = llvm::LLVMRustInlineAsmVerify(fty, cons);
@@ -864,10 +864,10 @@ 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(type_::Type::vector(elt_ty, num_elts as u64));
+            let undef = llvm::LLVMGetUndef(&self.cx().vector(elt_ty, num_elts as u64));
             let vec = self.insert_element(undef, elt, self.cx.c_i32(0));
-            let vec_i32_ty = type_::Type::vector(type_::Type::i32(self.cx), num_elts as u64);
-            self.shuffle_vector(vec, undef, self.cx.c_null(vec_i32_ty))
+            let vec_i32_ty = &self.cx().vector(&self.cx().i32(), num_elts as u64);
+            self.shuffle_vector(vec, undef, self.cx().c_null(vec_i32_ty))
         }
     }
 
@@ -1176,9 +1176,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 = stored_ty.ptr_to();
+        let stored_ptr_ty = self.cx.ptr_to(stored_ty);
 
-        assert_eq!(dest_ptr_ty.kind(), llvm::TypeKind::Pointer);
+        assert_eq!(self.cx.kind(dest_ptr_ty), llvm::TypeKind::Pointer);
 
         if dest_ptr_ty == stored_ptr_ty {
             ptr
@@ -1197,14 +1197,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 fn_ty.kind() == llvm::TypeKind::Pointer {
-            fn_ty = fn_ty.element_type();
+        while self.cx.kind(fn_ty) == llvm::TypeKind::Pointer {
+            fn_ty = self.cx.element_type(fn_ty);
         }
 
-        assert!(fn_ty.kind() == llvm::TypeKind::Function,
+        assert!(self.cx.kind(fn_ty) == llvm::TypeKind::Function,
                 "builder::{} not passed a function, but {:?}", typ, fn_ty);
 
-        let param_tys = fn_ty.func_params();
+        let param_tys = self.cx.func_params(fn_ty);
 
         let all_args_match = param_tys.iter()
             .zip(args.iter().map(|&v| self.cx().val_ty(v)))
@@ -1261,7 +1261,7 @@ impl BuilderMethods<'a, 'll, 'tcx>
 
         let lifetime_intrinsic = self.cx.get_intrinsic(intrinsic);
 
-        let ptr = self.pointercast(ptr, type_::Type::i8p(self.cx));
+        let ptr = self.pointercast(ptr, self.cx.i8p());
         self.call(lifetime_intrinsic, &[self.cx.c_u64(size), ptr], None);
     }