Vectorize IndexOf for OrdinalIgnoreCase

src/libraries/System.Private.CoreLib/src/System/Globalization/Ordinal.cs

@@ -4,6 +4,8 @@
 using System.Diagnostics;
 using System.Text.Unicode;
 using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Runtime.Intrinsics;
 
 namespace System.Globalization
 {
@@ -222,7 +224,6 @@ internal static int IndexOfOrdinalIgnoreCase(ReadOnlySpan<char> source, ReadOnly
                 // A non-linguistic search compares chars directly against one another, so large
                 // target strings can never be found inside small search spaces. This check also
                 // handles empty 'source' spans.
-
                 return -1;
             }
 
@@ -236,7 +237,80 @@ internal static int IndexOfOrdinalIgnoreCase(ReadOnlySpan<char> source, ReadOnly
                 return CompareInfo.NlsIndexOfOrdinalCore(source, value, ignoreCase: true, fromBeginning: true);
             }
 
-            return OrdinalCasing.IndexOf(source, value);
+            // if value starts with an ASCII char we can use a vectorized path
+            ref char valueRef = ref MemoryMarshal.GetReference(value);
+            char valueChar = valueRef;
+
+            if (!char.IsAscii(valueChar))
+            {
+                // Fallback to a more non-ASCII friendly version
+                return OrdinalCasing.IndexOf(source, value);
+            }
+
+
+            int valueTailLength = value.Length - 1;
+            ref char valueTail = ref Unsafe.Add(ref valueRef, 1);
+            ref char searchSpace = ref MemoryMarshal.GetReference(source);
+            int remainingSearchSpaceLength = source.Length - valueTailLength;
+
+            // hoist some expressions from the loop
+            char valueCharU = default;
+            char valueCharL = default;
+            bool isLetter = false;
+            nint offset = 0;
+
+            if ((uint)((valueChar | 0x20) - 'a') <= 'z' - 'a')
+            {
+                valueCharU = (char)(valueChar & ~0x20);
+                valueCharL = (char)(valueChar | 0x20);
+                isLetter = true;
+            }
+
+            while (remainingSearchSpaceLength > 0)
+            {
+                int relativeIndex;
+                if (isLetter)
+                {
+                    relativeIndex =
+                        SpanHelpers.IndexOfAny(
+                            ref Unsafe.Add(ref searchSpace, offset),
+                            valueCharU,
+                            valueCharL,
+                            remainingSearchSpaceLength);
+                }
+                else
+                {
+                    relativeIndex =
+                        SpanHelpers.IndexOf(
+                            ref Unsafe.Add(ref searchSpace, offset),
+                            valueChar,
+                            remainingSearchSpaceLength);
+                }
+
+                // Do a quick search for the first element of "value".
+                if (relativeIndex < 0)
+                    break;
+
+                remainingSearchSpaceLength -= relativeIndex;
+                offset += relativeIndex;
+
+                if (remainingSearchSpaceLength <= 0)
+                    break;  // The unsearched portion is now shorter than the sequence we're looking for. So it can't be there.
+
+                // Found the first element of "value". See if the tail matches.
+                if (EqualsIgnoreCase(
+                        ref Unsafe.Add(ref searchSpace, (nuint)(offset + 1)),
+                        ref valueTail,
+                        valueTailLength))
+                {
+                    return (int)offset;  // The tail matched. Return a successful find.
+                }
+
+                remainingSearchSpaceLength--;
+                offset++;
+            }
+
+            return -1;
         }
 
         internal static int LastIndexOf(string source, string value, int startIndex, int count)