Move copy_slice() into a submodule

Move implementation of copy_slice() into a submodule, so we could
provide different implenations on different platforms.

Signed-off-by: Liu Jiang <[email protected]>

Author: jiangliu

src/volatile_memory.rs

@@ -38,6 +38,8 @@ use std::usize;
 
 use crate::{ByteValued, Bytes};
 
+use copy_slice_impl::copy_slice;
+
 /// `VolatileMemory` related errors.
 #[allow(missing_docs)]
 #[derive(Debug)]
@@ -463,57 +465,6 @@ impl<'a> VolatileSlice<'a> {
     }
 }
 
-// Return the largest value that `addr` is aligned to. Forcing this function to return 1 will
-// cause test_non_atomic_access to fail.
-fn alignment(addr: usize) -> usize {
-    // Rust is silly and does not let me write addr & -addr.
-    addr & (!addr + 1)
-}
-
-// Has the same safety requirements as `read_volatile` + `write_volatile`, namely:
-// - `src_addr` and `dst_addr` must be valid for reads/writes.
-// - `src_addr` and `dst_addr` must be properly aligned with respect to `align`.
-// - `src_addr` must point to a properly initialized value, which is true here because
-//   we're only using integer primitives.
-unsafe fn copy_single(align: usize, src_addr: usize, dst_addr: usize) {
-    match align {
-        8 => write_volatile(dst_addr as *mut u64, read_volatile(src_addr as *const u64)),
-        4 => write_volatile(dst_addr as *mut u32, read_volatile(src_addr as *const u32)),
-        2 => write_volatile(dst_addr as *mut u16, read_volatile(src_addr as *const u16)),
-        1 => write_volatile(dst_addr as *mut u8, read_volatile(src_addr as *const u8)),
-        _ => unreachable!(),
-    }
-}
-
-fn copy_slice(dst: &mut [u8], src: &[u8]) -> usize {
-    let total = min(src.len(), dst.len());
-    let mut left = total;
-
-    let mut src_addr = src.as_ptr() as usize;
-    let mut dst_addr = dst.as_ptr() as usize;
-    let align = min(alignment(src_addr), alignment(dst_addr));
-
-    let mut copy_aligned_slice = |min_align| {
-        while align >= min_align && left >= min_align {
-            // Safe because we check alignment beforehand, the memory areas are valid for
-            // reads/writes, and the source always contains a valid value.
-            unsafe { copy_single(min_align, src_addr, dst_addr) };
-            src_addr += min_align;
-            dst_addr += min_align;
-            left -= min_align;
-        }
-    };
-
-    if size_of::<usize>() > 4 {
-        copy_aligned_slice(8);
-    }
-    copy_aligned_slice(4);
-    copy_aligned_slice(2);
-    copy_aligned_slice(1);
-
-    total
-}
-
 impl Bytes<usize> for VolatileSlice<'_> {
     type E = Error;
 
@@ -1081,6 +1032,61 @@ impl<'a> From<VolatileSlice<'a>> for VolatileArrayRef<'a, u8> {
     }
 }
 
+// Return the largest value that `addr` is aligned to. Forcing this function to return 1 will
+// cause test_non_atomic_access to fail.
+fn alignment(addr: usize) -> usize {
+    // Rust is silly and does not let me write addr & -addr.
+    addr & (!addr + 1)
+}
+
+mod copy_slice_impl {
+    use super::*;
+
+    // Has the same safety requirements as `read_volatile` + `write_volatile`, namely:
+    // - `src_addr` and `dst_addr` must be valid for reads/writes.
+    // - `src_addr` and `dst_addr` must be properly aligned with respect to `align`.
+    // - `src_addr` must point to a properly initialized value, which is true here because
+    //   we're only using integer primitives.
+    unsafe fn copy_single(align: usize, src_addr: usize, dst_addr: usize) {
+        match align {
+            8 => write_volatile(dst_addr as *mut u64, read_volatile(src_addr as *const u64)),
+            4 => write_volatile(dst_addr as *mut u32, read_volatile(src_addr as *const u32)),
+            2 => write_volatile(dst_addr as *mut u16, read_volatile(src_addr as *const u16)),
+            1 => write_volatile(dst_addr as *mut u8, read_volatile(src_addr as *const u8)),
+            _ => unreachable!(),
+        }
+    }
+
+    pub(super) fn copy_slice(dst: &mut [u8], src: &[u8]) -> usize {
+        let total = min(src.len(), dst.len());
+        let mut left = total;
+
+        let mut src_addr = src.as_ptr() as usize;
+        let mut dst_addr = dst.as_ptr() as usize;
+        let align = min(alignment(src_addr), alignment(dst_addr));
+
+        let mut copy_aligned_slice = |min_align| {
+            while align >= min_align && left >= min_align {
+                // Safe because we check alignment beforehand, the memory areas are valid for
+                // reads/writes, and the source always contains a valid value.
+                unsafe { copy_single(min_align, src_addr, dst_addr) };
+                src_addr += min_align;
+                dst_addr += min_align;
+                left -= min_align;
+            }
+        };
+
+        if size_of::<usize>() > 4 {
+            copy_aligned_slice(8);
+        }
+        copy_aligned_slice(4);
+        copy_aligned_slice(2);
+        copy_aligned_slice(1);
+
+        total
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;