optimize memcpy for ARM

just as it was done in the previous commit memcpy is now written in assembly.
Measurements below.

| Bytes | HEAD | this PR | diff      |
| ----- | ---- | ------- | --------- |
| 0     | 6    | 10      | +66.6667% |
| 1     | 12   | 16      | +33.3333% |
| 2     | 18   | 24      | +33.3333% |
| 3     | 24   | 32      | +33.3333% |
| 4     | 30   | 20      | -33.3333% |
| 16    | 102  | 50      | -50.9804% |
| 64    | 390  | 170     | -56.4103% |
| 256   | 1796 | 650     | -63.8085% |
| 1024  | 7172 | 2570    | -64.1662% |

All times are in clock cycles. The measurements were done on a Cortex-M3
processor running at 8 MHz.

Author: japaric

src/arm.rs

@@ -1,7 +1,7 @@
 use core::intrinsics;
 
 #[cfg(feature = "mem")]
-use mem::{memcpy, memmove, memset};
+use mem::{memmove, memset};
 
 // NOTE This function and the ones below are implemented using assembly because they using a custom
 // calling convention which can't be implemented using a normal Rust function
@@ -209,18 +209,48 @@ __aeabi_memset8:
 5:  bx   lr
 "#);
 
-#[cfg_attr(not(test), no_mangle)]
-pub unsafe extern "aapcs" fn __aeabi_memcpy(dest: *mut u8, src: *const u8, n: usize) {
-    memcpy(dest, src, n);
-}
-#[cfg_attr(not(test), no_mangle)]
-pub unsafe extern "aapcs" fn __aeabi_memcpy4(dest: *mut u8, src: *const u8, n: usize) {
-    memcpy(dest, src, n);
-}
-#[cfg_attr(not(test), no_mangle)]
-pub unsafe extern "aapcs" fn __aeabi_memcpy8(dest: *mut u8, src: *const u8, n: usize) {
-    memcpy(dest, src, n);
-}
+// Assembly optimized memcpy{,4,8}
+global_asm!(r"
+@ fn __aeabi_memcpy(r0: *mut u8, r1: *const u8, r2: usize)
+    .global __aeabi_memcpy
+
+@ fn __aeabi_memcpy4(r0: *mut u8, r1: *const u8, r2: usize)
+@ r0 and r1 are 4-byte aligned
+    .global __aeabi_memcpy4
+
+@ fn __aeabi_memcpy8(r0: *mut u8, r1: *const u8, r2: usize)
+@ r0 and r1 are 8-byte aligned
+    .global __aeabi_memcpy8
+
+__aeabi_memcpy4:
+__aeabi_memcpy8:
+    @ word-wise copy loop
+    @ branch to '__aeabi_memcpy' if r2 < 4
+    cmp r2, #4
+    blt __aeabi_memcpy
+
+    ldr  r3, [r1]
+    adds r1, 4
+    str  r3, [r0]
+    adds r0, 4
+    subs r2, r2, #4
+    b    __aeabi_memcpy4
+
+__aeabi_memcpy:
+    @ branch to '2' if r2 == 0
+    cmp  r2, #0
+    beq  2f
+
+1:  @ byte-wise copy loop
+    ldrb r3, [r1]
+    adds r1, #1
+    strb r3, [r0]
+    adds r0, #1
+    subs r2, r2, #1
+    bne  1b
+
+2:  bx   lr
+"#);
 
 #[cfg_attr(not(test), no_mangle)]
 pub unsafe extern "aapcs" fn __aeabi_memmove(dest: *mut u8, src: *const u8, n: usize) {

tests/aeabi_memcpy.rs

@@ -0,0 +1,69 @@
+#![cfg(all(target_arch = "arm",
+           not(any(target_env = "gnu", target_env = "musl")),
+           target_os = "linux",
+           feature = "mem"))]
+#![feature(compiler_builtins_lib)]
+#![no_std]
+
+extern crate compiler_builtins;
+
+// test runner
+extern crate utest_cortex_m_qemu;
+
+// overrides `panic!`
+#[macro_use]
+extern crate utest_macros;
+
+macro_rules! panic {
+    ($($tt:tt)*) => {
+        upanic!($($tt)*);
+    };
+}
+
+extern "C" {
+    fn __aeabi_memcpy(dest: *mut u8, src: *const u8, n: usize);
+    fn __aeabi_memcpy4(dest: *mut u8, src: *const u8, n: usize);
+}
+
+struct Aligned {
+    array: [u8; 8],
+    _alignment: [u32; 0],
+}
+
+impl Aligned {
+    fn new(array: [u8; 8]) -> Self {
+        Aligned {
+            array: array,
+            _alignment: [],
+        }
+    }
+}
+
+#[test]
+fn memcpy() {
+    let mut dest = [0; 4];
+    let src = [0xde, 0xad, 0xbe, 0xef];
+
+    for n in 0..dest.len() {
+        dest.copy_from_slice(&[0; 4]);
+
+        unsafe { __aeabi_memcpy(dest.as_mut_ptr(), src.as_ptr(), n) }
+
+        assert_eq!(&dest[0..n], &src[0..n])
+    }
+}
+
+#[test]
+fn memcpy4() {
+    let mut aligned = Aligned::new([0; 8]);
+    let dest = &mut aligned.array;
+    let src = [0xde, 0xad, 0xbe, 0xef, 0xba, 0xad, 0xf0, 0x0d];
+
+    for n in 0..dest.len() {
+        dest.copy_from_slice(&[0; 8]);
+
+        unsafe { __aeabi_memcpy4(dest.as_mut_ptr(), src.as_ptr(), n) }
+
+        assert_eq!(&dest[0..n], &src[0..n])
+    }
+}