perf(string): SIMD swab — 16-34x self, 10-20x faster than glibc

swab() byte-swapped adjacent pairs with two scalar stores per pair
(dest[2k]=src[2k+1]; dest[2k+1]=src[2k]) — ~0.58-0.66 ns/B, ~1.6x SLOWER than
glibc's tuned loop. Replace the body with a single 32-byte portable-SIMD
shuffle (lane 2k <-> 2k+1) plus a 2-byte scalar tail. The swizzle is exactly
the pairwise transposition, so it is byte-for-byte identical to the scalar
loop; bytes is even so neither the SIMD step (multiple of 32) nor the tail
splits a pair, and an odd trailing byte (n odd) stays untouched per POSIX.

swab (ns/B): scalar 0.564-0.790 -> SIMD 0.018-0.050 = 15.8-33.9x self;
vs glibc 0.36-0.48 ns/B -> 0.05-0.10x (10-20x FASTER than glibc).

Isomorphism: conformance_diff_string_mut::diff_swab_cases vs host glibc —
extended with a 16..511-byte even/odd sweep so the SIMD block, its boundary,
and the scalar tail are all covered (was <=8 bytes = scalar tail only);
+ core unit tests (basic + odd_length). 0 divergences.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: Dicklesworthstone

crates/frankenlibc-abi/tests/conformance_diff_string_mut.rs

@@ -1811,6 +1811,36 @@ fn diff_swab_cases() {
             });
         }
     }
+
+    // Larger sweep to exercise the 32-byte SIMD shuffle path and its tail/
+    // boundary (the small cases above only hit the scalar tail). Sizes span the
+    // SIMD block, just-over-block + odd-byte, and multi-block with a remainder,
+    // each filled with a high-bit-varied pattern, all compared against host glibc.
+    let pattern: Vec<u8> = (0..512u32).map(|i| (i.wrapping_mul(73).wrapping_add(17)) as u8).collect();
+    for &len in &[16usize, 31, 32, 33, 48, 63, 64, 65, 100, 127, 128, 200, 255, 256, 300, 511] {
+        for &odd in &[false, true] {
+            let n = if odd { len | 1 } else { len & !1 };
+            if n > pattern.len() {
+                continue;
+            }
+            let src = &pattern[..n];
+            let mut dst_fl = vec![0xCDu8; n + 8];
+            let mut dst_lc = vec![0xCDu8; n + 8];
+            unsafe {
+                fl::swab(src.as_ptr() as *const c_void, dst_fl.as_mut_ptr() as *mut c_void, n as isize);
+                swab(src.as_ptr() as *const c_void, dst_lc.as_mut_ptr() as *mut c_void, n as isize);
+            }
+            if dst_fl != dst_lc {
+                divs.push(Divergence {
+                    function: "swab",
+                    case: format!("(len={n})"),
+                    field: "dst_buffer",
+                    frankenlibc: format!("{:?}", &dst_fl[..n]),
+                    glibc: format!("{:?}", &dst_lc[..n]),
+                });
+            }
+        }
+    }
     assert!(divs.is_empty(), "swab divergences:\n{}", render_divs(&divs));
 }
 

crates/frankenlibc-core/src/string/mem.rs

@@ -769,11 +769,34 @@ pub fn bcmp(a: &[u8], b: &[u8], n: usize) -> i32 {
 /// Equivalent to POSIX `swab`. Processes `n` bytes (n should be even).
 pub fn swab(src: &[u8], dest: &mut [u8], n: usize) -> usize {
     let pairs = n.min(src.len()).min(dest.len()) / 2;
-    for i in 0..pairs {
-        dest[2 * i] = src[2 * i + 1];
-        dest[2 * i + 1] = src[2 * i];
+    let bytes = pairs * 2;
+    let mut i = 0;
+
+    // SIMD: swap adjacent byte pairs 32 at a time via a single shuffle (lane
+    // 2k <-> 2k+1), instead of two scalar stores per pair. Byte-for-byte
+    // identical to the scalar swap below — the swizzle is exactly the pairwise
+    // transposition `dest[2k]=src[2k+1]; dest[2k+1]=src[2k]`. `bytes` is even,
+    // so the SIMD step (multiple of 32) and the 2-byte tail never split a pair,
+    // and an odd trailing byte (n odd) is left untouched, as POSIX swab requires.
+    const LANES: usize = 32;
+    while i + LANES <= bytes {
+        let v = Simd::<u8, LANES>::from_slice(&src[i..i + LANES]);
+        let sw = std::simd::simd_swizzle!(
+            v,
+            [
+                1, 0, 3, 2, 5, 4, 7, 6, 9, 8, 11, 10, 13, 12, 15, 14, 17, 16, 19, 18, 21, 20, 23,
+                22, 25, 24, 27, 26, 29, 28, 31, 30
+            ]
+        );
+        sw.copy_to_slice(&mut dest[i..i + LANES]);
+        i += LANES;
+    }
+    while i < bytes {
+        dest[i] = src[i + 1];
+        dest[i + 1] = src[i];
+        i += 2;
     }
-    pairs * 2
+    bytes
 }
 
 #[cfg(test)]