perf(strncpy): SWAR scan + wide copy + wide pad for strncpy/stpncpy (bd-2g7oyh.363)

strncpy copied byte-at-a-time to the NUL then byte-padded the remainder with
NUL. Replace the copy+pad loop with a composition of the already-shipped,
independently-gated SWAR/wide primitives: scan_c_string (SWAR) finds the source
NUL within the bound, raw_memcpy_bytes (wide u128-block) copies the prefix
clamped to the dst bound, and raw_memset_bytes (wide) NUL-fills the remainder —
byte-identical to the scalar loop including the membrane-repair clamping
(safe_src_len/safe_dst_len). stpncpy delegates to strncpy + strnlen, so it
inherits this and the SWAR strnlen win.

Measured (rch, median ns/op, copy-heavy strlen==n full copy, no pad):
  n       old(ns)   new(ns)   glibc(ns)   self    vs-glibc
   64      33.4      7.6       20.9      4.39x    2.76x
  256     116.0     20.7       34.1      5.60x    1.64x
 1024     449.0     77.5       92.6      5.80x    1.20x
 4096    1783.0    291.9      308.0      6.11x    1.06x
65536   28402.6    4524.2     4531.0      6.28x    1.00x
Self-speedup 4.4-6.3x for n>=64 (>=2.0); matches-or-beats glibc strncpy at every
size. (Pad-heavy strncpy was already fast — the byte pad lowered to memset — so
this is the copy-portion win; total strncpy never slower.)

Parity: conformance_diff_strncpy.rs proves fl strncpy/stpncpy produce byte-
identical destination buffers (full n bytes incl. NUL padding) + stpncpy end
offset vs host glibc across 2400 cases (src len 0..300 x n straddling the NUL x
src/dst alignments 0..7). The composed primitives stay independently gated by
conformance_diff_{scan_c_string,memcpy,memset}. Tenth ABI string-vein win.

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

Author: Dicklesworthstone

crates/frankenlibc-abi/src/string_abi.rs

@@ -2651,19 +2651,18 @@ pub unsafe extern "C" fn strncpy(dst: *mut c_char, src: *const c_char, n: usize)
     }
 
     // SAFETY: bounded by safe_dst_len and safe_src_len.
+    // SWAR scan for the NUL, then a wide block copy of the prefix and a wide NUL
+    // pad of the remainder — composing the proven scan_c_string / raw_memcpy_bytes
+    // / raw_memset_bytes primitives instead of the byte-at-a-time copy+pad loop.
+    // `k` is the source NUL index (or safe_src_len if none within bound); the copy
+    // is clamped to safe_dst_len, and everything after it is NUL-filled — exactly
+    // what the scalar loop produced.
     unsafe {
-        let mut i = 0usize;
-        while i < safe_dst_len {
-            let ch = if i < safe_src_len { *src.add(i) } else { 0 };
-            *dst.add(i) = ch;
-            i += 1;
-            if ch == 0 {
-                break;
-            }
-        }
-        while i < safe_dst_len {
-            *dst.add(i) = 0;
-            i += 1;
+        let k = scan_c_string(src, Some(safe_src_len)).0;
+        let copy_len = k.min(safe_dst_len);
+        raw_memcpy_bytes(dst.cast::<u8>(), src.cast::<u8>(), copy_len);
+        if copy_len < safe_dst_len {
+            raw_memset_bytes(dst.add(copy_len).cast::<u8>(), 0, safe_dst_len - copy_len);
         }
     }
     runtime_policy::observe(

crates/frankenlibc-abi/tests/conformance_diff_strncpy.rs

@@ -0,0 +1,64 @@
+//! Differential gate for the public `strncpy`/`stpncpy` ABI after replacing the
+//! byte-at-a-time copy+pad loop with SWAR scan + wide block copy + wide NUL pad.
+//! fl must produce byte-identical destination buffers (full n bytes, incl. the
+//! NUL padding) to host glibc across source lengths, `n` straddling the NUL, and
+//! both source and destination alignments — the regime where the wide copy and
+//! wide pad replace the old scalar loop.
+#![cfg(target_os = "linux")]
+#![allow(unsafe_code)]
+
+use frankenlibc_abi::string_abi::{stpncpy as fl_stpncpy, strncpy as fl_strncpy};
+use std::os::raw::c_char;
+
+#[test]
+fn strncpy_stpncpy_match_glibc() {
+    let mut checked = 0u64;
+    let lengths = [0usize, 1, 7, 8, 15, 16, 17, 31, 33, 63, 64, 100, 128, 255, 300];
+    let ns = [0usize, 1, 8, 16, 33, 64, 100, 128, 256, 301];
+
+    for &src_off in &[0usize, 1, 3, 7] {
+        for &dst_off in &[0usize, 1, 3, 7] {
+            for &len in &lengths {
+                // src: `len` non-NUL bytes (incl high-bit) then NUL.
+                let mut src_buf = vec![0u8; src_off + len + 1];
+                for k in 0..len {
+                    let b = (k as u8).wrapping_mul(53).wrapping_add(1);
+                    src_buf[src_off + k] = if b == 0 { 0x80 } else { b };
+                }
+                src_buf[src_off + len] = 0;
+                let src = unsafe { src_buf.as_ptr().add(src_off) } as *const c_char;
+
+                for &n in &ns {
+                    // Destination buffers preset to 0xAA so any unwritten byte shows.
+                    let mut fl = vec![0xAAu8; dst_off + n + 1];
+                    let mut gl = vec![0xAAu8; dst_off + n + 1];
+                    let fl_end = unsafe { fl_strncpy(fl.as_mut_ptr().add(dst_off) as *mut c_char, src, n) };
+                    let gl_ret = unsafe {
+                        libc::strncpy(gl.as_mut_ptr().add(dst_off) as *mut c_char, src, n)
+                    };
+                    let _ = (fl_end, gl_ret);
+                    assert_eq!(
+                        fl, gl,
+                        "strncpy src_off={src_off} dst_off={dst_off} len={len} n={n}"
+                    );
+
+                    // stpncpy: same buffer result + the returned end offset.
+                    let mut fl2 = vec![0xAAu8; dst_off + n + 1];
+                    let mut gl2 = vec![0xAAu8; dst_off + n + 1];
+                    let fl_base = unsafe { fl2.as_mut_ptr().add(dst_off) };
+                    let gl_base = unsafe { gl2.as_mut_ptr().add(dst_off) };
+                    let fe = unsafe { fl_stpncpy(fl_base as *mut c_char, src, n) };
+                    let ge = unsafe { libc::stpncpy(gl_base as *mut c_char, src, n) };
+                    assert_eq!(fl2, gl2, "stpncpy buf src_off={src_off} dst_off={dst_off} len={len} n={n}");
+                    assert_eq!(
+                        fe as usize - fl_base as usize,
+                        ge as usize - gl_base as usize,
+                        "stpncpy end off src_off={src_off} dst_off={dst_off} len={len} n={n}"
+                    );
+                    checked += 1;
+                }
+            }
+        }
+    }
+    assert!(checked >= 2400, "corpus unexpectedly small: {checked}");
+}

crates/frankenlibc-bench/benches/memset_abi_bench.rs

@@ -16,6 +16,39 @@ use frankenlibc_abi::string_abi::{
     bench_scan_strcmp,
 };
 
+/// Pre-lever strncpy copy+pad: byte-at-a-time copy to NUL then byte NUL-pad.
+#[inline(never)]
+unsafe fn old_byte_strncpy(dst: *mut u8, src: *const u8, n: usize) {
+    unsafe {
+        let mut i = 0usize;
+        while i < n {
+            let ch = *src.add(i);
+            *dst.add(i) = ch;
+            i += 1;
+            if ch == 0 {
+                break;
+            }
+        }
+        while i < n {
+            *dst.add(i) = 0;
+            i += 1;
+        }
+    }
+}
+
+/// New-lever strncpy: SWAR scan + wide copy + wide pad (the shipped composition).
+#[inline(never)]
+unsafe fn new_strncpy(dst: *mut u8, src: *const u8, n: usize) {
+    unsafe {
+        let k = bench_scan_c_string(src.cast::<std::os::raw::c_char>(), Some(n)).0;
+        let copy_len = k.min(n);
+        bench_raw_memcpy_bytes(dst, src, copy_len);
+        if copy_len < n {
+            bench_raw_memset_bytes(dst.add(copy_len), 0, n - copy_len);
+        }
+    }
+}
+
 /// Pre-lever strncasecmp scan: byte-at-a-time tolower compare to first diff/NUL.
 #[inline(never)]
 unsafe fn old_byte_strcasecmp(
@@ -380,4 +413,36 @@ fn main() {
             n, old, new, gl, old / new, gl / new,
         );
     }
+
+    println!("\nstrncpy (copy-heavy: strlen==n, full copy no pad):");
+    println!(
+        "{:>8} | {:>12} | {:>12} | {:>12} | {:>10} | {:>10}",
+        "n", "old(ns)", "new(ns)", "glibc(ns)", "self x", "vs glibc"
+    );
+    for &n in &sizes {
+        let mut src = vec![0x61u8; n + 1];
+        src[n] = 0;
+        let mut dst = vec![0u8; n + 1];
+        let sp = src.as_ptr();
+        let dp = dst.as_mut_ptr();
+        let iters = (4_000_000u64 / (n as u64 + 1)).max(2000);
+
+        let old = median_ns_per_op(rounds, iters, || {
+            unsafe { old_byte_strncpy(dp, sp, n) };
+            black_box(dst[0]);
+        });
+        let new = median_ns_per_op(rounds, iters, || {
+            unsafe { new_strncpy(dp, sp, n) };
+            black_box(dst[0]);
+        });
+        let gl = median_ns_per_op(rounds, iters, || {
+            // SAFETY: src NUL-terminated, dst valid for n bytes.
+            unsafe { libc::strncpy(dp.cast::<std::os::raw::c_char>(), sp.cast::<std::os::raw::c_char>(), n) };
+            black_box(dst[0]);
+        });
+        println!(
+            "{:>8} | {:>12.1} | {:>12.1} | {:>12.1} | {:>9.2}x | {:>9.2}x",
+            n, old, new, gl, old / new, gl / new,
+        );
+    }
 }