replace get_nonspace_bits with get_nonspace_index on sve2

Author: hsqStephenZhang

src/parser.rs

@@ -288,12 +288,11 @@ impl SpaceSkipper {
         // then we use simd to accelerate skipping space
         while let Some(chunk) = reader.peek_n(16) {
             let chunk = unsafe { &*(chunk.as_ptr() as *const [_; 16]) };
-            let bitmap = unsafe { crate::util::arch::get_nonspace_bits(chunk) };
-            if bitmap != 0 {
-                let cnt = bitmap.trailing_zeros() as usize;
-                let ch = chunk[cnt];
-                reader.eat(cnt + 1);
+            let cnt = unsafe { crate::util::arch::get_nonspace_index(chunk) };
 
+            if cnt < 16 {
+                let ch = chunk[cnt];
+                reader.eat(cnt + 1); // Skip spaces + return char
                 return Some(ch);
             }
             reader.eat(16)

src/util/arch/mod.rs

@@ -23,10 +23,9 @@ mod test {
         let input = b"\t\r\n xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx";
         cfg_if::cfg_if! {
             if #[cfg(all(target_feature="sve2", target_arch="aarch64"))] {
-                let non_space_bits = unsafe { get_nonspace_bits(std::mem::transmute(input)) };
+                let first_nonspace_idx = unsafe { get_nonspace_index(std::mem::transmute(input)) };
                 // sve2 cannot generate the full bitmap(without performance loss)
-                let expected_bits = 0b10000;
-                assert_eq!(non_space_bits, expected_bits, "bits is {non_space_bits:b}");
+                assert_eq!(first_nonspace_idx, 4, "first non-space index is {first_nonspace_idx}");
             } else {
                 let non_space_bits = unsafe { get_nonspace_bits(input) };
                 let expected_bits = 0b1111111111111111111111111111111111111111111111111111111111110000;

src/util/arch/sve2.rs

@@ -8,39 +8,39 @@ pub unsafe fn prefix_xor(bitmask: u64) -> u64 {
     bitmask ^= bitmask << 32;
     bitmask
 }
-
-/// SVE2 implementation of `get_nonspace_bits`.
-/// But this won't get the full bitmap
+/// SVE2 implementation: Returns the index of the first non-space char (0-15).
+/// Returns 16 if all characters are spaces.
 #[inline(always)]
-pub unsafe fn get_nonspace_bits(data: &[u8; 16]) -> u64 {
-    let mut index: u64;
-    // 0x09 (Tab), 0x0A (LF), 0x0D (CR), 0x20 (Space)
+pub unsafe fn get_nonspace_index(data: &[u8; 16]) -> usize {
+    let mut idx: u64 = 16; // Default to 16 (Not Found)
+                           // 0x09 (Tab), 0x0A (LF), 0x0D (CR), 0x20 (Space)
     let tokens: u32 = 0x090a0d20;
 
     core::arch::asm!(
         "ptrue  p0.b, vl16",
         "ld1b   {{z0.b}}, p0/z, [{ptr}]",
-        // broadcast token set
         "mov    z1.s, {t:w}",
 
-        // nmatch: find token does not match
+        // 1. Identify non-space characters
+        // NMATCH sets the Z flag if NO non-spaces are found (all whitespace)
         "nmatch p1.b, p0/z, z0.b, z1.b",
 
-        // locate
-        "brkb   p1.b, p0/z, p1.b",
-        // count number of true bits
-        "cntp   {idx}, p0, p1.b",
+        // 2. Fast Path: Branch if NO non-space characters were found.
+        // b.none checks the Z flag set by nmatch.
+        // If Z=1 (all spaces), we skip the calculation and keep idx=16.
+        "b.none 1f",
+
+        // 3. Slow Path (Found something): Calculate the exact index
+        "brkb   p2.b, p0/z, p1.b", // Mask bits *after* the first match
+        "cntp   {idx}, p0, p2.b",  // Count leading matches
 
+        "1:",
         ptr = in(reg) data.as_ptr(),
         t = in(reg) tokens,
-        idx = out(reg) index,
+        idx = inout(reg) idx,
         out("z0") _, out("z1") _,
-        out("p0") _, out("p1") _,
+        out("p0") _, out("p1") _, out("p2") _,
     );
 
-    if index < 16 {
-        1u64 << index
-    } else {
-        0
-    }
+    idx as usize
 }