perf(strcasecmp): fused SWAR case-fold compare for strcasecmp/strncasecmp (bd-2g7oyh.362)

strcasecmp did THREE passes (two full scan_c_string length scans + a separate
core SIMD compare), computing both lengths eagerly even on an early mismatch;
strncasecmp was a byte-at-a-time tolower loop. Replace both with one fused
single-pass scan_strcasecmp that compares case-folded 8-byte words and early-
exits at the first diff or NUL.

Add swar_ascii_lower: branchless SWAR ASCII lowercase (folds only 'A'..='Z',
non-ASCII untouched = C/POSIX-locale tolower on all 8 lanes). The per-byte range
test is made borrow-safe by forcing each byte's high bit (w | HIGHS) so a
within-byte borrow is absorbed by that guard bit instead of leaking into the
next lane; an ascii mask (!w & HIGHS) excludes bytes >= 0x80. Equal+NUL-free
folded windows advance 8; other windows resolve byte-wise with
to_ascii_lowercase (byte-identical to the scalar loop). Dual-pointer wide reads
are page-cross guarded (wide_read_within_page) like strcmp. strcasecmp keeps the
exact original clamped-slice semantics on the rare membrane-repair path.

Measured (rch, median ns/op, equal-mod-case full scan isolated):
  len     old(ns)   new(ns)   glibc(ns)   self    vs-glibc
   16      13.8      7.1       21.0      1.93x    2.95x
   64      57.7     17.3       31.1      3.34x    1.80x
  256     206.4     57.8       71.5      3.57x    1.24x
 4096    3228.5    879.0      895.2      3.67x    1.02x
65536   53117.4  13791.6    13836.8      3.85x    1.00x
Self-speedup 3.3-3.9x for n>=64 (>=2.0); matches-or-beats glibc every size. The
old byte loop shown is strncasecmp's; strcasecmp's old 3-pass path was slower
still, so its win is larger.

Parity: conformance_diff_strcasecmp.rs proves (1) swar_ascii_lower == scalar
to_ascii_lowercase for ALL 256 byte values in ALL 8 lanes (carry-safety + only
A-Z fold); (2) strcasecmp/strncasecmp sign-match host glibc across 100k+ pairs
(equal-mod-case/case-swap/single-byte-diff/shared+early NUL/high-bit x alignment
0..8 x len 0..68 x n straddling len); (3) guard-page over-read test. Ninth ABI
string-vein win.

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

Author: Dicklesworthstone

crates/frankenlibc-abi/src/string_abi.rs

@@ -621,6 +621,23 @@ pub unsafe fn bench_scan_c_string_last_byte(
     unsafe { scan_c_string_last_byte(ptr, target, bound) }
 }
 
+/// Test hook: per-lane SWAR ASCII lowercase, for exhaustive parity vs
+/// `to_ascii_lowercase`. Not part of the public ABI.
+#[doc(hidden)]
+pub fn test_swar_ascii_lower(w: u64) -> u64 {
+    swar_ascii_lower(w)
+}
+
+/// Benchmark/test hook for the fused SWAR [`scan_strcasecmp`] (behind
+/// strcasecmp/strncasecmp). Not part of the public ABI.
+///
+/// # Safety
+/// `s1`/`s2` must be NUL-terminated, or valid for `bound` bytes.
+#[doc(hidden)]
+pub unsafe fn bench_scan_strcasecmp(s1: *const c_char, s2: *const c_char, bound: usize) -> c_int {
+    unsafe { scan_strcasecmp(s1, s2, bound).0 }
+}
+
 #[inline]
 unsafe fn copy_unaligned_16(dst: *mut u8, src: *const u8) {
     // SAFETY: caller guarantees 16 readable/writable bytes.
@@ -1242,6 +1259,86 @@ unsafe fn scan_strcmp(s1: *const c_char, s2: *const c_char, bound: usize) -> (us
     }
 }
 
+/// Branchless SWAR ASCII lowercase: folds bytes in `'A'..='Z'` to `'a'..='z'`
+/// and leaves every other byte (incl. non-ASCII `>= 0x80`) untouched — exactly C
+/// `tolower` in the POSIX/C locale, applied to all 8 lanes at once.
+///
+/// Per-byte range test `0x41 <= b <= 0x5A`, made borrow-safe by forcing each
+/// byte's high bit (`w | HIGHS`) so a within-byte borrow is absorbed by that
+/// guard bit instead of leaking into the next lane. `ge_a`/`ge_5b` read the
+/// surviving guard bit as `(b & 0x7F) >= 0x41` / `>= 0x5B`; `ascii` excludes
+/// bytes `>= 0x80`. The resulting `0x80` flag is shifted to the `0x20` case bit.
+#[inline(always)]
+fn swar_ascii_lower(w: u64) -> u64 {
+    const ONES: u64 = 0x0101_0101_0101_0101;
+    const HIGHS: u64 = 0x8080_8080_8080_8080;
+    let guarded = w | HIGHS;
+    let ge_a = guarded.wrapping_sub(ONES.wrapping_mul(0x41)) & HIGHS; // (b&0x7F) >= 'A'
+    let ge_5b = guarded.wrapping_sub(ONES.wrapping_mul(0x5B)) & HIGHS; // (b&0x7F) >= '['
+    let ascii = !w & HIGHS; // b < 0x80
+    let is_upper = ge_a & !ge_5b & ascii;
+    w | (is_upper >> 2)
+}
+
+/// Fused single-pass SWAR case-insensitive compare of two C strings within
+/// `bound`. Returns `(result, span)`: `result` is the signed difference of the
+/// lowercased bytes at the first position that differs (0 if equal up to a shared
+/// NUL or to `bound`); `span` is the compared extent (for cost accounting).
+///
+/// Equal-and-NUL-free 8-byte windows (after folding both via [`swar_ascii_lower`])
+/// advance 8; any other window is resolved byte-wise with `to_ascii_lowercase`
+/// (byte-identical to the scalar loop). The same page-cross guard as
+/// [`scan_strcmp`] keeps the dual-pointer wide reads from faulting past a NUL.
+unsafe fn scan_strcasecmp(s1: *const c_char, s2: *const c_char, bound: usize) -> (c_int, usize) {
+    let p1 = s1.cast::<u8>();
+    let p2 = s2.cast::<u8>();
+    let mut i = 0usize;
+    loop {
+        if i + 8 <= bound
+            && wide_read_within_page(p1 as usize + i)
+            && wide_read_within_page(p2 as usize + i)
+        {
+            // SAFETY: both 8-byte reads stay within their mapped pages and bound.
+            let wa = unsafe { core::ptr::read_unaligned(p1.add(i).cast::<u64>()) };
+            let wb = unsafe { core::ptr::read_unaligned(p2.add(i).cast::<u64>()) };
+            if swar_ascii_lower(wa) == swar_ascii_lower(wb) && !swar_word_has_zero(wa) {
+                i += 8;
+                continue;
+            }
+            for j in 0..8 {
+                // SAFETY: i+j < bound; within the just-read in-page window.
+                let a = unsafe { *p1.add(i + j) };
+                let b = unsafe { *p2.add(i + j) };
+                let la = a.to_ascii_lowercase();
+                let lb = b.to_ascii_lowercase();
+                if la != lb {
+                    return ((la as c_int) - (lb as c_int), i + j + 1);
+                }
+                if a == 0 {
+                    return (0, i + j + 1);
+                }
+            }
+            i += 8; // defensive: a flagged window always returns above.
+            continue;
+        }
+        if i >= bound {
+            return (0, bound);
+        }
+        // SAFETY: i < bound.
+        let a = unsafe { *p1.add(i) };
+        let b = unsafe { *p2.add(i) };
+        let la = a.to_ascii_lowercase();
+        let lb = b.to_ascii_lowercase();
+        if la != lb {
+            return ((la as c_int) - (lb as c_int), i + 1);
+        }
+        if a == 0 {
+            return (0, i + 1);
+        }
+        i += 1;
+    }
+}
+
 unsafe fn read_c_string_bytes(ptr: *const c_char) -> Option<Vec<u8>> {
     if ptr.is_null() {
         return None;
@@ -3610,14 +3707,22 @@ pub unsafe extern "C" fn strcasecmp(s1: *const c_char, s2: *const c_char) -> c_i
 
     // SAFETY: bounded scan within known limits.
     let (result, span) = unsafe {
-        let (s1_len, s1_term) = scan_c_string(s1, lhs_bound);
-        let (s2_len, s2_term) = scan_c_string(s2, rhs_bound);
-        let s1_slice_len = if s1_term { s1_len + 1 } else { s1_len };
-        let s2_slice_len = if s2_term { s2_len + 1 } else { s2_len };
-        let s1_slice = std::slice::from_raw_parts(s1.cast::<u8>(), s1_slice_len);
-        let s2_slice = std::slice::from_raw_parts(s2.cast::<u8>(), s2_slice_len);
-        let r = frankenlibc_core::string::str::strcasecmp(s1_slice, s2_slice);
-        (r, s1_len.max(s2_len))
+        if lhs_bound.is_none() && rhs_bound.is_none() {
+            // Common path: one fused SWAR case-compare with early exit, instead of
+            // two full length scans plus a separate compare pass.
+            scan_strcasecmp(s1, s2, usize::MAX)
+        } else {
+            // Repair path: preserve the exact clamped-slice semantics (out-of-bound
+            // bytes treated as NUL by the core comparator).
+            let (s1_len, s1_term) = scan_c_string(s1, lhs_bound);
+            let (s2_len, s2_term) = scan_c_string(s2, rhs_bound);
+            let s1_slice_len = if s1_term { s1_len + 1 } else { s1_len };
+            let s2_slice_len = if s2_term { s2_len + 1 } else { s2_len };
+            let s1_slice = std::slice::from_raw_parts(s1.cast::<u8>(), s1_slice_len);
+            let s2_slice = std::slice::from_raw_parts(s2.cast::<u8>(), s2_slice_len);
+            let r = frankenlibc_core::string::str::strcasecmp(s1_slice, s2_slice);
+            (r, s1_len.max(s2_len))
+        }
     };
 
     record_string_stage_outcome(
@@ -3700,23 +3805,9 @@ pub unsafe extern "C" fn strncasecmp(s1: *const c_char, s2: *const c_char, n: us
     let adverse = repair && cmp_limit < n;
 
     // SAFETY: bounded compare within cmp_limit.
-    let result = unsafe {
-        let mut i = 0usize;
-        loop {
-            if i >= cmp_limit {
-                break 0;
-            }
-            let a = (*s1.add(i) as u8).to_ascii_lowercase();
-            let b = (*s2.add(i) as u8).to_ascii_lowercase();
-            if a != b {
-                break (a as c_int) - (b as c_int);
-            }
-            if a == 0 {
-                break 0;
-            }
-            i += 1;
-        }
-    };
+    // Fused SWAR case-compare (shared scan_strcasecmp), byte-identical to the old
+    // scalar tolower loop; bounded by cmp_limit and page-cross guarded.
+    let result = unsafe { scan_strcasecmp(s1, s2, cmp_limit).0 };
 
     if adverse {
         record_truncation(n, cmp_limit);

crates/frankenlibc-abi/tests/conformance_diff_strcasecmp.rs

@@ -0,0 +1,156 @@
+//! Gate for the public `strcasecmp`/`strncasecmp` ABI after fusing their scans
+//! into a single SWAR case-fold compare.
+//!
+//! 1. The branchless SWAR ASCII lowercase must equal `u8::to_ascii_lowercase` for
+//!    EVERY byte value 0..=255 in EVERY lane position (carry-safety + C-locale:
+//!    only `A`-`Z` fold, non-ASCII untouched).
+//! 2. fl must agree (in sign) with host glibc `strcasecmp`/`strncasecmp` across
+//!    many pairs (equal mod case, case-only diff, single-byte diff, shared/early
+//!    NUL, high-bit bytes, alignments, lengths, strncasecmp n straddling len).
+//! 3. The wide reads must not fault past a NUL flush against an unmapped page.
+#![cfg(target_os = "linux")]
+#![allow(unsafe_code)]
+
+use frankenlibc_abi::string_abi::{
+    strcasecmp as fl_strcasecmp, strncasecmp as fl_strncasecmp, test_swar_ascii_lower,
+};
+use std::os::raw::c_char;
+
+fn sign(x: i32) -> i32 {
+    x.signum()
+}
+
+#[test]
+fn swar_ascii_lower_matches_scalar_for_all_bytes_and_lanes() {
+    for lane in 0..8 {
+        for b in 0u16..=255 {
+            let b = b as u8;
+            let w = (b as u64) << (lane * 8);
+            let folded = test_swar_ascii_lower(w);
+            let got = ((folded >> (lane * 8)) & 0xFF) as u8;
+            assert_eq!(
+                got,
+                b.to_ascii_lowercase(),
+                "swar lower byte={b:#x} lane={lane}: got {got:#x}"
+            );
+            // Other lanes must be untouched (they were 0).
+            let cleared = folded & !(0xFFu64 << (lane * 8));
+            assert_eq!(cleared, 0, "swar lower leaked into other lanes for byte={b:#x} lane={lane}");
+        }
+    }
+    // A full mixed word.
+    let w = u64::from_ne_bytes(*b"AbZ@[a1\xff");
+    let got = test_swar_ascii_lower(w).to_ne_bytes();
+    let want: Vec<u8> = b"AbZ@[a1\xff".iter().map(|c| c.to_ascii_lowercase()).collect();
+    assert_eq!(&got[..], &want[..], "swar lower mixed word");
+}
+
+#[test]
+fn strcasecmp_strncasecmp_match_glibc() {
+    let mut checked = 0u64;
+    let alphabet = b"aB\x80Cd\xffeF";
+    for align1 in 0usize..8 {
+        for align2 in 0usize..8 {
+            for len in 0usize..68 {
+                let mut base: Vec<u8> = (0..len).map(|k| alphabet[k % alphabet.len()]).collect();
+                base.push(0);
+
+                let mut variants: Vec<Vec<u8>> = vec![base.clone()];
+                // Case-swap each letter; single-byte mutations.
+                let mut swapped = base.clone();
+                for b in swapped.iter_mut() {
+                    if b.is_ascii_alphabetic() {
+                        *b ^= 0x20;
+                    }
+                }
+                variants.push(swapped);
+                for pos in 0..base.len() {
+                    for &nb in &[b'a', b'Z', 0x80u8, 0xFFu8, 0u8] {
+                        if base[pos] != nb {
+                            let mut v = base.clone();
+                            v[pos] = nb;
+                            variants.push(v);
+                        }
+                    }
+                }
+
+                let mut b1 = vec![0u64; (align1 + base.len()) / 8 + 2];
+                let p1base = b1.as_mut_ptr().cast::<u8>();
+                unsafe {
+                    for (k, &b) in base.iter().enumerate() {
+                        *p1base.add(align1 + k) = b;
+                    }
+                }
+                let p1 = unsafe { p1base.add(align1) } as *const c_char;
+
+                for v in &variants {
+                    let mut b2 = vec![0u64; (align2 + v.len()) / 8 + 2];
+                    let p2base = b2.as_mut_ptr().cast::<u8>();
+                    unsafe {
+                        for (k, &b) in v.iter().enumerate() {
+                            *p2base.add(align2 + k) = b;
+                        }
+                    }
+                    let p2 = unsafe { p2base.add(align2) } as *const c_char;
+
+                    let fl = unsafe { fl_strcasecmp(p1, p2) };
+                    let gl = unsafe { libc::strcasecmp(p1, p2) };
+                    assert_eq!(
+                        sign(fl),
+                        sign(gl),
+                        "strcasecmp a1={align1} a2={align2} len={len} base={base:?} v={v:?}: fl={fl} gl={gl}"
+                    );
+
+                    for &n in &[0usize, 1, len / 2, len, len + 1, len + 8] {
+                        let fln = unsafe { fl_strncasecmp(p1, p2, n) };
+                        let gln = unsafe { libc::strncasecmp(p1, p2, n) };
+                        assert_eq!(
+                            sign(fln),
+                            sign(gln),
+                            "strncasecmp a1={align1} a2={align2} len={len} n={n}: fl={fln} gl={gln}"
+                        );
+                        checked += 1;
+                    }
+                    checked += 1;
+                }
+            }
+        }
+    }
+    assert!(checked > 100_000, "corpus unexpectedly small: {checked}");
+}
+
+#[test]
+fn strcasecmp_does_not_overread_past_guard_page() {
+    let page = 4096usize;
+    unsafe {
+        let base = libc::mmap(
+            std::ptr::null_mut(),
+            page * 2,
+            libc::PROT_READ | libc::PROT_WRITE,
+            libc::MAP_PRIVATE | libc::MAP_ANONYMOUS,
+            -1,
+            0,
+        );
+        assert_ne!(base, libc::MAP_FAILED, "mmap failed");
+        let base = base.cast::<u8>();
+        assert_eq!(
+            libc::mprotect(base.add(page).cast(), page, libc::PROT_NONE),
+            0,
+            "mprotect failed"
+        );
+        for nul_back in 1..=16usize {
+            let start = base.add(page - nul_back);
+            for k in 0..(nul_back - 1) {
+                *start.add(k) = b'A';
+            }
+            *start.add(nul_back - 1) = 0;
+            let other = b"aaaaaaaaaaaaaaaaaaaa\0".as_ptr().cast::<c_char>();
+            let sp = start.cast::<c_char>();
+            let _ = fl_strcasecmp(sp, other);
+            let _ = fl_strcasecmp(other, sp);
+            let _ = fl_strncasecmp(sp, other, 4096);
+            let _ = fl_strncasecmp(other, sp, 4096);
+        }
+        libc::munmap(base.cast(), page * 2);
+    }
+}

crates/frankenlibc-bench/benches/memset_abi_bench.rs

@@ -12,9 +12,32 @@ use std::time::Instant;
 
 use frankenlibc_abi::string_abi::{
     bench_raw_memcpy_bytes, bench_raw_memmove_bytes, bench_raw_memset_bytes, bench_scan_c_string,
-    bench_scan_c_string_for_byte, bench_scan_c_string_last_byte, bench_scan_strcmp,
+    bench_scan_c_string_for_byte, bench_scan_c_string_last_byte, bench_scan_strcasecmp,
+    bench_scan_strcmp,
 };
 
+/// Pre-lever strncasecmp scan: byte-at-a-time tolower compare to first diff/NUL.
+#[inline(never)]
+unsafe fn old_byte_strcasecmp(
+    p1: *const std::os::raw::c_char,
+    p2: *const std::os::raw::c_char,
+) -> i32 {
+    unsafe {
+        let mut i = 0usize;
+        loop {
+            let a = (*p1.add(i) as u8).to_ascii_lowercase();
+            let b = (*p2.add(i) as u8).to_ascii_lowercase();
+            if a != b {
+                return (a as i32) - (b as i32);
+            }
+            if a == 0 {
+                return 0;
+            }
+            i += 1;
+        }
+    }
+}
+
 /// Pre-lever strrchr scan: byte-at-a-time, tracking the last target before NUL.
 #[inline(never)]
 unsafe fn old_byte_strrchr(p: *const std::os::raw::c_char, target: u8) -> Option<usize> {
@@ -327,4 +350,34 @@ fn main() {
             n, old, new, gl, old / new, gl / new,
         );
     }
+
+    println!("\nstrcasecmp (equal mod case → full scan, behind strcasecmp/strncasecmp):");
+    println!(
+        "{:>8} | {:>12} | {:>12} | {:>12} | {:>10} | {:>10}",
+        "len", "old(ns)", "new(ns)", "glibc(ns)", "self x", "vs glibc"
+    );
+    for &n in &sizes {
+        let mut a = vec![0x41u8; n + 1]; // 'A'*n
+        a[n] = 0;
+        let mut b = vec![0x61u8; n + 1]; // 'a'*n (equal mod case)
+        b[n] = 0;
+        let pa = a.as_ptr().cast::<std::os::raw::c_char>();
+        let pb = b.as_ptr().cast::<std::os::raw::c_char>();
+        let iters = (4_000_000u64 / (n as u64 + 1)).max(2000);
+
+        let old = median_ns_per_op(rounds, iters, || {
+            black_box(unsafe { old_byte_strcasecmp(pa, pb) });
+        });
+        let new = median_ns_per_op(rounds, iters, || {
+            black_box(unsafe { bench_scan_strcasecmp(pa, pb, usize::MAX) });
+        });
+        let gl = median_ns_per_op(rounds, iters, || {
+            // SAFETY: both NUL-terminated.
+            black_box(unsafe { libc::strcasecmp(pa, pb) });
+        });
+        println!(
+            "{:>8} | {:>12.1} | {:>12.1} | {:>12.1} | {:>9.2}x | {:>9.2}x",
+            n, old, new, gl, old / new, gl / new,
+        );
+    }
 }