Added default impl for DerivedTypeMethods + empty impl for Cranelift BaseTypeMethods

Author: denismerigoux

src/librustc_codegen_llvm/abi.rs

@@ -325,7 +325,11 @@ pub trait FnTypeExt<'tcx> {
     fn llvm_type(&self, cx: &CodegenCx<'ll, 'tcx, &'ll Value>) -> &'ll Type;
     fn llvm_cconv(&self) -> llvm::CallConv;
     fn apply_attrs_llfn(&self, llfn: &'ll Value);
-    fn apply_attrs_callsite(&self, bx: &mut Builder<'a, 'll, 'tcx, &'ll Value>, callsite: &'ll Value);
+    fn apply_attrs_callsite(
+        &self,
+        bx: &mut Builder<'a, 'll, 'tcx, &'ll Value>,
+        callsite: &'ll Value
+    );
 }
 
 impl<'tcx> FnTypeExt<'tcx> for FnType<'tcx, Ty<'tcx>> {
@@ -728,7 +732,11 @@ impl<'tcx> FnTypeExt<'tcx> for FnType<'tcx, Ty<'tcx>> {
         }
     }
 
-    fn apply_attrs_callsite(&self, bx: &mut Builder<'a, 'll, 'tcx, &'ll Value>, callsite: &'ll Value) {
+    fn apply_attrs_callsite(
+        &self,
+        bx: &mut Builder<'a, 'll, 'tcx, &'ll Value>,
+        callsite: &'ll Value
+    ) {
         let mut i = 0;
         let mut apply = |attrs: &ArgAttributes| {
             attrs.apply_callsite(llvm::AttributePlace::Argument(i), callsite);

src/librustc_codegen_llvm/context.rs

@@ -470,7 +470,7 @@ impl MiscMethods<'ll, 'tcx> for CodegenCx<'ll, 'tcx, &'ll Value> {
     }
 }
 
-impl<'ll, 'tcx: 'll> CodegenMethods<'ll, 'tcx> for CodegenCx<'ll, 'tcx, &'ll Value> {}
+impl<'a, 'll: 'a, 'tcx: 'll> CodegenMethods<'a, 'll, 'tcx> for CodegenCx<'ll, 'tcx, &'ll Value> {}
 
 impl IntrinsicDeclarationMethods<'b> for CodegenCx<'b, 'tcx, &'b Value> {
     fn get_intrinsic(&self, key: &str) -> &'b Value {

src/librustc_codegen_llvm/debuginfo/gdb.rs

@@ -23,7 +23,9 @@ use syntax::attr;
 
 /// Inserts a side-effect free instruction sequence that makes sure that the
 /// .debug_gdb_scripts global is referenced, so it isn't removed by the linker.
-pub fn insert_reference_to_gdb_debug_scripts_section_global(bx: &mut Builder<'_, 'll, '_, &'ll Value>) {
+pub fn insert_reference_to_gdb_debug_scripts_section_global(
+    bx: &mut Builder<'_, 'll, '_, &'ll Value>
+) {
     if needs_gdb_debug_scripts_section(bx.cx()) {
         let gdb_debug_scripts_section = get_or_insert_gdb_debug_scripts_section_global(bx.cx());
         // Load just the first byte as that's all that's necessary to force

src/librustc_codegen_llvm/type_.rs

@@ -18,16 +18,12 @@ use context::CodegenCx;
 use value::Value;
 use rustc_codegen_ssa::interfaces::*;
 
-
-use syntax::ast;
-use rustc::ty::layout::{self, Align, Size};
 use rustc::util::nodemap::FxHashMap;
-use rustc::ty::{self, Ty, TyCtxt};
+use rustc::ty::{Ty, TyCtxt};
 use rustc::ty::layout::TyLayout;
 use rustc_target::abi::call::{CastTarget, FnType, Reg};
 use rustc_data_structures::small_c_str::SmallCStr;
 use common;
-use rustc_codegen_ssa;
 use rustc_codegen_ssa::common::TypeKind;
 use type_of::LayoutLlvmExt;
 use abi::{LlvmType, FnTypeExt};
@@ -111,6 +107,10 @@ impl BaseTypeMethods<'ll, 'tcx> for CodegenCx<'ll, 'tcx, &'ll Value> {
         }
     }
 
+    fn type_isize(&self) -> &'ll Type {
+        self.isize_ty
+    }
+
     fn type_f32(&self) -> &'ll Type {
         unsafe {
             llvm::LLVMFloatTypeInContext(&self.llcx)
@@ -279,126 +279,8 @@ impl Type {
     }
 }
 
-impl DerivedTypeMethods<'ll, 'tcx> for CodegenCx<'ll, 'tcx, &'ll Value> {
-
-    fn type_bool(&self) -> &'ll Type {
-        &self.type_i8()
-    }
-
-    fn type_char(&self) -> &'ll Type {
-        &self.type_i32()
-    }
-
-    fn type_i8p(&self) -> &'ll Type {
-        &self.type_ptr_to(&self.type_i8())
-    }
-
-    fn type_isize(&self) -> &'ll Type {
-        &self.isize_ty
-    }
-
-    fn type_int(&self) -> &'ll Type {
-        match &self.sess().target.target.target_c_int_width[..] {
-            "16" => &self.type_i16(),
-            "32" => &self.type_i32(),
-            "64" => &self.type_i64(),
-            width => bug!("Unsupported target_c_int_width: {}", width),
-        }
-    }
-
-    fn type_int_from_ty(
-        &self,
-        t: ast::IntTy
-    ) -> &'ll Type {
-        match t {
-            ast::IntTy::Isize => &self.isize_ty,
-            ast::IntTy::I8 => &self.type_i8(),
-            ast::IntTy::I16 => &self.type_i16(),
-            ast::IntTy::I32 => &self.type_i32(),
-            ast::IntTy::I64 => &self.type_i64(),
-            ast::IntTy::I128 => &self.type_i128(),
-        }
-    }
-
-    fn type_uint_from_ty(
-        &self,
-        t: ast::UintTy
-    ) -> &'ll Type {
-        match t {
-            ast::UintTy::Usize => &self.isize_ty,
-            ast::UintTy::U8 => &self.type_i8(),
-            ast::UintTy::U16 => &self.type_i16(),
-            ast::UintTy::U32 => &self.type_i32(),
-            ast::UintTy::U64 => &self.type_i64(),
-            ast::UintTy::U128 => &self.type_i128(),
-        }
-    }
-
-    fn type_float_from_ty(
-        &self,
-        t: ast::FloatTy
-    ) -> &'ll Type {
-        match t {
-            ast::FloatTy::F32 => &self.type_f32(),
-            ast::FloatTy::F64 => &self.type_f64(),
-        }
-    }
-
-    fn type_from_integer(&self, i: layout::Integer) -> &'ll Type {
-        use rustc::ty::layout::Integer::*;
-        match i {
-            I8 => &self.type_i8(),
-            I16 => &self.type_i16(),
-            I32 => &self.type_i32(),
-            I64 => &self.type_i64(),
-            I128 => &self.type_i128(),
-        }
-    }
-
-    fn type_pointee_for_abi_align(&self, align: Align) -> &'ll Type {
-        // FIXME(eddyb) We could find a better approximation if ity.align < align.
-        let ity = layout::Integer::approximate_abi_align(self, align);
-        &self.type_from_integer(ity)
-    }
-
-    fn type_padding_filler(
-        &self,
-        size: Size,
-        align: Align
-    ) -> &'ll Type {
-        let unit = layout::Integer::approximate_abi_align(self, align);
-        let size = size.bytes();
-        let unit_size = unit.size().bytes();
-        assert_eq!(size % unit_size, 0);
-        &self.type_array(&self.type_from_integer(unit), size / unit_size)
-    }
-
-    fn type_needs_drop(&self, ty: Ty<'tcx>) -> bool {
-        rustc_codegen_ssa::common::type_needs_drop(*self.tcx(), ty)
-    }
-
-    fn type_is_sized(&self, ty: Ty<'tcx>) -> bool {
-        rustc_codegen_ssa::common::type_is_sized(*self.tcx(), ty)
-    }
-
-    fn type_is_freeze(&self, ty: Ty<'tcx>) -> bool {
-        rustc_codegen_ssa::common::type_is_freeze(*self.tcx(), ty)
-    }
-
-    fn type_has_metadata(&self, ty: Ty<'tcx>) -> bool {
-        use syntax_pos::DUMMY_SP;
-        if ty.is_sized(self.tcx().at(DUMMY_SP), ty::ParamEnv::reveal_all()) {
-            return false;
-        }
-
-        let tail = self.tcx().struct_tail(ty);
-        match tail.sty {
-            ty::Foreign(..) => false,
-            ty::Str | ty::Slice(..) | ty::Dynamic(..) => true,
-            _ => bug!("unexpected unsized tail: {:?}", tail.sty),
-        }
-    }
-}
+impl<'a, 'll: 'a, 'tcx: 'll> DerivedTypeMethods<'a, 'll, 'tcx> for CodegenCx<'ll, 'tcx, &'ll Value>
+    {}
 
 impl LayoutTypeMethods<'ll, 'tcx> for CodegenCx<'ll, 'tcx, &'ll Value> {
     fn backend_type(&self, ty: &TyLayout<'tcx>) -> &'ll Type {
@@ -435,4 +317,4 @@ impl LayoutTypeMethods<'ll, 'tcx> for CodegenCx<'ll, 'tcx, &'ll Value> {
     }
 }
 
-impl TypeMethods<'ll, 'tcx> for CodegenCx<'ll, 'tcx, &'ll Value> {}
+impl<'a, 'll: 'a, 'tcx: 'll> TypeMethods<'a, 'll, 'tcx> for CodegenCx<'ll, 'tcx, &'ll Value> {}

src/librustc_codegen_ssa/base.rs

@@ -72,14 +72,18 @@ use mir::operand::OperandValue;
 use std::marker::PhantomData;
 
 
-pub struct StatRecorder<'a, 'll: 'a, 'tcx: 'll, Cx: 'a + CodegenMethods<'ll, 'tcx>> {
+pub struct StatRecorder<'a, 'll: 'a, 'tcx: 'll, Cx: 'a + CodegenMethods<'a, 'll, 'tcx>>
+    where &'a Cx : LayoutOf<Ty = Ty<'tcx>, TyLayout = TyLayout<'tcx>> + HasTyCtxt<'tcx>
+{
     cx: &'a Cx,
     name: Option<String>,
     istart: usize,
     phantom: PhantomData<(&'ll (), &'tcx ())>
 }
 
-impl<'a, 'll: 'a, 'tcx: 'll, Cx: 'a + CodegenMethods<'ll, 'tcx>> StatRecorder<'a, 'll, 'tcx, Cx> {
+impl<'a, 'll: 'a, 'tcx: 'll, Cx: 'a + CodegenMethods<'a, 'll, 'tcx>> StatRecorder<'a, 'll, 'tcx, Cx>
+    where &'a Cx : LayoutOf<Ty = Ty<'tcx>, TyLayout = TyLayout<'tcx>> + HasTyCtxt<'tcx>
+{
     pub fn new(cx: &'a Cx, name: String) -> Self {
         let istart = cx.stats().borrow().n_llvm_insns;
         StatRecorder {
@@ -91,8 +95,9 @@ impl<'a, 'll: 'a, 'tcx: 'll, Cx: 'a + CodegenMethods<'ll, 'tcx>> StatRecorder<'a
     }
 }
 
-impl<'a, 'll: 'a, 'tcx: 'll, Cx: 'a + CodegenMethods<'ll, 'tcx>> Drop for
+impl<'a, 'll: 'a, 'tcx: 'll, Cx: 'a + CodegenMethods<'a, 'll, 'tcx>> Drop for
     StatRecorder<'a, 'll, 'tcx, Cx>
+    where &'a Cx : LayoutOf<Ty = Ty<'tcx>, TyLayout = TyLayout<'tcx>> + HasTyCtxt<'tcx>
 {
     fn drop(&mut self) {
         if self.cx.sess().codegen_stats() {
@@ -147,7 +152,9 @@ pub fn compare_simd_types<'a, 'll:'a, 'tcx:'ll, Bx : BuilderMethods<'a, 'll, 'tc
     t: Ty<'tcx>,
     ret_ty: <Bx::CodegenCx as Backend<'ll>>::Type,
     op: hir::BinOpKind
-) -> <Bx::CodegenCx as Backend<'ll>>::Value {
+) -> <Bx::CodegenCx as Backend<'ll>>::Value
+    where &'a Bx::CodegenCx : LayoutOf<Ty = Ty<'tcx>, TyLayout = TyLayout<'tcx>> + HasTyCtxt<'tcx>
+{
     let signed = match t.sty {
         ty::Float(_) => {
             let cmp = bin_op_to_fcmp_predicate(op);
@@ -174,7 +181,7 @@ pub fn compare_simd_types<'a, 'll:'a, 'tcx:'ll, Bx : BuilderMethods<'a, 'll, 'tc
 /// The `old_info` argument is a bit funny. It is intended for use
 /// in an upcast, where the new vtable for an object will be derived
 /// from the old one.
-pub fn unsized_info<'a, 'll: 'a, 'tcx: 'll, Cx: 'a + CodegenMethods<'ll, 'tcx>>(
+pub fn unsized_info<'a, 'll: 'a, 'tcx: 'll, Cx: 'a + CodegenMethods<'a, 'll, 'tcx>>(
     cx: &'a Cx,
     source: Ty<'tcx>,
     target: Ty<'tcx>,
@@ -326,7 +333,9 @@ pub fn cast_shift_expr_rhs<'a, 'll: 'a, 'tcx: 'll, Bx : BuilderMethods<'a, 'll,
     op: hir::BinOpKind,
     lhs: <Bx::CodegenCx as Backend<'ll>>::Value,
     rhs: <Bx::CodegenCx as Backend<'ll>>::Value
-) -> <Bx::CodegenCx as Backend<'ll>>::Value {
+) -> <Bx::CodegenCx as Backend<'ll>>::Value
+    where &'a Bx::CodegenCx : LayoutOf<Ty = Ty<'tcx>, TyLayout = TyLayout<'tcx>> + HasTyCtxt<'tcx>
+{
     cast_shift_rhs(bx, op, lhs, rhs)
 }
 
@@ -335,7 +344,9 @@ fn cast_shift_rhs<'a, 'll :'a, 'tcx : 'll, Bx : BuilderMethods<'a, 'll, 'tcx>>(
     op: hir::BinOpKind,
     lhs: <Bx::CodegenCx as Backend<'ll>>::Value,
     rhs: <Bx::CodegenCx as Backend<'ll>>::Value,
-) -> <Bx::CodegenCx as Backend<'ll>>::Value {
+) -> <Bx::CodegenCx as Backend<'ll>>::Value
+    where &'a Bx::CodegenCx : LayoutOf<Ty = Ty<'tcx>, TyLayout = TyLayout<'tcx>> + HasTyCtxt<'tcx>
+{
     // Shifts may have any size int on the rhs
     if op.is_shift() {
         let mut rhs_llty = bx.cx().val_ty(rhs);
@@ -374,15 +385,19 @@ pub fn wants_msvc_seh(sess: &Session) -> bool {
 pub fn call_assume<'a, 'll: 'a, 'tcx: 'll, Bx : BuilderMethods<'a, 'll ,'tcx>>(
     bx: &mut Bx,
     val: <Bx::CodegenCx as Backend<'ll>>::Value
-) {
+)
+    where &'a Bx::CodegenCx : LayoutOf<Ty = Ty<'tcx>, TyLayout = TyLayout<'tcx>> + HasTyCtxt<'tcx>
+{
     let assume_intrinsic = bx.cx().get_intrinsic("llvm.assume");
     bx.call(assume_intrinsic, &[val], None);
 }
 
 pub fn from_immediate<'a, 'll: 'a, 'tcx: 'll, Bx : BuilderMethods<'a, 'll ,'tcx>>(
     bx: &mut Bx,
     val: <Bx::CodegenCx as Backend<'ll>>::Value
-) -> <Bx::CodegenCx as Backend<'ll>>::Value {
+) -> <Bx::CodegenCx as Backend<'ll>>::Value
+    where &'a Bx::CodegenCx : LayoutOf<Ty = Ty<'tcx>, TyLayout = TyLayout<'tcx>> + HasTyCtxt<'tcx>
+{
     if bx.cx().val_ty(val) == bx.cx().type_i1() {
         bx.zext(val, bx.cx().type_i8())
     } else {
@@ -394,7 +409,9 @@ pub fn to_immediate<'a, 'll: 'a, 'tcx: 'll, Bx : BuilderMethods<'a, 'll, 'tcx>>(
     bx: &mut Bx,
     val: <Bx::CodegenCx as Backend<'ll>>::Value,
     layout: layout::TyLayout,
-) -> <Bx::CodegenCx as Backend<'ll>>::Value {
+) -> <Bx::CodegenCx as Backend<'ll>>::Value
+    where &'a Bx::CodegenCx : LayoutOf<Ty = Ty<'tcx>, TyLayout = TyLayout<'tcx>> + HasTyCtxt<'tcx>
+{
     if let layout::Abi::Scalar(ref scalar) = layout.abi {
         return to_immediate_scalar(bx, val, scalar);
     }
@@ -405,7 +422,9 @@ pub fn to_immediate_scalar<'a, 'll :'a, 'tcx :'ll, Bx : BuilderMethods<'a, 'll,
     bx: &mut Bx,
     val: <Bx::CodegenCx as Backend<'ll>>::Value,
     scalar: &layout::Scalar,
-) -> <Bx::CodegenCx as Backend<'ll>>::Value {
+) -> <Bx::CodegenCx as Backend<'ll>>::Value
+    where &'a Bx::CodegenCx : LayoutOf<Ty = Ty<'tcx>, TyLayout = TyLayout<'tcx>> + HasTyCtxt<'tcx>
+{
     if scalar.is_bool() {
         return bx.trunc(val, bx.cx().type_i1());
     }
@@ -419,7 +438,9 @@ pub fn memcpy_ty<'a, 'll: 'a, 'tcx: 'll, Bx : BuilderMethods<'a, 'll, 'tcx>>(
     layout: TyLayout<'tcx>,
     align: Align,
     flags: MemFlags,
-) {
+)
+    where &'a Bx::CodegenCx : LayoutOf<Ty = Ty<'tcx>, TyLayout = TyLayout<'tcx>> + HasTyCtxt<'tcx>
+{
     let size = layout.size.bytes();
     if size == 0 {
         return;
@@ -467,7 +488,9 @@ pub fn codegen_instance<'a, 'll: 'a, 'tcx: 'll, Bx: BuilderMethods<'a, 'll, 'tcx
 /// users main function.
 pub fn maybe_create_entry_wrapper<'a, 'll: 'a, 'tcx: 'll, Bx: BuilderMethods<'a, 'll, 'tcx>>(
     cx: &'a Bx::CodegenCx
-) {
+)
+    where &'a Bx::CodegenCx : LayoutOf<Ty = Ty<'tcx>, TyLayout = TyLayout<'tcx>> + HasTyCtxt<'tcx>
+{
     let (main_def_id, span) = match *cx.sess().entry_fn.borrow() {
         Some((id, span, _)) => {
             (cx.tcx().hir.local_def_id(id), span)
@@ -498,7 +521,10 @@ pub fn maybe_create_entry_wrapper<'a, 'll: 'a, 'tcx: 'll, Bx: BuilderMethods<'a,
         rust_main: <Bx::CodegenCx as Backend<'ll>>::Value,
         rust_main_def_id: DefId,
         use_start_lang_item: bool,
-    ) {
+    )
+        where &'a Bx::CodegenCx :
+            LayoutOf<Ty = Ty<'tcx>, TyLayout = TyLayout<'tcx>> + HasTyCtxt<'tcx>
+    {
         let llfty =
             cx.type_func(&[cx.type_int(), cx.type_ptr_to(cx.type_i8p())], cx.type_int());
 
@@ -551,7 +577,7 @@ pub fn maybe_create_entry_wrapper<'a, 'll: 'a, 'tcx: 'll, Bx: BuilderMethods<'a,
         };
 
         let result = bx.call(start_fn, &args, None);
-        let cast = bx.intcast(result, cx.type_int(), true); 
+        let cast = bx.intcast(result, cx.type_int(), true);
         bx.ret(cast);
     }
 }

src/librustc_codegen_ssa/callee.rs

@@ -9,15 +9,18 @@
 // except according to those terms.
 
 use interfaces::*;
-use rustc::ty;
+use rustc::ty::{self, Ty};
+use rustc::ty::layout::{LayoutOf, TyLayout, HasTyCtxt};
 use rustc::ty::subst::Substs;
 use rustc::hir::def_id::DefId;
 
-pub fn resolve_and_get_fn<'ll, 'tcx: 'll, Cx : CodegenMethods<'ll, 'tcx>>(
+pub fn resolve_and_get_fn<'a, 'll: 'a, 'tcx: 'll, Cx : 'a +  CodegenMethods<'a, 'll, 'tcx>>(
     cx: &Cx,
     def_id: DefId,
     substs: &'tcx Substs<'tcx>,
-) -> Cx::Value {
+) -> Cx::Value
+    where &'a Cx : LayoutOf<Ty = Ty<'tcx>, TyLayout = TyLayout<'tcx>> + HasTyCtxt<'tcx>
+{
     cx.get_fn(
         ty::Instance::resolve(
             *cx.tcx(),