Use the method form for CodegenCx everywhere

denismerigoux · denismerigoux · commit 29591b5c833d · 2018-09-06T14:57:54.000-07:00
diff --git a/src/librustc_codegen_llvm/abi.rs b/src/librustc_codegen_llvm/abi.rs
@@ -242,7 +242,7 @@ impl ArgTypeExt<'ll, 'tcx> for ArgType<'tcx, Ty<'tcx>> {
                 base::call_memcpy(bx,
                                   bx.pointercast(dst.llval, Type::i8p(cx)),
                                   bx.pointercast(llscratch, Type::i8p(cx)),
-                                  CodegenCx::c_usize(cx, self.layout.size.bytes()),
+                                  cx.c_usize(self.layout.size.bytes()),
                                   self.layout.align.min(scratch_align),
                                   MemFlags::empty());
 
diff --git a/src/librustc_codegen_llvm/asm.rs b/src/librustc_codegen_llvm/asm.rs
@@ -107,7 +107,7 @@ pub fn codegen_inline_asm(
         let kind = llvm::LLVMGetMDKindIDInContext(bx.cx().llcx,
             key.as_ptr() as *const c_char, key.len() as c_uint);
 
-        let val: &'ll Value = CodegenCx::c_i32(bx.cx(), ia.ctxt.outer().as_u32() as i32);
+        let val: &'ll Value = bx.cx().c_i32(ia.ctxt.outer().as_u32() as i32);
 
         llvm::LLVMSetMetadata(r, kind,
             llvm::LLVMMDNodeInContext(bx.cx().llcx, &val, 1));
diff --git a/src/librustc_codegen_llvm/base.rs b/src/librustc_codegen_llvm/base.rs
@@ -157,14 +157,14 @@ pub fn bin_op_to_fcmp_predicate(op: hir::BinOpKind) -> RealPredicate {
     }
 }
 
-pub fn compare_simd_types(
-    bx: &Builder<'a, 'll, 'tcx, &'ll Value>,
-    lhs: &'ll Value,
-    rhs: &'ll Value,
+pub fn compare_simd_types<'a, 'll:'a, 'tcx:'ll, Builder : BuilderMethods<'a, 'll, 'tcx>>(
+    bx: &Builder,
+    lhs: Builder::Value,
+    rhs: Builder::Value,
     t: Ty<'tcx>,
-    ret_ty: &'ll Type,
+    ret_ty: Builder::Type,
     op: hir::BinOpKind
-) -> &'ll Value {
+) -> Builder::Value {
     let signed = match t.sty {
         ty::Float(_) => {
             let cmp = bin_op_to_fcmp_predicate(op);
@@ -198,7 +198,7 @@ pub fn unsized_info(
     let (source, target) = cx.tcx.struct_lockstep_tails(source, target);
     match (&source.sty, &target.sty) {
         (&ty::Array(_, len), &ty::Slice(_)) => {
-            CodegenCx::c_usize(cx, len.unwrap_usize(cx.tcx))
+            cx.c_usize(len.unwrap_usize(cx.tcx))
         }
         (&ty::Dynamic(..), &ty::Dynamic(..)) => {
             // For now, upcasts are limited to changes in marker
@@ -444,8 +444,8 @@ pub fn call_memcpy<'a, 'll: 'a, 'tcx: 'll>(
     let src_ptr = bx.pointercast(src, Type::i8p(cx));
     let dst_ptr = bx.pointercast(dst, Type::i8p(cx));
     let size = bx.intcast(n_bytes, cx.isize_ty, false);
-    let align = CodegenCx::c_i32(cx, align.abi() as i32);
-    let volatile = CodegenCx::c_bool(cx, flags.contains(MemFlags::VOLATILE));
+    let align = cx.c_i32(align.abi() as i32);
+    let volatile = cx.c_bool(flags.contains(MemFlags::VOLATILE));
     bx.call(memcpy, &[dst_ptr, src_ptr, size, align, volatile], None);
 }
 
@@ -462,7 +462,7 @@ pub fn memcpy_ty<'a, 'll: 'a, 'tcx: 'll>(
         return;
     }
 
-    call_memcpy(bx, dst, src, CodegenCx::c_usize(bx.cx(), size), align, flags);
+    call_memcpy(bx, dst, src, bx.cx().c_usize(size), align, flags);
 }
 
 pub fn call_memset(
@@ -476,7 +476,7 @@ pub fn call_memset(
     let ptr_width = &bx.cx().sess().target.target.target_pointer_width;
     let intrinsic_key = format!("llvm.memset.p0i8.i{}", ptr_width);
     let llintrinsicfn = bx.cx().get_intrinsic(&intrinsic_key);
-    let volatile = CodegenCx::c_bool(bx.cx(), volatile);
+    let volatile = bx.cx().c_bool(volatile);
     bx.call(llintrinsicfn, &[ptr, fill_byte, size, align, volatile], None)
 }
 
diff --git a/src/librustc_codegen_llvm/builder.rs b/src/librustc_codegen_llvm/builder.rs
@@ -607,7 +607,7 @@ impl BuilderMethods<'a, 'll, 'tcx>
                 // *always* point to a metadata value of the integer 1.
                 //
                 // [1]: http://llvm.org/docs/LangRef.html#store-instruction
-                let one = CodegenCx::c_i32(self.cx, 1);
+                let one = self.cx.c_i32(1);
                 let node = llvm::LLVMMDNodeInContext(self.cx.llcx, &one, 1);
                 llvm::LLVMSetMetadata(store, llvm::MD_nontemporal as c_uint, node);
             }
@@ -848,7 +848,7 @@ impl BuilderMethods<'a, 'll, 'tcx>
         unsafe {
             let elt_ty = self.cx.val_ty(elt);
             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 = 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))
         }
@@ -1245,7 +1245,7 @@ impl BuilderMethods<'a, 'll, 'tcx>
         let lifetime_intrinsic = self.cx.get_intrinsic(intrinsic);
 
         let ptr = self.pointercast(ptr, type_::Type::i8p(self.cx));
-        self.call(lifetime_intrinsic, &[CodegenCx::c_u64(self.cx, size), ptr], None);
+        self.call(lifetime_intrinsic, &[self.cx.c_u64(size), ptr], None);
     }
 
     fn call(&self, llfn: &'ll Value, args: &[&'ll Value],
diff --git a/src/librustc_codegen_llvm/debuginfo/gdb.rs b/src/librustc_codegen_llvm/debuginfo/gdb.rs
@@ -30,7 +30,7 @@ pub fn insert_reference_to_gdb_debug_scripts_section_global(bx: &Builder<'_, 'll
         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
         // LLVM to keep around the reference to the global.
-        let indices = [CodegenCx::c_i32(bx.cx(), 0), CodegenCx::c_i32(bx.cx(), 0)];
+        let indices = [bx.cx().c_i32(0), bx.cx().c_i32(0)];
         let element = bx.inbounds_gep(gdb_debug_scripts_section, &indices);
         let volative_load_instruction = bx.volatile_load(element);
         unsafe {
@@ -64,7 +64,7 @@ pub fn get_or_insert_gdb_debug_scripts_section_global(cx: &CodegenCx<'ll, '_, &'
                 bug!("symbol `{}` is already defined", section_var_name)
             });
             llvm::LLVMSetSection(section_var, section_name.as_ptr() as *const _);
-            llvm::LLVMSetInitializer(section_var, CodegenCx::c_bytes(cx, section_contents));
+            llvm::LLVMSetInitializer(section_var, cx.c_bytes(section_contents));
             llvm::LLVMSetGlobalConstant(section_var, llvm::True);
             llvm::LLVMSetUnnamedAddr(section_var, llvm::True);
             llvm::LLVMRustSetLinkage(section_var, llvm::Linkage::LinkOnceODRLinkage);
diff --git a/src/librustc_codegen_llvm/glue.rs b/src/librustc_codegen_llvm/glue.rs
@@ -16,7 +16,6 @@ use std;
 
 use builder::Builder;
 use common::*;
-use context::CodegenCx;
 use meth;
 use rustc::ty::layout::LayoutOf;
 use rustc::ty::{self, Ty};
@@ -66,8 +65,8 @@ pub fn size_and_align_of_dst(
             let sized_align = layout.align.abi();
             debug!("DST {} statically sized prefix size: {} align: {}",
                    t, sized_size, sized_align);
-            let sized_size = CodegenCx::c_usize(cx, sized_size);
-            let sized_align = CodegenCx::c_usize(cx, sized_align);
+            let sized_size = cx.c_usize(sized_size);
+            let sized_align = cx.c_usize(sized_align);
 
             // Recurse to get the size of the dynamically sized field (must be
             // the last field).
@@ -98,7 +97,7 @@ pub fn size_and_align_of_dst(
                 (Some(sized_align), Some(unsized_align)) => {
                     // If both alignments are constant, (the sized_align should always be), then
                     // pick the correct alignment statically.
-                    CodegenCx::c_usize(cx, std::cmp::max(sized_align, unsized_align) as u64)
+                    cx.c_usize(std::cmp::max(sized_align, unsized_align) as u64)
                 }
                 _ => bx.select(bx.icmp(IntPredicate::IntUGT, sized_align, unsized_align),
                                 sized_align,
@@ -116,7 +115,7 @@ pub fn size_and_align_of_dst(
             //
             //   `(size + (align-1)) & -align`
 
-            let addend = bx.sub(align, CodegenCx::c_usize(bx.cx(), 1));
+            let addend = bx.sub(align, bx.cx().c_usize(1));
             let size = bx.and(bx.add(size, addend), bx.neg(align));
 
             (size, align)
diff --git a/src/librustc_codegen_llvm/interfaces/backend.rs b/src/librustc_codegen_llvm/interfaces/backend.rs
@@ -8,8 +8,10 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+use std::fmt::Debug;
+
 pub trait Backend {
-    type Value;
+    type Value : Debug + PartialEq;
     type BasicBlock;
     type Type;
     type Context;
diff --git a/src/librustc_codegen_llvm/interfaces/common.rs b/src/librustc_codegen_llvm/interfaces/common.rs
@@ -47,9 +47,10 @@ pub trait CommonMethods : Backend + CommonWriteMethods {
     fn const_get_elt(&self, v: Self::Value, idx: u64) -> Self::Value;
     fn const_get_real(&self, v: Self::Value) -> Option<(f64, bool)>;
     fn const_to_uint(&self, v: Self::Value) -> u64;
+    fn const_to_opt_u128(&self, v: Self::Value, sign_ext: bool) -> Option<u128>;
+
     fn is_const_integral(&self, v: Self::Value) -> bool;
     fn is_const_real(&self, v: Self::Value) -> bool;
-    fn const_to_opt_u128(&self, v: Self::Value, sign_ext: bool) -> Option<u128>;
 }
 
 pub trait CommonWriteMethods : Backend {
diff --git a/src/librustc_codegen_llvm/meth.rs b/src/librustc_codegen_llvm/meth.rs
@@ -44,7 +44,7 @@ impl<'a, 'tcx> VirtualIndex {
         let llvtable = bx.pointercast(llvtable, fn_ty.llvm_type(bx.cx()).ptr_to().ptr_to());
         let ptr_align = bx.tcx().data_layout.pointer_align;
         let ptr = bx.load(
-            bx.inbounds_gep(llvtable, &[CodegenCx::c_usize(bx.cx(), self.0)]),
+            bx.inbounds_gep(llvtable, &[bx.cx().c_usize(self.0)]),
             ptr_align
         );
         bx.nonnull_metadata(ptr);
@@ -64,7 +64,7 @@ impl<'a, 'tcx> VirtualIndex {
         let llvtable = bx.pointercast(llvtable, Type::isize(bx.cx()).ptr_to());
         let usize_align = bx.tcx().data_layout.pointer_align;
         let ptr = bx.load(
-            bx.inbounds_gep(llvtable, &[CodegenCx::c_usize(bx.cx(), self.0)]),
+            bx.inbounds_gep(llvtable, &[bx.cx().c_usize(self.0)]),
             usize_align
         );
         // Vtable loads are invariant
@@ -101,8 +101,8 @@ pub fn get_vtable(
     let (size, align) = cx.size_and_align_of(ty);
     let mut components: Vec<_> = [
         callee::get_fn(cx, monomorphize::resolve_drop_in_place(cx.tcx, ty)),
-        CodegenCx::c_usize(cx, size.bytes()),
-        CodegenCx::c_usize(cx, align.abi())
+        cx.c_usize(size.bytes()),
+        cx.c_usize(align.abi())
     ].iter().cloned().collect();
 
     if let Some(trait_ref) = trait_ref {
@@ -116,7 +116,7 @@ pub fn get_vtable(
         components.extend(methods);
     }
 
-    let vtable_const = CodegenCx::c_struct(cx, &components, false);
+    let vtable_const = cx.c_struct(&components, false);
     let align = cx.data_layout().pointer_align;
     let vtable = consts::addr_of(cx, vtable_const, align, Some("vtable"));
 
diff --git a/src/librustc_codegen_llvm/mir/block.rs b/src/librustc_codegen_llvm/mir/block.rs
@@ -19,7 +19,6 @@ use base;
 use callee;
 use builder::{Builder, MemFlags};
 use common::{self, IntPredicate};
-use context::CodegenCx;
 use consts;
 use meth;
 use monomorphize;
@@ -347,7 +346,7 @@ impl FunctionCx<'a, 'll, 'tcx, &'ll Value> {
 
                 // Pass the condition through llvm.expect for branch hinting.
                 let expect = bx.cx().get_intrinsic(&"llvm.expect.i1");
-                let cond = bx.call(expect, &[cond, CodegenCx::c_bool(bx.cx(), expected)], None);
+                let cond = bx.call(expect, &[cond, bx.cx().c_bool(expected)], None);
 
                 // Create the failure block and the conditional branch to it.
                 let lltarget = llblock(self, target);
@@ -365,9 +364,9 @@ impl FunctionCx<'a, 'll, 'tcx, &'ll Value> {
                 // Get the location information.
                 let loc = bx.sess().source_map().lookup_char_pos(span.lo());
                 let filename = Symbol::intern(&loc.file.name.to_string()).as_str();
-                let filename = CodegenCx::c_str_slice(bx.cx(), filename);
-                let line = CodegenCx::c_u32(bx.cx(), loc.line as u32);
-                let col = CodegenCx::c_u32(bx.cx(), loc.col.to_usize() as u32 + 1);
+                let filename = bx.cx().c_str_slice(filename);
+                let line = bx.cx().c_u32(loc.line as u32);
+                let col = bx.cx().c_u32(loc.col.to_usize() as u32 + 1);
                 let align = tcx.data_layout.aggregate_align
                     .max(tcx.data_layout.i32_align)
                     .max(tcx.data_layout.pointer_align);
@@ -378,8 +377,7 @@ impl FunctionCx<'a, 'll, 'tcx, &'ll Value> {
                         let len = self.codegen_operand(&mut bx, len).immediate();
                         let index = self.codegen_operand(&mut bx, index).immediate();
 
-                        let file_line_col = CodegenCx::c_struct(bx.cx(),
-                             &[filename, line, col], false);
+                        let file_line_col = bx.cx().c_struct(                             &[filename, line, col], false);
                         let file_line_col = consts::addr_of(bx.cx(),
                                                             file_line_col,
                                                             align,
@@ -390,9 +388,8 @@ impl FunctionCx<'a, 'll, 'tcx, &'ll Value> {
                     _ => {
                         let str = msg.description();
                         let msg_str = Symbol::intern(str).as_str();
-                        let msg_str = CodegenCx::c_str_slice(bx.cx(), msg_str);
-                        let msg_file_line_col = CodegenCx::c_struct(bx.cx(),
-                                                     &[msg_str, filename, line, col],
+                        let msg_str = bx.cx().c_str_slice(msg_str);
+                        let msg_file_line_col = bx.cx().c_struct(                                                     &[msg_str, filename, line, col],
                                                      false);
                         let msg_file_line_col = consts::addr_of(bx.cx(),
                                                                 msg_file_line_col,
diff --git a/src/librustc_codegen_llvm/mir/constant.rs b/src/librustc_codegen_llvm/mir/constant.rs
@@ -97,7 +97,7 @@ pub fn const_alloc_to_llvm(cx: &CodegenCx<'ll, '_, &'ll Value>, alloc: &Allocati
         assert_eq!(offset as usize as u64, offset);
         let offset = offset as usize;
         if offset > next_offset {
-            llvals.push(CodegenCx::c_bytes(cx, &alloc.bytes[next_offset..offset]));
+            llvals.push(cx.c_bytes(&alloc.bytes[next_offset..offset]));
         }
         let ptr_offset = read_target_uint(
             layout.endian,
@@ -115,10 +115,10 @@ pub fn const_alloc_to_llvm(cx: &CodegenCx<'ll, '_, &'ll Value>, alloc: &Allocati
         next_offset = offset + pointer_size;
     }
     if alloc.bytes.len() >= next_offset {
-        llvals.push(CodegenCx::c_bytes(cx, &alloc.bytes[next_offset ..]));
+        llvals.push(cx.c_bytes(&alloc.bytes[next_offset ..]));
     }
 
-    CodegenCx::c_struct(cx, &llvals, true)
+    cx.c_struct(&llvals, true)
 }
 
 pub fn codegen_static_initializer(
@@ -208,7 +208,7 @@ impl FunctionCx<'a, 'll, 'tcx, &'ll Value> {
                         bug!("simd shuffle field {:?}", field)
                     }
                 }).collect();
-                let llval = CodegenCx::c_struct(bx.cx(), &values?, false);
+                let llval = bx.cx().c_struct(&values?, false);
                 Ok((llval, c.ty))
             })
             .unwrap_or_else(|e| {
diff --git a/src/librustc_codegen_llvm/mir/mod.rs b/src/librustc_codegen_llvm/mir/mod.rs
@@ -420,7 +420,7 @@ fn create_funclets(
                 // it's null. The 64 here is actually a bitfield which
                 // represents that this is a catch-all block.
                 let null = bx.cx().c_null(Type::i8p(bx.cx()));
-                let sixty_four = CodegenCx::c_i32(bx.cx(), 64);
+                let sixty_four = bx.cx().c_i32(64);
                 cleanup = cp_bx.catch_pad(cs, &[null, sixty_four, null]);
                 cp_bx.br(llbb);
             }
