Move mem{cpy,move,set} to MemoryBuilderMethods

Author: bjorn3

src/librustc_codegen_llvm/builder.rs

@@ -354,6 +354,63 @@ impl MemoryBuilderMethods<'tcx> for Builder<'a, 'll, 'tcx> {
             llvm::LLVMBuildStructGEP(self.llbuilder, ptr, idx as c_uint, noname())
         }
     }
+
+    fn memcpy(&mut self, dst: &'ll Value, dst_align: Align,
+                  src: &'ll Value, src_align: Align,
+                  size: &'ll Value, flags: MemFlags) {
+        if flags.contains(MemFlags::NONTEMPORAL) {
+            // HACK(nox): This is inefficient but there is no nontemporal memcpy.
+            let val = self.load(src, src_align);
+            let ptr = self.pointercast(dst, self.type_ptr_to(self.val_ty(val)));
+            self.store_with_flags(val, ptr, dst_align, flags);
+            return;
+        }
+        let size = self.intcast(size, self.type_isize(), false);
+        let is_volatile = flags.contains(MemFlags::VOLATILE);
+        let dst = self.pointercast(dst, self.type_i8p());
+        let src = self.pointercast(src, self.type_i8p());
+        unsafe {
+            llvm::LLVMRustBuildMemCpy(self.llbuilder, dst, dst_align.bytes() as c_uint,
+                                      src, src_align.bytes() as c_uint, size, is_volatile);
+        }
+    }
+
+    fn memmove(&mut self, dst: &'ll Value, dst_align: Align,
+                  src: &'ll Value, src_align: Align,
+                  size: &'ll Value, flags: MemFlags) {
+        if flags.contains(MemFlags::NONTEMPORAL) {
+            // HACK(nox): This is inefficient but there is no nontemporal memmove.
+            let val = self.load(src, src_align);
+            let ptr = self.pointercast(dst, self.type_ptr_to(self.val_ty(val)));
+            self.store_with_flags(val, ptr, dst_align, flags);
+            return;
+        }
+        let size = self.intcast(size, self.type_isize(), false);
+        let is_volatile = flags.contains(MemFlags::VOLATILE);
+        let dst = self.pointercast(dst, self.type_i8p());
+        let src = self.pointercast(src, self.type_i8p());
+        unsafe {
+            llvm::LLVMRustBuildMemMove(self.llbuilder, dst, dst_align.bytes() as c_uint,
+                                      src, src_align.bytes() as c_uint, size, is_volatile);
+        }
+    }
+
+    fn memset(
+        &mut self,
+        ptr: &'ll Value,
+        fill_byte: &'ll Value,
+        size: &'ll Value,
+        align: Align,
+        flags: MemFlags,
+    ) {
+        let ptr_width = &self.sess().target.target.target_pointer_width;
+        let intrinsic_key = format!("llvm.memset.p0i8.i{}", ptr_width);
+        let llintrinsicfn = self.get_intrinsic(&intrinsic_key);
+        let ptr = self.pointercast(ptr, self.type_i8p());
+        let align = self.const_u32(align.bytes() as u32);
+        let volatile = self.const_bool(flags.contains(MemFlags::VOLATILE));
+        self.call(llintrinsicfn, &[ptr, fill_byte, size, align, volatile], None);
+    }
 }
 
 impl BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
@@ -928,63 +985,6 @@ impl BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
         }
     }
 
-    fn memcpy(&mut self, dst: &'ll Value, dst_align: Align,
-                  src: &'ll Value, src_align: Align,
-                  size: &'ll Value, flags: MemFlags) {
-        if flags.contains(MemFlags::NONTEMPORAL) {
-            // HACK(nox): This is inefficient but there is no nontemporal memcpy.
-            let val = self.load(src, src_align);
-            let ptr = self.pointercast(dst, self.type_ptr_to(self.val_ty(val)));
-            self.store_with_flags(val, ptr, dst_align, flags);
-            return;
-        }
-        let size = self.intcast(size, self.type_isize(), false);
-        let is_volatile = flags.contains(MemFlags::VOLATILE);
-        let dst = self.pointercast(dst, self.type_i8p());
-        let src = self.pointercast(src, self.type_i8p());
-        unsafe {
-            llvm::LLVMRustBuildMemCpy(self.llbuilder, dst, dst_align.bytes() as c_uint,
-                                      src, src_align.bytes() as c_uint, size, is_volatile);
-        }
-    }
-
-    fn memmove(&mut self, dst: &'ll Value, dst_align: Align,
-                  src: &'ll Value, src_align: Align,
-                  size: &'ll Value, flags: MemFlags) {
-        if flags.contains(MemFlags::NONTEMPORAL) {
-            // HACK(nox): This is inefficient but there is no nontemporal memmove.
-            let val = self.load(src, src_align);
-            let ptr = self.pointercast(dst, self.type_ptr_to(self.val_ty(val)));
-            self.store_with_flags(val, ptr, dst_align, flags);
-            return;
-        }
-        let size = self.intcast(size, self.type_isize(), false);
-        let is_volatile = flags.contains(MemFlags::VOLATILE);
-        let dst = self.pointercast(dst, self.type_i8p());
-        let src = self.pointercast(src, self.type_i8p());
-        unsafe {
-            llvm::LLVMRustBuildMemMove(self.llbuilder, dst, dst_align.bytes() as c_uint,
-                                      src, src_align.bytes() as c_uint, size, is_volatile);
-        }
-    }
-
-    fn memset(
-        &mut self,
-        ptr: &'ll Value,
-        fill_byte: &'ll Value,
-        size: &'ll Value,
-        align: Align,
-        flags: MemFlags,
-    ) {
-        let ptr_width = &self.sess().target.target.target_pointer_width;
-        let intrinsic_key = format!("llvm.memset.p0i8.i{}", ptr_width);
-        let llintrinsicfn = self.get_intrinsic(&intrinsic_key);
-        let ptr = self.pointercast(ptr, self.type_i8p());
-        let align = self.const_u32(align.bytes() as u32);
-        let volatile = self.const_bool(flags.contains(MemFlags::VOLATILE));
-        self.call(llintrinsicfn, &[ptr, fill_byte, size, align, volatile], None);
-    }
-
     fn select(
         &mut self, cond: &'ll Value,
         then_val: &'ll Value,

src/librustc_codegen_ssa/mir/operand.rs

@@ -54,10 +54,12 @@ impl<V: CodegenObject> fmt::Debug for OperandRef<'tcx, V> {
 }
 
 impl<'a, 'tcx: 'a, V: CodegenObject> OperandRef<'tcx, V> {
-    pub fn new_zst<Bx: BuilderMethods<'a, 'tcx, Value = V>>(
+    pub fn new_zst<Bx: HasCodegen<'tcx, Value = V>>(
         bx: &mut Bx,
         layout: TyLayout<'tcx>
-    ) -> OperandRef<'tcx, V> {
+    ) -> OperandRef<'tcx, V>
+        where Bx::CodegenCx: ConstMethods<'tcx>
+    {
         assert!(layout.is_zst());
         OperandRef {
             val: OperandValue::Immediate(bx.const_undef(bx.immediate_backend_type(layout))),

src/librustc_codegen_ssa/traits/builder.rs

@@ -62,6 +62,33 @@ pub trait MemoryBuilderMethods<'tcx>: HasCodegen<'tcx> {
     fn gep(&mut self, ptr: Self::Value, indices: &[Self::Value]) -> Self::Value;
     fn inbounds_gep(&mut self, ptr: Self::Value, indices: &[Self::Value]) -> Self::Value;
     fn struct_gep(&mut self, ptr: Self::Value, idx: u64) -> Self::Value;
+
+    fn memcpy(
+        &mut self,
+        dst: Self::Value,
+        dst_align: Align,
+        src: Self::Value,
+        src_align: Align,
+        size: Self::Value,
+        flags: MemFlags,
+    );
+    fn memmove(
+        &mut self,
+        dst: Self::Value,
+        dst_align: Align,
+        src: Self::Value,
+        src_align: Align,
+        size: Self::Value,
+        flags: MemFlags,
+    );
+    fn memset(
+        &mut self,
+        ptr: Self::Value,
+        fill_byte: Self::Value,
+        size: Self::Value,
+        align: Align,
+        flags: MemFlags,
+    );
 }
 
 pub trait BuilderMethods<'a, 'tcx: 'a>:
@@ -176,33 +203,6 @@ pub trait BuilderMethods<'a, 'tcx: 'a>:
         dia: AsmDialect,
     ) -> Option<Self::Value>;
 
-    fn memcpy(
-        &mut self,
-        dst: Self::Value,
-        dst_align: Align,
-        src: Self::Value,
-        src_align: Align,
-        size: Self::Value,
-        flags: MemFlags,
-    );
-    fn memmove(
-        &mut self,
-        dst: Self::Value,
-        dst_align: Align,
-        src: Self::Value,
-        src_align: Align,
-        size: Self::Value,
-        flags: MemFlags,
-    );
-    fn memset(
-        &mut self,
-        ptr: Self::Value,
-        fill_byte: Self::Value,
-        size: Self::Value,
-        align: Align,
-        flags: MemFlags,
-    );
-
     fn select(
         &mut self,
         cond: Self::Value,

src/librustc_codegen_ssa/traits/mod.rs

@@ -30,7 +30,7 @@ mod write;
 pub use self::abi::{AbiBuilderMethods, AbiMethods};
 pub use self::asm::{AsmBuilderMethods, AsmMethods};
 pub use self::backend::{Backend, BackendTypes, ExtraBackendMethods};
-pub use self::builder::{BuilderMethods, MemoryBuilderMethods, OverflowOp};
+pub use self::builder::*;
 pub use self::consts::ConstMethods;
 pub use self::debuginfo::{DebugInfoBuilderMethods, DebugInfoMethods};
 pub use self::declare::{DeclareMethods, PreDefineMethods};