4-byte align the arrays in the unit tests

Author: japaric

tests/aeabi_memclr.rs

@@ -14,6 +14,8 @@ extern crate utest_cortex_m_qemu;
 #[macro_use]
 extern crate utest_macros;
 
+use core::mem;
+
 macro_rules! panic {
     ($($tt:tt)*) => {
         upanic!($($tt)*);
@@ -25,9 +27,25 @@ extern "C" {
     fn __aeabi_memset4(dest: *mut u8, n: usize, c: u32);
 }
 
+struct Aligned {
+    array: [u8; 8],
+    _alignment: [u32; 0],
+}
+
+impl Aligned {
+    fn new() -> Self {
+        Aligned {
+            array: [0; 8],
+            _alignment: [],
+        }
+    }
+}
+
 #[test]
 fn memclr4() {
-    let mut xs = [0u8; 8];
+    let mut aligned = Aligned::new();;
+    assert_eq!(mem::align_of_val(&aligned), 4);
+    let xs = &mut aligned.array;
 
     for n in 0..9 {
         unsafe {

tests/aeabi_memset.rs

@@ -14,6 +14,8 @@ extern crate utest_cortex_m_qemu;
 #[macro_use]
 extern crate utest_macros;
 
+use core::mem;
+
 macro_rules! panic {
     ($($tt:tt)*) => {
         upanic!($($tt)*);
@@ -24,199 +26,249 @@ extern "C" {
     fn __aeabi_memset4(dest: *mut u8, n: usize, c: u32);
 }
 
+struct Aligned {
+    array: [u8; 8],
+    _alignment: [u32; 0],
+}
+
+impl Aligned {
+    fn new(array: [u8; 8]) -> Self {
+        Aligned {
+            array: array,
+            _alignment: [],
+        }
+    }
+}
+
 #[test]
 fn zero() {
-    let mut xs = [0u8; 8];
+    let mut aligned = Aligned::new([0u8; 8]);;
+    assert_eq!(mem::align_of_val(&aligned), 4);
+    let xs = &mut aligned.array;
     let c = 0xdeadbeef;
 
     unsafe {
         __aeabi_memset4(xs.as_mut_ptr(), 0, c)
     }
 
-    assert_eq!(xs, [0; 8]);
+    assert_eq!(*xs, [0; 8]);
 
-    let mut xs = [1u8; 8];
+    let mut aligned = Aligned::new([1u8; 8]);;
+    assert_eq!(mem::align_of_val(&aligned), 4);
+    let xs = &mut aligned.array;
     let c = 0xdeadbeef;
 
     unsafe {
         __aeabi_memset4(xs.as_mut_ptr(), 0, c)
     }
 
-    assert_eq!(xs, [1; 8]);
+    assert_eq!(*xs, [1; 8]);
 }
 
 #[test]
 fn one() {
-    let mut xs = [0u8; 8];
+    let mut aligned = Aligned::new([0u8; 8]);;
+    assert_eq!(mem::align_of_val(&aligned), 4);
+    let xs = &mut aligned.array;
     let n = 1;
     let c = 0xdeadbeef;
 
     unsafe {
         __aeabi_memset4(xs.as_mut_ptr(), n, c)
     }
 
-    assert_eq!(xs, [0xef, 0, 0, 0, 0, 0, 0, 0]);
+    assert_eq!(*xs, [0xef, 0, 0, 0, 0, 0, 0, 0]);
 
-    let mut xs = [1u8; 8];
+    let mut aligned = Aligned::new([1u8; 8]);;
+    assert_eq!(mem::align_of_val(&aligned), 4);
+    let xs = &mut aligned.array;
     let c = 0xdeadbeef;
 
     unsafe {
         __aeabi_memset4(xs.as_mut_ptr(), n, c)
     }
 
-    assert_eq!(xs, [0xef, 1, 1, 1, 1, 1, 1, 1]);
+    assert_eq!(*xs, [0xef, 1, 1, 1, 1, 1, 1, 1]);
 }
 
 #[test]
 fn two() {
-    let mut xs = [0u8; 8];
+    let mut aligned = Aligned::new([0u8; 8]);;
+    assert_eq!(mem::align_of_val(&aligned), 4);
+    let xs = &mut aligned.array;
     let n = 2;
     let c = 0xdeadbeef;
 
     unsafe {
         __aeabi_memset4(xs.as_mut_ptr(), n, c)
     }
 
-    assert_eq!(xs, [0xef, 0xef, 0, 0, 0, 0, 0, 0]);
+    assert_eq!(*xs, [0xef, 0xef, 0, 0, 0, 0, 0, 0]);
 
-    let mut xs = [1u8; 8];
+    let mut aligned = Aligned::new([1u8; 8]);;
+    assert_eq!(mem::align_of_val(&aligned), 4);
+    let xs = &mut aligned.array;
     let c = 0xdeadbeef;
 
     unsafe {
         __aeabi_memset4(xs.as_mut_ptr(), n, c)
     }
 
-    assert_eq!(xs, [0xef, 0xef, 1, 1, 1, 1, 1, 1]);
+    assert_eq!(*xs, [0xef, 0xef, 1, 1, 1, 1, 1, 1]);
 }
 
 #[test]
 fn three() {
-    let mut xs = [0u8; 8];
+    let mut aligned = Aligned::new([0u8; 8]);;
+    assert_eq!(mem::align_of_val(&aligned), 4);
+    let xs = &mut aligned.array;
     let n = 3;
     let c = 0xdeadbeef;
 
     unsafe {
         __aeabi_memset4(xs.as_mut_ptr(), n, c)
     }
 
-    assert_eq!(xs, [0xef, 0xef, 0xef, 0, 0, 0, 0, 0]);
+    assert_eq!(*xs, [0xef, 0xef, 0xef, 0, 0, 0, 0, 0]);
 
-    let mut xs = [1u8; 8];
+    let mut aligned = Aligned::new([1u8; 8]);;
+    assert_eq!(mem::align_of_val(&aligned), 4);
+    let xs = &mut aligned.array;
     let c = 0xdeadbeef;
 
     unsafe {
         __aeabi_memset4(xs.as_mut_ptr(), n, c)
     }
 
-    assert_eq!(xs, [0xef, 0xef, 0xef, 1, 1, 1, 1, 1]);
+    assert_eq!(*xs, [0xef, 0xef, 0xef, 1, 1, 1, 1, 1]);
 }
 
 #[test]
 fn four() {
-    let mut xs = [0u8; 8];
+    let mut aligned = Aligned::new([0u8; 8]);;
+    assert_eq!(mem::align_of_val(&aligned), 4);
+    let xs = &mut aligned.array;
     let n = 4;
     let c = 0xdeadbeef;
 
     unsafe {
         __aeabi_memset4(xs.as_mut_ptr(), n, c)
     }
 
-    assert_eq!(xs, [0xef, 0xef, 0xef, 0xef, 0, 0, 0, 0]);
+    assert_eq!(*xs, [0xef, 0xef, 0xef, 0xef, 0, 0, 0, 0]);
 
-    let mut xs = [1u8; 8];
+    let mut aligned = Aligned::new([1u8; 8]);;
+    assert_eq!(mem::align_of_val(&aligned), 4);
+    let xs = &mut aligned.array;
     let c = 0xdeadbeef;
 
     unsafe {
         __aeabi_memset4(xs.as_mut_ptr(), n, c)
     }
 
-    assert_eq!(xs, [0xef, 0xef, 0xef, 0xef, 1, 1, 1, 1]);
+    assert_eq!(*xs, [0xef, 0xef, 0xef, 0xef, 1, 1, 1, 1]);
 }
 
 #[test]
 fn five() {
-    let mut xs = [0u8; 8];
+    let mut aligned = Aligned::new([0u8; 8]);;
+    assert_eq!(mem::align_of_val(&aligned), 4);
+    let xs = &mut aligned.array;
     let n = 5;
     let c = 0xdeadbeef;
 
     unsafe {
         __aeabi_memset4(xs.as_mut_ptr(), n, c)
     }
 
-    assert_eq!(xs, [0xef, 0xef, 0xef, 0xef, 0xef, 0, 0, 0]);
+    assert_eq!(*xs, [0xef, 0xef, 0xef, 0xef, 0xef, 0, 0, 0]);
 
-    let mut xs = [1u8; 8];
+    let mut aligned = Aligned::new([1u8; 8]);;
+    assert_eq!(mem::align_of_val(&aligned), 4);
+    let xs = &mut aligned.array;
     let c = 0xdeadbeef;
 
     unsafe {
         __aeabi_memset4(xs.as_mut_ptr(), n, c)
     }
 
-    assert_eq!(xs, [0xef, 0xef, 0xef, 0xef, 0xef, 1, 1, 1]);
+    assert_eq!(*xs, [0xef, 0xef, 0xef, 0xef, 0xef, 1, 1, 1]);
 }
 
 #[test]
 fn six() {
-    let mut xs = [0u8; 8];
+    let mut aligned = Aligned::new([0u8; 8]);;
+    assert_eq!(mem::align_of_val(&aligned), 4);
+    let xs = &mut aligned.array;
     let n = 6;
     let c = 0xdeadbeef;
 
     unsafe {
         __aeabi_memset4(xs.as_mut_ptr(), n, c)
     }
 
-    assert_eq!(xs, [0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0, 0]);
+    assert_eq!(*xs, [0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0, 0]);
 
-    let mut xs = [1u8; 8];
+    let mut aligned = Aligned::new([1u8; 8]);;
+    assert_eq!(mem::align_of_val(&aligned), 4);
+    let xs = &mut aligned.array;
     let c = 0xdeadbeef;
 
     unsafe {
         __aeabi_memset4(xs.as_mut_ptr(), n, c)
     }
 
-    assert_eq!(xs, [0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 1, 1]);
+    assert_eq!(*xs, [0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 1, 1]);
 }
 
 #[test]
 fn seven() {
-    let mut xs = [0u8; 8];
+    let mut aligned = Aligned::new([0u8; 8]);;
+    assert_eq!(mem::align_of_val(&aligned), 4);
+    let xs = &mut aligned.array;
     let n = 7;
     let c = 0xdeadbeef;
 
     unsafe {
         __aeabi_memset4(xs.as_mut_ptr(), n, c)
     }
 
-    assert_eq!(xs, [0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0]);
+    assert_eq!(*xs, [0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0]);
 
-    let mut xs = [1u8; 8];
+    let mut aligned = Aligned::new([1u8; 8]);;
+    assert_eq!(mem::align_of_val(&aligned), 4);
+    let xs = &mut aligned.array;
     let c = 0xdeadbeef;
 
     unsafe {
         __aeabi_memset4(xs.as_mut_ptr(), n, c)
     }
 
-    assert_eq!(xs, [0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 1]);
+    assert_eq!(*xs, [0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 1]);
 }
 
 #[test]
 fn eight() {
-    let mut xs = [0u8; 8];
+    let mut aligned = Aligned::new([0u8; 8]);;
+    assert_eq!(mem::align_of_val(&aligned), 4);
+    let xs = &mut aligned.array;
     let n = 8;
     let c = 0xdeadbeef;
 
     unsafe {
         __aeabi_memset4(xs.as_mut_ptr(), n, c)
     }
 
-    assert_eq!(xs, [0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef]);
+    assert_eq!(*xs, [0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef]);
 
-    let mut xs = [1u8; 8];
+    let mut aligned = Aligned::new([1u8; 8]);;
+    assert_eq!(mem::align_of_val(&aligned), 4);
+    let xs = &mut aligned.array;
     let c = 0xdeadbeef;
 
     unsafe {
         __aeabi_memset4(xs.as_mut_ptr(), n, c)
     }
 
-    assert_eq!(xs, [0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef]);
+    assert_eq!(*xs, [0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef]);
 }