Added 'll lifetime parameter to backend

Author: denismerigoux

src/librustc_codegen_llvm/abi.rs

@@ -284,7 +284,7 @@ impl<'a, 'll: 'a, 'tcx: 'll> ArgTypeMethods<'a, 'll, 'tcx> for Builder<'a, 'll,
     fn store_fn_arg(
         &self,
         ty: &ArgType<'tcx, Ty<'tcx>>,
-        idx: &mut usize, dst: PlaceRef<'tcx, <Self::CodegenCx as Backend>::Value>
+        idx: &mut usize, dst: PlaceRef<'tcx, <Self::CodegenCx as Backend<'ll>>::Value>
     ) {
         ty.store_fn_arg(&self, idx, dst)
     }
@@ -824,7 +824,7 @@ 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
+        callsite: <Self::CodegenCx as Backend<'ll>>::Value
     ) {
         ty.apply_attrs_callsite(&self, callsite)
     }

src/librustc_codegen_llvm/base.rs

@@ -157,12 +157,12 @@ pub fn bin_op_to_fcmp_predicate(op: hir::BinOpKind) -> RealPredicate {
 
 pub fn compare_simd_types<'a, 'll:'a, 'tcx:'ll, Builder : BuilderMethods<'a, 'll, 'tcx>>(
     bx: &Builder,
-    lhs: <Builder::CodegenCx as Backend>::Value,
-    rhs: <Builder::CodegenCx as Backend>::Value,
+    lhs: <Builder::CodegenCx as Backend<'ll>>::Value,
+    rhs: <Builder::CodegenCx as Backend<'ll>>::Value,
     t: Ty<'tcx>,
-    ret_ty: <Builder::CodegenCx as Backend>::Type,
+    ret_ty: <Builder::CodegenCx as Backend<'ll>>::Type,
     op: hir::BinOpKind
-) -> <Builder::CodegenCx as Backend>::Value {
+) -> <Builder::CodegenCx as Backend<'ll>>::Value {
     let signed = match t.sty {
         ty::Float(_) => {
             let cmp = bin_op_to_fcmp_predicate(op);
@@ -219,10 +219,10 @@ pub fn unsized_info<'a, 'll: 'a, 'tcx: 'll, Cx: 'a + CodegenMethods<'ll, 'tcx>>(
 /// Coerce `src` to `dst_ty`. `src_ty` must be a thin pointer.
 pub fn unsize_thin_ptr<'a, 'll: 'a, 'tcx: 'll, Bx: BuilderMethods<'a, 'll, 'tcx>>(
     bx: &Bx,
-    src: <Bx::CodegenCx as Backend>::Value,
+    src: <Bx::CodegenCx as Backend<'ll>>::Value,
     src_ty: Ty<'tcx>,
     dst_ty: Ty<'tcx>
-) -> (<Bx::CodegenCx as Backend>::Value, <Bx::CodegenCx as Backend>::Value) where
+) -> (<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>
 {
     debug!("unsize_thin_ptr: {:?} => {:?}", src_ty, dst_ty);
@@ -276,8 +276,8 @@ pub fn unsize_thin_ptr<'a, 'll: 'a, 'tcx: 'll, Bx: BuilderMethods<'a, 'll, 'tcx>
 /// to a value of type `dst_ty` and store the result in `dst`
 pub fn coerce_unsized_into<'a, 'll: 'a, 'tcx: 'll, Bx: BuilderMethods<'a, 'll, 'tcx>>(
     bx: &Bx,
-    src: PlaceRef<'tcx, <Bx::CodegenCx as Backend>::Value>,
-    dst: PlaceRef<'tcx, <Bx::CodegenCx as Backend>::Value>
+    src: PlaceRef<'tcx, <Bx::CodegenCx as Backend<'ll>>::Value>,
+    dst: PlaceRef<'tcx, <Bx::CodegenCx as Backend<'ll>>::Value>
 ) where &'a Bx::CodegenCx: LayoutOf<Ty = Ty<'tcx>, TyLayout = TyLayout<'tcx>> + HasTyCtxt<'tcx>
 {
     let src_ty = src.layout.ty;
@@ -337,28 +337,28 @@ pub fn coerce_unsized_into<'a, 'll: 'a, 'tcx: 'll, Bx: BuilderMethods<'a, 'll, '
 pub fn cast_shift_expr_rhs<'a, 'll: 'a, 'tcx: 'll, Builder : BuilderMethods<'a, 'll, 'tcx>>(
     bx: &Builder,
     op: hir::BinOpKind,
-    lhs: <Builder::CodegenCx as Backend>::Value,
-    rhs: <Builder::CodegenCx as Backend>::Value
-) -> <Builder::CodegenCx as Backend>::Value {
+    lhs: <Builder::CodegenCx as Backend<'ll>>::Value,
+    rhs: <Builder::CodegenCx as Backend<'ll>>::Value
+) -> <Builder::CodegenCx as Backend<'ll>>::Value {
     cast_shift_rhs(bx, op, lhs, rhs, |a, b| bx.trunc(a, b), |a, b| bx.zext(a, b))
 }
 
 fn cast_shift_rhs<'a, 'll :'a, 'tcx : 'll, F, G, Builder : BuilderMethods<'a, 'll, 'tcx>>(
     bx: &Builder,
     op: hir::BinOpKind,
-    lhs: <Builder::CodegenCx as Backend>::Value,
-    rhs: <Builder::CodegenCx as Backend>::Value,
+    lhs: <Builder::CodegenCx as Backend<'ll>>::Value,
+    rhs: <Builder::CodegenCx as Backend<'ll>>::Value,
     trunc: F,
     zext: G
-) -> <Builder::CodegenCx as Backend>::Value
+) -> <Builder::CodegenCx as Backend<'ll>>::Value
     where F: FnOnce(
-        <Builder::CodegenCx as Backend>::Value,
-        <Builder::CodegenCx as Backend>::Type
-    ) -> <Builder::CodegenCx as Backend>::Value,
+        <Builder::CodegenCx as Backend<'ll>>::Value,
+        <Builder::CodegenCx as Backend<'ll>>::Type
+    ) -> <Builder::CodegenCx as Backend<'ll>>::Value,
     G: FnOnce(
-        <Builder::CodegenCx as Backend>::Value,
-        <Builder::CodegenCx as Backend>::Type
-    ) -> <Builder::CodegenCx as Backend>::Value
+        <Builder::CodegenCx as Backend<'ll>>::Value,
+        <Builder::CodegenCx as Backend<'ll>>::Type
+    ) -> <Builder::CodegenCx as Backend<'ll>>::Value
 {
     // Shifts may have any size int on the rhs
     if op.is_shift() {
@@ -397,16 +397,16 @@ pub fn wants_msvc_seh(sess: &Session) -> bool {
 
 pub fn call_assume<'a, 'll: 'a, 'tcx: 'll, Bx : BuilderMethods<'a, 'll ,'tcx>>(
     bx: &Bx,
-    val: <Bx::CodegenCx as Backend>::Value
+    val: <Bx::CodegenCx as Backend<'ll>>::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, Bx : BuilderMethods<'a, 'll ,'tcx>>(
     bx: &Bx,
-    val: <Bx::CodegenCx as Backend>::Value
-) -> <Bx::CodegenCx as Backend>::Value {
+    val: <Bx::CodegenCx as Backend<'ll>>::Value
+) -> <Bx::CodegenCx as Backend<'ll>>::Value {
     if bx.cx().val_ty(val) == bx.cx().type_i1() {
         bx.zext(val, bx.cx().type_i8())
     } else {
@@ -416,9 +416,9 @@ pub fn from_immediate<'a, 'll: 'a, 'tcx: 'll, Bx : BuilderMethods<'a, 'll ,'tcx>
 
 pub fn to_immediate<'a, 'll: 'a, 'tcx: 'll, Builder : BuilderMethods<'a, 'll, 'tcx>>(
     bx: &Builder,
-    val: <Builder::CodegenCx as Backend>::Value,
+    val: <Builder::CodegenCx as Backend<'ll>>::Value,
     layout: layout::TyLayout,
-) -> <Builder::CodegenCx as Backend>::Value {
+) -> <Builder::CodegenCx as Backend<'ll>>::Value {
     if let layout::Abi::Scalar(ref scalar) = layout.abi {
         return to_immediate_scalar(bx, val, scalar);
     }
@@ -427,9 +427,9 @@ pub fn to_immediate<'a, 'll: 'a, 'tcx: 'll, Builder : BuilderMethods<'a, 'll, 't
 
 pub fn to_immediate_scalar<'a, 'll :'a, 'tcx :'ll, Builder : BuilderMethods<'a, 'll, 'tcx>>(
     bx: &Builder,
-    val: <Builder::CodegenCx as Backend>::Value,
+    val: <Builder::CodegenCx as Backend<'ll>>::Value,
     scalar: &layout::Scalar,
-) -> <Builder::CodegenCx as Backend>::Value {
+) -> <Builder::CodegenCx as Backend<'ll>>::Value {
     if scalar.is_bool() {
         return bx.trunc(val, bx.cx().type_i1());
     }
@@ -438,8 +438,8 @@ pub fn to_immediate_scalar<'a, 'll :'a, 'tcx :'ll, Builder : BuilderMethods<'a,
 
 pub fn memcpy_ty<'a, 'll: 'a, 'tcx: 'll, Builder : BuilderMethods<'a, 'll, 'tcx>>(
     bx: &Builder,
-    dst: <Builder::CodegenCx as Backend>::Value,
-    src: <Builder::CodegenCx as Backend>::Value,
+    dst: <Builder::CodegenCx as Backend<'ll>>::Value,
+    src: <Builder::CodegenCx as Backend<'ll>>::Value,
     layout: TyLayout<'tcx>,
     align: Align,
     flags: MemFlags,

src/librustc_codegen_llvm/callee.rs

@@ -205,7 +205,7 @@ pub fn get_fn(
 }
 
 pub fn resolve_and_get_fn<'ll, 'tcx: 'll,
-    Cx : Backend + MiscMethods<'tcx> + TypeMethods<'ll, 'tcx>
+    Cx : Backend<'ll> + MiscMethods<'ll, 'tcx> + TypeMethods<'ll, 'tcx>
     >(
     cx: &Cx,
     def_id: DefId,

src/librustc_codegen_llvm/common.rs

@@ -215,14 +215,14 @@ impl<'ll, V : CodegenObject> Funclet<'ll, V> {
     }
 }
 
-impl Backend for CodegenCx<'ll, 'tcx, &'ll Value> {
+impl Backend<'ll> for CodegenCx<'ll, 'tcx, &'ll Value> {
     type Value = &'ll Value;
     type BasicBlock = &'ll BasicBlock;
     type Type = &'ll Type;
     type Context = &'ll llvm::Context;
 }
 
-impl<'ll, 'tcx : 'll> ConstMethods<'tcx> for CodegenCx<'ll, 'tcx, &'ll Value> {
+impl<'ll, 'tcx : 'll> ConstMethods<'ll, 'tcx> for CodegenCx<'ll, 'tcx, &'ll Value> {
 
     // LLVM constant constructors.
     fn const_null(&self, t: &'ll Type) -> &'ll Value {
@@ -545,9 +545,9 @@ pub fn langcall(tcx: TyCtxt,
 
 pub fn build_unchecked_lshift<'a, 'll: 'a, 'tcx: 'll, Bx: BuilderMethods<'a, 'll, 'tcx>>(
     bx: &Bx,
-    lhs: <Bx::CodegenCx as Backend>::Value,
-    rhs: <Bx::CodegenCx as Backend>::Value
-) -> <Bx::CodegenCx as Backend>::Value {
+    lhs: <Bx::CodegenCx as Backend<'ll>>::Value,
+    rhs: <Bx::CodegenCx as Backend<'ll>>::Value
+) -> <Bx::CodegenCx as Backend<'ll>>::Value {
     let rhs = base::cast_shift_expr_rhs(bx, hir::BinOpKind::Shl, lhs, rhs);
     // #1877, #10183: Ensure that input is always valid
     let rhs = shift_mask_rhs(bx, rhs);
@@ -557,9 +557,9 @@ pub fn build_unchecked_lshift<'a, 'll: 'a, 'tcx: 'll, Bx: BuilderMethods<'a, 'll
 pub fn build_unchecked_rshift<'a, 'll: 'a, 'tcx: 'll, Bx: BuilderMethods<'a, 'll, 'tcx>>(
     bx: &Bx,
     lhs_t: Ty<'tcx>,
-    lhs: <Bx::CodegenCx as Backend>::Value,
-    rhs: <Bx::CodegenCx as Backend>::Value
-) -> <Bx::CodegenCx as Backend>::Value {
+    lhs: <Bx::CodegenCx as Backend<'ll>>::Value,
+    rhs: <Bx::CodegenCx as Backend<'ll>>::Value
+) -> <Bx::CodegenCx as Backend<'ll>>::Value {
     let rhs = base::cast_shift_expr_rhs(bx, hir::BinOpKind::Shr, lhs, rhs);
     // #1877, #10183: Ensure that input is always valid
     let rhs = shift_mask_rhs(bx, rhs);
@@ -573,18 +573,18 @@ pub fn build_unchecked_rshift<'a, 'll: 'a, 'tcx: 'll, Bx: BuilderMethods<'a, 'll
 
 fn shift_mask_rhs<'a, 'll: 'a, 'tcx: 'll, Bx: BuilderMethods<'a, 'll, 'tcx>>(
     bx: &Bx,
-    rhs: <Bx::CodegenCx as Backend>::Value
-) -> <Bx::CodegenCx as Backend>::Value {
+    rhs: <Bx::CodegenCx as Backend<'ll>>::Value
+) -> <Bx::CodegenCx as Backend<'ll>>::Value {
     let rhs_llty = bx.cx().val_ty(rhs);
     bx.and(rhs, shift_mask_val(bx, rhs_llty, rhs_llty, false))
 }
 
 pub fn shift_mask_val<'a, 'll: 'a, 'tcx: 'll, Bx: BuilderMethods<'a, 'll, 'tcx>>(
     bx: &Bx,
-    llty: <Bx::CodegenCx as Backend>::Type,
-    mask_llty: <Bx::CodegenCx as Backend>::Type,
+    llty: <Bx::CodegenCx as Backend<'ll>>::Type,
+    mask_llty: <Bx::CodegenCx as Backend<'ll>>::Type,
     invert: bool
-) -> <Bx::CodegenCx as Backend>::Value {
+) -> <Bx::CodegenCx as Backend<'ll>>::Value {
     let kind = bx.cx().type_kind(llty);
     match kind {
         TypeKind::Integer => {

src/librustc_codegen_llvm/consts.rs

@@ -116,7 +116,7 @@ pub fn ptrcast(val: &'ll Value, ty: &'ll Type) -> &'ll Value {
     }
 }
 
-impl StaticMethods<'tcx> for CodegenCx<'ll, 'tcx, &'ll Value> {
+impl StaticMethods<'ll> for CodegenCx<'ll, 'tcx, &'ll Value> {
 
     fn static_ptrcast(&self, val: &'ll Value, ty: &'ll Type) -> &'ll Value {
         ptrcast(val, ty)

src/librustc_codegen_llvm/context.rs

@@ -316,7 +316,7 @@ impl<'a, 'tcx, Value : Eq+Hash> CodegenCx<'a, 'tcx, Value> {
     }
 }
 
-impl MiscMethods<'tcx> for CodegenCx<'ll, 'tcx, &'ll Value> {
+impl MiscMethods<'ll, 'tcx> for CodegenCx<'ll, 'tcx, &'ll Value> {
     fn vtables(&self) -> &RefCell<FxHashMap<(Ty<'tcx>,
                                 Option<ty::PolyExistentialTraitRef<'tcx>>), &'ll Value>>
     {
@@ -422,7 +422,7 @@ impl MiscMethods<'tcx> for CodegenCx<'ll, 'tcx, &'ll Value> {
 
 impl<'ll, 'tcx: 'll> CodegenMethods<'ll, 'tcx> for CodegenCx<'ll, 'tcx, &'ll Value> {}
 
-impl IntrinsicDeclarationMethods for CodegenCx<'b, 'tcx, &'b Value> {
+impl IntrinsicDeclarationMethods<'b> for CodegenCx<'b, 'tcx, &'b Value> {
     fn get_intrinsic(&self, key: &str) -> &'b Value {
         if let Some(v) = self.intrinsics.borrow().get(key).cloned() {
             return v;

src/librustc_codegen_llvm/declare.rs

@@ -95,7 +95,7 @@ fn declare_raw_fn(
     llfn
 }
 
-impl DeclareMethods<'tcx> for CodegenCx<'ll, 'tcx, &'ll Value> {
+impl DeclareMethods<'ll, 'tcx> for CodegenCx<'ll, 'tcx, &'ll Value> {
 
     /// Declare a global value.
     ///

src/librustc_codegen_llvm/glue.rs

@@ -25,8 +25,8 @@ pub fn size_and_align_of_dst<'a, 'll: 'a, 'tcx: 'll,
     >(
     bx: &Bx,
     t: Ty<'tcx>,
-    info: Option<<Bx::CodegenCx as Backend>::Value>
-) -> (<Bx::CodegenCx as Backend>::Value, <Bx::CodegenCx as Backend>::Value)  where
+    info: Option<<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>
 {
     debug!("calculate size of DST: {}; with lost info: {:?}",

src/librustc_codegen_llvm/interfaces/abi.rs

@@ -27,6 +27,6 @@ pub trait AbiBuilderMethods<'a, 'll: 'a, 'tcx: 'll> : HasCodegen<'a, 'll, 'tcx>
     fn apply_attrs_callsite(
         &self,
         ty: &FnType<'tcx, Ty<'tcx>>,
-        callsite: <Self::CodegenCx as Backend>::Value
+        callsite: <Self::CodegenCx as Backend<'ll>>::Value
     );
 }

src/librustc_codegen_llvm/interfaces/asm.rs

@@ -17,8 +17,8 @@ pub trait AsmBuilderMethods<'a, 'll: 'a, 'tcx: 'll> : HasCodegen<'a, 'll, 'tcx>{
     fn codegen_inline_asm(
         &self,
         ia: &InlineAsm,
-        outputs: Vec<PlaceRef<'tcx, <Self::CodegenCx as Backend>::Value>>,
-        inputs: Vec<<Self::CodegenCx as Backend>::Value>
+        outputs: Vec<PlaceRef<'tcx, <Self::CodegenCx as Backend<'ll>>::Value>>,
+        inputs: Vec<<Self::CodegenCx as Backend<'ll>>::Value>
     );
 }