Avoid scalar fallback in chunk remainder check

Refactor the eq check into an inner function for reuse in tail checking

Rather than fall back to the simple implementation for tail handling,
load the last 16 bytes to take advantage of vectorization. This doesn't
seem to negatively impact check time even when the remainder count is low.

Author: okaneco

library/core/src/slice/ascii.rs

@@ -90,35 +90,50 @@ impl [u8] {
         true
     }
 
-    /// Optimized version of `eq_ignore_ascii_case` which processes chunks at a
-    /// time.
+    /// Optimized version of `eq_ignore_ascii_case` for byte lengths of at least
+    /// 16 bytes, which processes chunks at a time.
     ///
     /// Platforms that have SIMD instructions may benefit from this
     /// implementation over `eq_ignore_ascii_case_simple`.
     #[cfg(all(target_arch = "x86_64", target_feature = "sse2"))]
     #[inline]
     const fn eq_ignore_ascii_case_chunks(&self, other: &[u8]) -> bool {
         const N: usize = 16;
-        let (a, a_rem) = self.as_chunks::<N>();
-        let (b, b_rem) = other.as_chunks::<N>();
+        let (self_chunks, self_rem) = self.as_chunks::<N>();
+        let (other_chunks, _) = other.as_chunks::<N>();
 
-        let mut i = 0;
-        while i < a.len() && i < b.len() {
+        // Branchless check to encourage auto-vectorization
+        const fn eq_ignore_ascii_inner(lhs: &[u8; N], rhs: &[u8; N]) -> bool {
             let mut equal_ascii = true;
             let mut j = 0;
             while j < N {
-                equal_ascii &= a[i][j].eq_ignore_ascii_case(&b[i][j]);
+                equal_ascii &= lhs[j].eq_ignore_ascii_case(&rhs[j]);
                 j += 1;
             }
 
-            if !equal_ascii {
+            equal_ascii
+        }
+
+        // Process the chunks, returning early if an inequality is found
+        let mut i = 0;
+        while i < self_chunks.len() && i < other_chunks.len() {
+            if !eq_ignore_ascii_inner(&self_chunks[i], &other_chunks[i]) {
                 return false;
             }
-
             i += 1;
         }
 
-        a_rem.eq_ignore_ascii_case_simple(b_rem)
+        // If there are remaining tails, load the last N bytes in the slices to
+        // avoid falling back to per-byte checking.
+        if !self_rem.is_empty() {
+            if let (Some(a_rem), Some(b_rem)) = (self.last_chunk::<N>(), other.last_chunk::<N>()) {
+                if !eq_ignore_ascii_inner(a_rem, b_rem) {
+                    return false;
+                }
+            }
+        }
+
+        true
     }
 
     /// Converts this slice to its ASCII upper case equivalent in-place.