Fix ARM64 decompression reuse and optimize NEON implementations (#411)

- Fixes `test_decompress_reuse_mixed` on ARM by properly resetting the
  `Decompressor` state fields (state, is_final_block, bitbuf, bitsleft)
  at the end of `decompress_ptr` for non-x86 code paths.
- Optimizes `match_len_neon` to process 32 bytes per iteration instead
  of 16, using combined XOR masks and 32-bit zero checks.
- Optimizes `adler32_arm_neon` to unroll the 8-iteration `vmlal` loop
  manually, removing branching overhead.
- Optimizes `adler32_arm_neon_dotprod` by unrolling the accumulation
  loop to a 128-byte stride from 64-byte.
- Adds microbenchmarks for ARM64 Adler32 and CRC32 variants.

Co-authored-by: google-labs-jules[bot] <161369871+google-labs-jules[bot]@users.noreply.github.com>

Author: 404Setup

benches/bench_arm_adler32.rs

@@ -0,0 +1,18 @@
+use criterion::{black_box, criterion_group, criterion_main, Criterion};
+
+#[cfg(target_arch = "aarch64")]
+use libdeflate::adler32::adler32;
+
+#[cfg(target_arch = "aarch64")]
+fn bench_adler32(c: &mut Criterion) {
+    let data = vec![0u8; 1024 * 1024]; // 1MB
+    c.bench_function("adler32_1mb", |b| {
+        b.iter(|| adler32(black_box(1), black_box(&data)))
+    });
+}
+
+#[cfg(not(target_arch = "aarch64"))]
+fn bench_adler32(_: &mut Criterion) {}
+
+criterion_group!(benches, bench_adler32);
+criterion_main!(benches);

src/compress/matchfinder.rs

@@ -667,11 +667,49 @@ unsafe fn match_len_avx10(a: *const u8, b: *const u8, max_len: usize) -> usize {
 #[inline]
 unsafe fn match_len_neon(a: *const u8, b: *const u8, max_len: usize) -> usize {
     let mut len = 0;
-    while len + 16 <= max_len {
+
+    // Process 32 bytes per iteration if possible
+    while len + 32 <= max_len {
+        let v1_0 = vld1q_u8(a.add(len));
+        let v2_0 = vld1q_u8(b.add(len));
+        let v1_1 = vld1q_u8(a.add(len + 16));
+        let v2_1 = vld1q_u8(b.add(len + 16));
+
+        let xor0 = veorq_u8(v1_0, v2_0);
+        let xor1 = veorq_u8(v1_1, v2_1);
+        let xor_combined = vorrq_u8(xor0, xor1);
+
+        if vmaxvq_u32(vreinterpretq_u32_u8(xor_combined)) == 0 {
+            len += 32;
+        } else {
+            if vmaxvq_u32(vreinterpretq_u32_u8(xor0)) != 0 {
+                let xor64 = vreinterpretq_u64_u8(xor0);
+                let low = vgetq_lane_u64::<0>(xor64);
+                if low == 0 {
+                    let high = vgetq_lane_u64::<1>(xor64);
+                    return len + 8 + (high.to_le().trailing_zeros() as usize >> 3);
+                } else {
+                    return len + (low.to_le().trailing_zeros() as usize >> 3);
+                }
+            } else {
+                let xor64 = vreinterpretq_u64_u8(xor1);
+                let low = vgetq_lane_u64::<0>(xor64);
+                if low == 0 {
+                    let high = vgetq_lane_u64::<1>(xor64);
+                    return len + 24 + (high.to_le().trailing_zeros() as usize >> 3);
+                } else {
+                    return len + 16 + (low.to_le().trailing_zeros() as usize >> 3);
+                }
+            }
+        }
+    }
+
+    // Process 16 bytes
+    if len + 16 <= max_len {
         let v1 = vld1q_u8(a.add(len));
         let v2 = vld1q_u8(b.add(len));
         let xor = veorq_u8(v1, v2);
-        if vmaxvq_u8(xor) == 0 {
+        if vmaxvq_u32(vreinterpretq_u32_u8(xor)) == 0 {
             len += 16;
         } else {
             let xor64 = vreinterpretq_u64_u8(xor);
@@ -684,6 +722,7 @@ unsafe fn match_len_neon(a: *const u8, b: *const u8, max_len: usize) -> usize {
             }
         }
     }
+
     len + match_len_sw(a.add(len), b.add(len), max_len - len)
 }
 

src/decompress/mod.rs

@@ -196,7 +196,12 @@ impl Decompressor {
         self.is_final_block = false;
 
         let mut out_idx = 0;
-        unsafe { self.decompress_streaming_ptr(input, out_ptr, out_len, &mut out_idx) }
+        let res = unsafe { self.decompress_streaming_ptr(input, out_ptr, out_len, &mut out_idx) };
+        self.state = DecompressorState::Start;
+        self.is_final_block = false;
+        self.bitbuf = 0;
+        self.bitsleft = 0;
+        res
     }
 
     pub fn decompress_streaming(