Added self argument for Codegen CommonMethod trait methods

Author: denismerigoux

src/librustc_codegen_llvm/builder.rs

@@ -541,8 +541,8 @@ impl BuilderMethods<'a, 'll, 'tcx>
         unsafe {
             let llty = CodegenCx::val_ty(load);
             let v = [
-                CodegenCx::c_uint_big(llty, range.start),
-                CodegenCx::c_uint_big(llty, range.end)
+                self.cx.c_uint_big(llty, range.start),
+                self.cx.c_uint_big(llty, range.end)
             ];
 
             llvm::LLVMSetMetadata(load, llvm::MD_range as c_uint,
@@ -850,7 +850,7 @@ impl BuilderMethods<'a, 'll, 'tcx>
             let undef = llvm::LLVMGetUndef(type_::Type::vector(elt_ty, num_elts as u64));
             let vec = self.insert_element(undef, elt, CodegenCx::c_i32(self.cx, 0));
             let vec_i32_ty = type_::Type::vector(type_::Type::i32(self.cx), num_elts as u64);
-            self.shuffle_vector(vec, undef, CodegenCx::c_null(vec_i32_ty))
+            self.shuffle_vector(vec, undef, self.cx.c_null(vec_i32_ty))
         }
     }
 

src/librustc_codegen_llvm/common.rs

@@ -210,51 +210,51 @@ impl<'ll, 'tcx : 'll> CommonMethods for CodegenCx<'ll, 'tcx, &'ll Value> {
     }
 
     // LLVM constant constructors.
-    fn c_null(t: &'ll Type) -> &'ll Value {
+    fn c_null(&self, t: &'ll Type) -> &'ll Value {
         unsafe {
             llvm::LLVMConstNull(t)
         }
     }
 
-    fn c_undef(t: &'ll Type) -> &'ll Value {
+    fn c_undef(&self, t: &'ll Type) -> &'ll Value {
         unsafe {
             llvm::LLVMGetUndef(t)
         }
     }
 
-    fn c_int(t: &'ll Type, i: i64) -> &'ll Value {
+    fn c_int(&self, t: &'ll Type, i: i64) -> &'ll Value {
         unsafe {
             llvm::LLVMConstInt(t, i as u64, True)
         }
     }
 
-    fn c_uint(t: &'ll Type, i: u64) -> &'ll Value {
+    fn c_uint(&self, t: &'ll Type, i: u64) -> &'ll Value {
         unsafe {
             llvm::LLVMConstInt(t, i, False)
         }
     }
 
-    fn c_uint_big(t: &'ll Type, u: u128) -> &'ll Value {
+    fn c_uint_big(&self, t: &'ll Type, u: u128) -> &'ll Value {
         unsafe {
             let words = [u as u64, (u >> 64) as u64];
             llvm::LLVMConstIntOfArbitraryPrecision(t, 2, words.as_ptr())
         }
     }
 
     fn c_bool(&self, val: bool) -> &'ll Value {
-        Self::c_uint(Type::i1(&self), val as u64)
+        &self.c_uint(Type::i1(&self), val as u64)
     }
 
     fn c_i32(&self, i: i32) -> &'ll Value {
-        Self::c_int(Type::i32(&self), i as i64)
+        &self.c_int(Type::i32(&self), i as i64)
     }
 
     fn c_u32(&self, i: u32) -> &'ll Value {
-        Self::c_uint(Type::i32(&self), i as u64)
+        &self.c_uint(Type::i32(&self), i as u64)
     }
 
     fn c_u64(&self, i: u64) -> &'ll Value {
-        Self::c_uint(Type::i64(&self), i)
+        &self.c_uint(Type::i64(&self), i)
     }
 
     fn c_usize(&self, i: u64) -> &'ll Value {
@@ -264,11 +264,11 @@ impl<'ll, 'tcx : 'll> CommonMethods for CodegenCx<'ll, 'tcx, &'ll Value> {
             assert!(i < (1<<bit_size));
         }
 
-        Self::c_uint(&self.isize_ty, i)
+        &self.c_uint(&self.isize_ty, i)
     }
 
     fn c_u8(&self, i: u8) -> &'ll Value {
-        Self::c_uint(Type::i8(&self), i as u64)
+        &self.c_uint(Type::i8(&self), i as u64)
     }
 
 
@@ -494,9 +494,9 @@ pub fn shift_mask_val(
             // i8/u8 can shift by at most 7, i16/u16 by at most 15, etc.
             let val = llty.int_width() - 1;
             if invert {
-                CodegenCx::c_int(mask_llty, !val as i64)
+                bx.cx.c_int(mask_llty, !val as i64)
             } else {
-                CodegenCx::c_uint(mask_llty, val)
+                bx.cx.c_uint(mask_llty, val)
             }
         },
         TypeKind::Vector => {

src/librustc_codegen_llvm/interfaces/common.rs

@@ -15,11 +15,11 @@ pub trait CommonMethods : Backend {
     fn val_ty(v: Self::Value) -> Self::Type;
 
     // Constant constructors
-    fn c_null(t: Self::Type) -> Self::Value;
-    fn c_undef(t: Self::Type) -> Self::Value;
-    fn c_int(t: Self::Type, i: i64) -> Self::Value;
-    fn c_uint(t: Self::Type, i: u64) -> Self::Value;
-    fn c_uint_big(t: Self::Type, u: u128) -> Self::Value;
+    fn c_null(&self, t: Self::Type) -> Self::Value;
+    fn c_undef(&self, t: Self::Type) -> Self::Value;
+    fn c_int(&self, t: Self::Type, i: i64) -> Self::Value;
+    fn c_uint(&self, t: Self::Type, i: u64) -> Self::Value;
+    fn c_uint_big(&self, t: Self::Type, u: u128) -> Self::Value;
     fn c_bool(&self, val: bool) -> Self::Value;
     fn c_i32(&self, i: i32) -> Self::Value;
     fn c_u32(&self, i: u32) -> Self::Value;

src/librustc_codegen_llvm/intrinsic.rs

@@ -126,11 +126,11 @@ pub fn codegen_intrinsic_call(
         },
         "likely" => {
             let expect = cx.get_intrinsic(&("llvm.expect.i1"));
-            bx.call(expect, &[args[0].immediate(), CodegenCx::c_bool(cx, true)], None)
+            bx.call(expect, &[args[0].immediate(), bx.cx().c_bool(true)], None)
         }
         "unlikely" => {
             let expect = cx.get_intrinsic(&("llvm.expect.i1"));
-            bx.call(expect, &[args[0].immediate(), CodegenCx::c_bool(cx, false)], None)
+            bx.call(expect, &[args[0].immediate(), bx.cx().c_bool(false)], None)
         }
         "try" => {
             try_intrinsic(bx, cx,
@@ -146,7 +146,7 @@ pub fn codegen_intrinsic_call(
         }
         "size_of" => {
             let tp_ty = substs.type_at(0);
-            CodegenCx::c_usize(cx, cx.size_of(tp_ty).bytes())
+            cx.c_usize(cx.size_of(tp_ty).bytes())
         }
         "size_of_val" => {
             let tp_ty = substs.type_at(0);
@@ -155,12 +155,12 @@ pub fn codegen_intrinsic_call(
                     glue::size_and_align_of_dst(bx, tp_ty, Some(meta));
                 llsize
             } else {
-                CodegenCx::c_usize(cx, cx.size_of(tp_ty).bytes())
+                cx.c_usize(cx.size_of(tp_ty).bytes())
             }
         }
         "min_align_of" => {
             let tp_ty = substs.type_at(0);
-            CodegenCx::c_usize(cx, cx.align_of(tp_ty).abi())
+            cx.c_usize(cx.align_of(tp_ty).abi())
         }
         "min_align_of_val" => {
             let tp_ty = substs.type_at(0);
@@ -169,20 +169,20 @@ pub fn codegen_intrinsic_call(
                     glue::size_and_align_of_dst(bx, tp_ty, Some(meta));
                 llalign
             } else {
-                CodegenCx::c_usize(cx, cx.align_of(tp_ty).abi())
+                cx.c_usize(cx.align_of(tp_ty).abi())
             }
         }
         "pref_align_of" => {
             let tp_ty = substs.type_at(0);
-            CodegenCx::c_usize(cx, cx.align_of(tp_ty).pref())
+            cx.c_usize(cx.align_of(tp_ty).pref())
         }
         "type_name" => {
             let tp_ty = substs.type_at(0);
             let ty_name = Symbol::intern(&tp_ty.to_string()).as_str();
-            CodegenCx::c_str_slice(cx, ty_name)
+            cx.c_str_slice(ty_name)
         }
         "type_id" => {
-            CodegenCx::c_u64(cx, cx.tcx.type_id_hash(substs.type_at(0)))
+            cx.c_u64(cx.tcx.type_id_hash(substs.type_at(0)))
         }
         "init" => {
             let ty = substs.type_at(0);
@@ -196,8 +196,8 @@ pub fn codegen_intrinsic_call(
                     false,
                     ty,
                     llresult,
-                    CodegenCx::c_u8(cx, 0),
-                    CodegenCx::c_usize(cx, 1)
+                    cx.c_u8(0),
+                    cx.c_usize(1)
                 );
             }
             return;
@@ -209,7 +209,7 @@ pub fn codegen_intrinsic_call(
         "needs_drop" => {
             let tp_ty = substs.type_at(0);
 
-            CodegenCx::c_bool(cx, bx.cx().type_needs_drop(tp_ty))
+            cx.c_bool(bx.cx().type_needs_drop(tp_ty))
         }
         "offset" => {
             let ptr = args[0].immediate();
@@ -286,9 +286,9 @@ pub fn codegen_intrinsic_call(
             };
             bx.call(expect, &[
                 args[0].immediate(),
-                CodegenCx::c_i32(cx, rw),
+                cx.c_i32(rw),
                 args[1].immediate(),
-                CodegenCx::c_i32(cx, cache_type)
+                cx.c_i32(cache_type)
             ], None)
         },
         "ctlz" | "ctlz_nonzero" | "cttz" | "cttz_nonzero" | "ctpop" | "bswap" |
@@ -300,12 +300,12 @@ pub fn codegen_intrinsic_call(
                 Some((width, signed)) =>
                     match name {
                         "ctlz" | "cttz" => {
-                            let y = CodegenCx::c_bool(bx.cx(), false);
+                            let y = cx.c_bool(false);
                             let llfn = cx.get_intrinsic(&format!("llvm.{}.i{}", name, width));
                             bx.call(llfn, &[args[0].immediate(), y], None)
                         }
                         "ctlz_nonzero" | "cttz_nonzero" => {
-                            let y = CodegenCx::c_bool(bx.cx(), true);
+                            let y = cx.c_bool(true);
                             let llvm_name = &format!("llvm.{}.i{}", &name[..4], width);
                             let llfn = cx.get_intrinsic(llvm_name);
                             bx.call(llfn, &[args[0].immediate(), y], None)
@@ -707,8 +707,8 @@ fn copy_intrinsic(
 ) -> &'ll Value {
     let cx = bx.cx();
     let (size, align) = cx.size_and_align_of(ty);
-    let size = CodegenCx::c_usize(cx, size.bytes());
-    let align = CodegenCx::c_i32(cx, align.abi() as i32);
+    let size = cx.c_usize(size.bytes());
+    let align = cx.c_i32(align.abi() as i32);
 
     let operation = if allow_overlap {
         "memmove"
@@ -728,7 +728,7 @@ fn copy_intrinsic(
         src_ptr,
         bx.mul(size, count),
         align,
-        CodegenCx::c_bool(cx, volatile)],
+        cx.c_bool(volatile)],
         None)
 }
 
@@ -742,8 +742,8 @@ fn memset_intrinsic(
 ) -> &'ll Value {
     let cx = bx.cx();
     let (size, align) = cx.size_and_align_of(ty);
-    let size = CodegenCx::c_usize(cx, size.bytes());
-    let align = CodegenCx::c_i32(cx, align.abi() as i32);
+    let size = cx.c_usize(size.bytes());
+    let align = cx.c_i32(align.abi() as i32);
     let dst = bx.pointercast(dst, Type::i8p(cx));
     call_memset(bx, dst, val, bx.mul(size, count), align, volatile)
 }
@@ -759,7 +759,7 @@ fn try_intrinsic(
     if bx.sess().no_landing_pads() {
         bx.call(func, &[data], None);
         let ptr_align = bx.tcx().data_layout.pointer_align;
-        bx.store(CodegenCx::c_null(Type::i8p(&bx.cx())), dest, ptr_align);
+        bx.store(bx.cx().c_null(Type::i8p(&bx.cx())), dest, ptr_align);
     } else if wants_msvc_seh(bx.sess()) {
         codegen_msvc_try(bx, cx, func, data, local_ptr, dest);
     } else {
@@ -841,7 +841,7 @@ fn codegen_msvc_try(
         bx.invoke(func, &[data], normal.llbb(), catchswitch.llbb(),
             None);
 
-        normal.ret(CodegenCx::c_i32(cx, 0));
+        normal.ret(cx.c_i32(0));
 
         let cs = catchswitch.catch_switch(None, None, 1);
         catchswitch.add_handler(cs, catchpad.llbb());
@@ -851,19 +851,19 @@ fn codegen_msvc_try(
             Some(did) => ::consts::get_static(cx, did),
             None => bug!("msvc_try_filter not defined"),
         };
-        let tok = catchpad.catch_pad(cs, &[tydesc, CodegenCx::c_i32(cx, 0), slot]);
+        let tok = catchpad.catch_pad(cs, &[tydesc, cx.c_i32(0), slot]);
         let addr = catchpad.load(slot, ptr_align);
 
         let i64_align = bx.tcx().data_layout.i64_align;
         let arg1 = catchpad.load(addr, i64_align);
-        let val1 = CodegenCx::c_i32(cx, 1);
+        let val1 = cx.c_i32(1);
         let arg2 = catchpad.load(catchpad.inbounds_gep(addr, &[val1]), i64_align);
         let local_ptr = catchpad.bitcast(local_ptr, i64p);
         catchpad.store(arg1, local_ptr, i64_align);
         catchpad.store(arg2, catchpad.inbounds_gep(local_ptr, &[val1]), i64_align);
         catchpad.catch_ret(tok, caught.llbb());
 
-        caught.ret(CodegenCx::c_i32(cx, 1));
+        caught.ret(cx.c_i32(1));
     });
 
     // Note that no invoke is used here because by definition this function
@@ -919,7 +919,7 @@ fn codegen_gnu_try(
         let data = llvm::get_param(bx.llfn(), 1);
         let local_ptr = llvm::get_param(bx.llfn(), 2);
         bx.invoke(func, &[data], then.llbb(), catch.llbb(), None);
-        then.ret(CodegenCx::c_i32(cx, 0));
+        then.ret(cx.c_i32(0));
 
         // Type indicator for the exception being thrown.
         //
@@ -930,11 +930,11 @@ fn codegen_gnu_try(
         let lpad_ty = Type::struct_(cx, &[Type::i8p(cx), Type::i32(cx)],
                                     false);
         let vals = catch.landing_pad(lpad_ty, bx.cx().eh_personality(), 1);
-        catch.add_clause(vals, CodegenCx::c_null(Type::i8p(cx)));
+        catch.add_clause(vals, bx.cx().c_null(Type::i8p(cx)));
         let ptr = catch.extract_value(vals, 0);
         let ptr_align = bx.tcx().data_layout.pointer_align;
         catch.store(ptr, catch.bitcast(local_ptr, Type::i8p(cx).ptr_to()), ptr_align);
-        catch.ret(CodegenCx::c_i32(cx, 1));
+        catch.ret(cx.c_i32(1));
     });
 
     // Note that no invoke is used here because by definition this function
@@ -1127,13 +1127,13 @@ fn generic_simd_intrinsic(
                                     arg_idx, total_len);
                         None
                     }
-                    Some(idx) => Some(CodegenCx::c_i32(bx.cx(), idx as i32)),
+                    Some(idx) => Some(bx.cx().c_i32(idx as i32)),
                 }
             })
             .collect();
         let indices = match indices {
             Some(i) => i,
-            None => return Ok(CodegenCx::c_null(llret_ty))
+            None => return Ok(bx.cx().c_null(llret_ty))
         };
 
         return Ok(bx.shuffle_vector(args[0].immediate(),
@@ -1402,7 +1402,7 @@ fn generic_simd_intrinsic(
 
         // Alignment of T, must be a constant integer value:
         let alignment_ty = Type::i32(bx.cx());
-        let alignment = CodegenCx::c_i32(bx.cx(), bx.cx().align_of(in_elem).abi() as i32);
+        let alignment = bx.cx().c_i32(bx.cx().align_of(in_elem).abi() as i32);
 
         // Truncate the mask vector to a vector of i1s:
         let (mask, mask_ty) = {
@@ -1502,7 +1502,7 @@ fn generic_simd_intrinsic(
 
         // Alignment of T, must be a constant integer value:
         let alignment_ty = Type::i32(bx.cx());
-        let alignment = CodegenCx::c_i32(bx.cx(), bx.cx().align_of(in_elem).abi() as i32);
+        let alignment = bx.cx().c_i32(bx.cx().align_of(in_elem).abi() as i32);
 
         // Truncate the mask vector to a vector of i1s:
         let (mask, mask_ty) = {
@@ -1580,8 +1580,8 @@ fn generic_simd_intrinsic(
                         } else {
                             // unordered arithmetic reductions do not:
                             match f.bit_width() {
-                                32 => CodegenCx::c_undef(Type::f32(bx.cx())),
-                                64 => CodegenCx::c_undef(Type::f64(bx.cx())),
+                                32 => bx.cx().c_undef(Type::f32(bx.cx())),
+                                64 => bx.cx().c_undef(Type::f64(bx.cx())),
                                 v => {
                                     return_error!(r#"
 unsupported {} from `{}` with element `{}` of size `{}` to `{}`"#,

src/librustc_codegen_llvm/meth.rs

@@ -96,7 +96,7 @@ pub fn get_vtable(
     }
 
     // Not in the cache. Build it.
-    let nullptr = CodegenCx::c_null(Type::i8p(cx));
+    let nullptr = cx.c_null(Type::i8p(cx));
 
     let (size, align) = cx.size_and_align_of(ty);
     let mut components: Vec<_> = [