Transfered memcpy and memset to BuilderMethods

Author: denismerigoux

src/librustc_codegen_llvm/abi.rs

@@ -9,7 +9,6 @@
 // except according to those terms.
 
 use llvm::{self, AttributePlace};
-use base;
 use builder::{Builder, MemFlags};
 use common::C_usize;
 use context::CodegenCx;
@@ -239,12 +238,13 @@ impl ArgTypeExt<'ll, 'tcx> for ArgType<'tcx, Ty<'tcx>> {
                 bx.store(val, llscratch, scratch_align);
 
                 // ...and then memcpy it to the intended destination.
-                base::call_memcpy(bx,
-                                  bx.pointercast(dst.llval, cx.type_i8p()),
-                                  bx.pointercast(llscratch, cx.type_i8p()),
-                                  cx.const_usize(self.layout.size.bytes()),
-                                  self.layout.align.min(scratch_align),
-                                  MemFlags::empty());
+                bx.call_memcpy(
+                    bx.pointercast(dst.llval, cx.type_i8p()),
+                    bx.pointercast(llscratch, cx.type_i8p()),
+                    cx.const_usize(self.layout.size.bytes()),
+                    self.layout.align.min(scratch_align),
+                    MemFlags::empty()
+                );
 
                 bx.lifetime_end(llscratch, scratch_size);
             }

src/librustc_codegen_llvm/base.rs

@@ -432,33 +432,6 @@ pub fn to_immediate_scalar<'a, 'll, 'tcx, Builder : BuilderMethods<'a, 'll, 'tcx
     val
 }
 
-pub fn call_memcpy<'a, 'll: 'a, 'tcx: 'll, Builder : BuilderMethods<'a, 'll, 'tcx>>(
-    bx: &Builder,
-    dst: <Builder::CodegenCx as Backend>::Value,
-    src: <Builder::CodegenCx as Backend>::Value,
-    n_bytes: <Builder::CodegenCx as Backend>::Value,
-    align: Align,
-    flags: MemFlags,
-) {
-    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().type_ptr_to(bx.cx().val_ty(val)));
-        bx.store_with_flags(val, ptr, align, flags);
-        return;
-    }
-    let cx = bx.cx();
-    let ptr_width = &bx.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, cx.type_i8p());
-    let dst_ptr = bx.pointercast(dst, cx.type_i8p());
-    let size = bx.intcast(n_bytes, cx.type_isize(), false);
-    let align = cx.const_i32(align.abi() as i32);
-    let volatile = cx.const_bool(flags.contains(MemFlags::VOLATILE));
-    bx.call(memcpy, &[dst_ptr, src_ptr, size, align, volatile], None);
-}
-
 pub fn memcpy_ty<'a, 'll: 'a, 'tcx: 'll, Builder : BuilderMethods<'a, 'll, 'tcx>>(
     bx: &Builder,
     dst: <Builder::CodegenCx as Backend>::Value,
@@ -472,22 +445,7 @@ pub fn memcpy_ty<'a, 'll: 'a, 'tcx: 'll, Builder : BuilderMethods<'a, 'll, 'tcx>
         return;
     }
 
-    call_memcpy(bx, dst, src, bx.cx().const_usize(size), align, flags);
-}
-
-pub fn call_memset<'a, 'll: 'a, 'tcx: 'll, Builder : BuilderMethods<'a, 'll, 'tcx>>(
-    bx: &Builder,
-    ptr: <Builder::CodegenCx as Backend>::Value,
-    fill_byte: <Builder::CodegenCx as Backend>::Value,
-    size: <Builder::CodegenCx as Backend>::Value,
-    align: <Builder::CodegenCx as Backend>::Value,
-    volatile: bool,
-) -> <Builder::CodegenCx as Backend>::Value {
-    let ptr_width = &bx.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 = bx.cx().const_bool(volatile);
-    bx.call(llintrinsicfn, &[ptr, fill_byte, size, align, volatile], None)
+    bx.call_memcpy(dst, src, bx.cx().const_usize(size), align, flags);
 }
 
 pub fn codegen_instance<'a, 'tcx>(cx: &CodegenCx<'a, 'tcx, &'a Value>, instance: Instance<'tcx>) {

src/librustc_codegen_llvm/builder.rs

@@ -1290,6 +1290,48 @@ impl BuilderMethods<'a, 'll, 'tcx>
         }
     }
 
+    fn call_memcpy(
+        &self,
+        dst: &'ll Value,
+        src: &'ll Value,
+        n_bytes: &'ll Value,
+        align: Align,
+        flags: MemFlags,
+    ) {
+        if flags.contains(MemFlags::NONTEMPORAL) {
+            // HACK(nox): This is inefficient but there is no nontemporal memcpy.
+            let val = &self.load(src, align);
+            let ptr = &self.pointercast(dst, &self.cx().type_ptr_to(&self.cx().val_ty(val)));
+            &self.store_with_flags(val, ptr, align, flags);
+            return;
+        }
+        let cx = &self.cx();
+        let ptr_width = &self.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 = &self.pointercast(src, cx.type_i8p());
+        let dst_ptr = &self.pointercast(dst, cx.type_i8p());
+        let size = &self.intcast(n_bytes, cx.type_isize(), false);
+        let align = cx.const_i32(align.abi() as i32);
+        let volatile = cx.const_bool(flags.contains(MemFlags::VOLATILE));
+        &self.call(memcpy, &[dst_ptr, src_ptr, size, align, volatile], None);
+    }
+
+    fn call_memset(
+        &self,
+        ptr: &'ll Value,
+        fill_byte: &'ll Value,
+        size: &'ll Value,
+        align: &'ll Value,
+        volatile: bool,
+    ) -> &'ll Value {
+        let ptr_width = &self.sess().target.target.target_pointer_width;
+        let intrinsic_key = format!("llvm.memset.p0i8.i{}", ptr_width);
+        let llintrinsicfn = &self.cx().get_intrinsic(&intrinsic_key);
+        let volatile = &self.cx().const_bool(volatile);
+        &self.call(llintrinsicfn, &[ptr, fill_byte, size, align, volatile], None)
+    }
+
     fn zext(&self, val: &'ll Value, dest_ty: &'ll Type) -> &'ll Value {
         self.count_insn("zext");
         unsafe {

src/librustc_codegen_llvm/interfaces/builder.rs

@@ -583,6 +583,25 @@ pub trait BuilderMethods<'a, 'll :'a, 'tcx: 'll> {
         args: &[<Self::CodegenCx as Backend>::Value],
         bundle: Option<&OperandBundleDef<'ll, <Self::CodegenCx as Backend>::Value>>
     ) -> <Self::CodegenCx as Backend>::Value;
+
+    fn call_memcpy(
+        &self,
+        dst: <Self::CodegenCx as Backend>::Value,
+        src: <Self::CodegenCx as Backend>::Value,
+        n_bytes: <Self::CodegenCx as Backend>::Value,
+        align: Align,
+        flags: MemFlags,
+    );
+
+    fn call_memset(
+        &self,
+        ptr: <Self::CodegenCx as Backend>::Value,
+        fill_byte: <Self::CodegenCx as Backend>::Value,
+        size: <Self::CodegenCx as Backend>::Value,
+        align: <Self::CodegenCx as Backend>::Value,
+        volatile: bool,
+    ) -> <Self::CodegenCx as Backend>::Value;
+
     fn zext(
         &self,
         val: <Self::CodegenCx as Backend>::Value,

src/librustc_codegen_llvm/intrinsic.rs

@@ -743,7 +743,7 @@ fn memset_intrinsic(
     let size = cx.const_usize(size.bytes());
     let align = cx.const_i32(align.abi() as i32);
     let dst = bx.pointercast(dst, cx.type_i8p());
-    call_memset(bx, dst, val, bx.mul(size, count), align, volatile)
+    bx.call_memset(dst, val, bx.mul(size, count), align, volatile)
 }
 
 fn try_intrinsic(

src/librustc_codegen_llvm/mir/operand.rs

@@ -348,7 +348,7 @@ impl OperandValue<&'ll Value> {
         // Allocate an appropriate region on the stack, and copy the value into it
         let (llsize, _) = glue::size_and_align_of_dst(bx, unsized_ty, Some(llextra));
         let lldst = bx.array_alloca(bx.cx().type_i8(), llsize, "unsized_tmp", max_align);
-        base::call_memcpy(bx, lldst, llptr, llsize, min_align, flags);
+        bx.call_memcpy(lldst, llptr, llsize, min_align, flags);
 
         // Store the allocated region and the extra to the indirect place.
         let indirect_operand = OperandValue::Pair(lldst, llextra);

src/librustc_codegen_llvm/mir/place.rs

@@ -384,7 +384,7 @@ impl PlaceRef<'tcx, &'ll Value> {
                         let (size, align) = self.layout.size_and_align();
                         let size = bx.cx().const_usize(size.bytes());
                         let align = bx.cx().const_u32(align.abi() as u32);
-                        base::call_memset(bx, llptr, fill_byte, size, align, false);
+                        bx.call_memset(llptr, fill_byte, size, align, false);
                     }
 
                     let niche = self.project_field(bx, 0);

src/librustc_codegen_llvm/mir/rvalue.rs

@@ -110,14 +110,14 @@ impl FunctionCx<'a, 'll, 'tcx, &'ll Value> {
                     // Use llvm.memset.p0i8.* to initialize all zero arrays
                     if bx.cx().is_const_integral(v) && bx.cx().const_to_uint(v) == 0 {
                         let fill = bx.cx().const_u8(0);
-                        base::call_memset(&bx, start, fill, size, align, false);
+                        bx.call_memset(start, fill, size, align, false);
                         return bx;
                     }
 
                     // Use llvm.memset.p0i8.* to initialize byte arrays
                     let v = base::from_immediate(&bx, v);
                     if bx.cx().val_ty(v) == bx.cx().type_i8() {
-                        base::call_memset(&bx, start, v, size, align, false);
+                        bx.call_memset(start, v, size, align, false);
                         return bx;
                     }
                 }