For small types, just swap directly

src/libcore/mem.rs

@@ -548,8 +548,19 @@ pub unsafe fn uninitialized<T>() -> T {
 #[inline]
 #[stable(feature = "rust1", since = "1.0.0")]
 pub fn swap<T>(x: &mut T, y: &mut T) {
-    unsafe {
-        ptr::swap_nonoverlapping(x, y, 1);
+    if size_of::<T>() < 32 {
+        // For small types, just swap directly.
+        // This keeps alignment and lets debug not run the big loop.
+        unsafe {
+            let temp = ptr::read(x);
+            ptr::copy_nonoverlapping(y, x, 1);
+            ptr::write(y, temp);
+        }
+    } else {
+        // For large types, use the simd swapping code.
+        unsafe {
+            ptr::swap_nonoverlapping(x, y, 1);
+        }
     }
 }
 

src/libcore/tests/mem.rs

@@ -89,6 +89,13 @@ fn test_swap() {
     swap(&mut x, &mut y);
     assert_eq!(x, 42);
     assert_eq!(y, 31337);
+
+    // A bigger one to hit the SIMD loop
+    let mut x = [1u64, 2, 3, 4, 5, 6, 7, 8];
+    let mut y = [11, 12, 13, 14, 15, 16, 17, 18];
+    swap(&mut x, &mut y);
+    assert_eq!(x, [11, 12, 13, 14, 15, 16, 17, 18]);
+    assert_eq!(y, [1, 2, 3, 4, 5, 6, 7, 8]);
 }
 
 #[test]