Add optimized UTF-8 validation and transcoding apis, hook them up to UTF8Encoding

src/System.Private.CoreLib/shared/System.Private.CoreLib.Shared.projitems

@@ -768,6 +768,7 @@
     <Compile Include="$(MSBuildThisFileDirectory)System\SystemException.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Text\ASCIIEncoding.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Text\ASCIIUtility.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)System\Text\ASCIIUtility.Helpers.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Text\StringBuilderCache.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Text\CodePageDataItem.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Text\Decoder.cs" />
@@ -799,13 +800,17 @@
     <Compile Include="$(MSBuildThisFileDirectory)System\Text\UnicodeDebug.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Text\UnicodeEncoding.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Text\UnicodeUtility.cs" />
-    <Compile Include="$(MSBuildThisFileDirectory)System\Text\Utf16Utility.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Text\UTF32Encoding.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Text\UTF7Encoding.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Text\UTF8Encoding.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Text\ValueStringBuilder.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)System\Text\Unicode\Utf16Utility.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)System\Text\Unicode\Utf16Utility.Validation.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Text\Unicode\Utf8.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Text\Unicode\Utf8Utility.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)System\Text\Unicode\Utf8Utility.Helpers.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)System\Text\Unicode\Utf8Utility.Transcoding.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)System\Text\Unicode\Utf8Utility.Validation.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\TimeSpan.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\ThreadAttributes.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Threading\AbandonedMutexException.cs" />

src/System.Private.CoreLib/shared/System/Globalization/CompareInfo.cs

@@ -8,7 +8,7 @@
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Runtime.Serialization;
-using System.Text;
+using System.Text.Unicode;
 using Internal.Runtime.CompilerServices;
 
 namespace System.Globalization

src/System.Private.CoreLib/shared/System/Globalization/TextInfo.cs

@@ -8,6 +8,7 @@
 using System.Runtime.InteropServices;
 using System.Runtime.Serialization;
 using System.Text;
+using System.Text.Unicode;
 using Internal.Runtime.CompilerServices;
 
 #if BIT64

src/System.Private.CoreLib/shared/System/Marvin.OrdinalIgnoreCase.cs

@@ -5,7 +5,7 @@
 using System.Buffers;
 using System.Diagnostics;
 using System.Runtime.InteropServices;
-using System.Text;
+using System.Text.Unicode;
 using Internal.Runtime.CompilerServices;
 
 #if BIT64

src/System.Private.CoreLib/shared/System/Text/ASCIIEncoding.cs

@@ -159,7 +159,7 @@ private unsafe int GetByteCountCommon(char* pChars, int charCount)
             // Common helper method for all non-EncoderNLS entry points to GetByteCount.
             // A modification of this method should be copied in to each of the supported encodings: ASCII, UTF8, UTF16, UTF32.
 
-            Debug.Assert(charCount >= 0, "Caller should't specify negative length buffer.");
+            Debug.Assert(charCount >= 0, "Caller shouldn't specify negative length buffer.");
             Debug.Assert(pChars != null || charCount == 0, "Input pointer shouldn't be null if non-zero length specified.");
 
             // First call into the fast path.
@@ -340,9 +340,9 @@ private unsafe int GetBytesCommon(char* pChars, int charCount, byte* pBytes, int
             // Common helper method for all non-EncoderNLS entry points to GetBytes.
             // A modification of this method should be copied in to each of the supported encodings: ASCII, UTF8, UTF16, UTF32.
 
-            Debug.Assert(charCount >= 0, "Caller should't specify negative length buffer.");
+            Debug.Assert(charCount >= 0, "Caller shouldn't specify negative length buffer.");
             Debug.Assert(pChars != null || charCount == 0, "Input pointer shouldn't be null if non-zero length specified.");
-            Debug.Assert(byteCount >= 0, "Caller should't specify negative length buffer.");
+            Debug.Assert(byteCount >= 0, "Caller shouldn't specify negative length buffer.");
             Debug.Assert(pBytes != null || byteCount == 0, "Input pointer shouldn't be null if non-zero length specified.");
 
             // First call into the fast path.
@@ -496,7 +496,7 @@ private unsafe int GetCharCountCommon(byte* pBytes, int byteCount)
             // Common helper method for all non-DecoderNLS entry points to GetCharCount.
             // A modification of this method should be copied in to each of the supported encodings: ASCII, UTF8, UTF16, UTF32.
 
-            Debug.Assert(byteCount >= 0, "Caller should't specify negative length buffer.");
+            Debug.Assert(byteCount >= 0, "Caller shouldn't specify negative length buffer.");
             Debug.Assert(pBytes != null || byteCount == 0, "Input pointer shouldn't be null if non-zero length specified.");
 
             // First call into the fast path.
@@ -624,9 +624,9 @@ private unsafe int GetCharsCommon(byte* pBytes, int byteCount, char* pChars, int
             // Common helper method for all non-DecoderNLS entry points to GetChars.
             // A modification of this method should be copied in to each of the supported encodings: ASCII, UTF8, UTF16, UTF32.
 
-            Debug.Assert(byteCount >= 0, "Caller should't specify negative length buffer.");
+            Debug.Assert(byteCount >= 0, "Caller shouldn't specify negative length buffer.");
             Debug.Assert(pBytes != null || byteCount == 0, "Input pointer shouldn't be null if non-zero length specified.");
-            Debug.Assert(charCount >= 0, "Caller should't specify negative length buffer.");
+            Debug.Assert(charCount >= 0, "Caller shouldn't specify negative length buffer.");
             Debug.Assert(pChars != null || charCount == 0, "Input pointer shouldn't be null if non-zero length specified.");
 
             // First call into the fast path.

src/System.Private.CoreLib/shared/System/Text/ASCIIUtility.Helpers.cs

@@ -0,0 +1,108 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Diagnostics;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Runtime.Intrinsics.X86;
+
+namespace System.Text
+{
+    internal static partial class ASCIIUtility
+    {
+        /// <summary>
+        /// A mask which selects only the high bit of each byte of the given <see cref="uint"/>.
+        /// </summary>
+        private const uint UInt32HighBitsOnlyMask = 0x80808080u;
+
+        /// <summary>
+        /// A mask which selects only the high bit of each byte of the given <see cref="ulong"/>.
+        /// </summary>
+        private const ulong UInt64HighBitsOnlyMask = 0x80808080_80808080ul;
+
+        /// <summary>
+        /// Returns <see langword="true"/> iff all bytes in <paramref name="value"/> are ASCII.
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal static bool AllBytesInUInt32AreAscii(uint value)
+        {
+            // If the high bit of any byte is set, that byte is non-ASCII.
+
+            return (value & UInt32HighBitsOnlyMask) == 0;
+        }
+
+        /// <summary>
+        /// Given a DWORD which represents a four-byte buffer read in machine endianness, and which
+        /// the caller has asserted contains a non-ASCII byte *somewhere* in the data, counts the
+        /// number of consecutive ASCII bytes starting from the beginning of the buffer. Returns
+        /// a value 0 - 3, inclusive. (The caller is responsible for ensuring that the buffer doesn't
+        /// contain all-ASCII data.)
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal static uint CountNumberOfLeadingAsciiBytesFromUInt32WithSomeNonAsciiData(uint value)
+        {
+            Debug.Assert(!AllBytesInUInt32AreAscii(value), "Caller shouldn't provide an all-ASCII value.");
+
+            // Use BMI1 directly rather than going through BitOperations. We only see a perf gain here
+            // if we're able to emit a real tzcnt instruction; the software fallback used by BitOperations
+            // is too slow for our purposes since we can provide our own faster, specialized software fallback.
+
+            if (Bmi1.IsSupported)
+            {
+                Debug.Assert(BitConverter.IsLittleEndian);
+                return Bmi1.TrailingZeroCount(value & UInt32HighBitsOnlyMask) >> 3;
+            }
+
+            // Couldn't emit tzcnt, use specialized software fallback.
+            // The 'allBytesUpToNowAreAscii' DWORD uses bit twiddling to hold a 1 or a 0 depending
+            // on whether all processed bytes were ASCII. Then we accumulate all of the
+            // results to calculate how many consecutive ASCII bytes are present.
+
+            value = ~value;
+
+            if (BitConverter.IsLittleEndian)
+            {
+                // Read first byte
+                value >>= 7;
+                uint allBytesUpToNowAreAscii = value & 1;
+                uint numAsciiBytes = allBytesUpToNowAreAscii;
+
+                // Read second byte
+                value >>= 8;
+                allBytesUpToNowAreAscii &= value;
+                numAsciiBytes += allBytesUpToNowAreAscii;
+
+                // Read third byte
+                value >>= 8;
+                allBytesUpToNowAreAscii &= value;
+                numAsciiBytes += allBytesUpToNowAreAscii;
+
+                return numAsciiBytes;
+            }
+            else
+            {
+                // BinaryPrimitives.ReverseEndianness is only implemented as an intrinsic on
+                // little-endian platforms, so using it in this big-endian path would be too
+                // expensive. Instead we'll just change how we perform the shifts.
+
+                // Read first byte
+                value = BitOperations.RotateLeft(value, 1);
+                uint allBytesUpToNowAreAscii = value & 1;
+                uint numAsciiBytes = allBytesUpToNowAreAscii;
+
+                // Read second byte
+                value = BitOperations.RotateLeft(value, 8);
+                allBytesUpToNowAreAscii &= value;
+                numAsciiBytes += allBytesUpToNowAreAscii;
+
+                // Read third byte
+                value = BitOperations.RotateLeft(value, 8);
+                allBytesUpToNowAreAscii &= value;
+                numAsciiBytes += allBytesUpToNowAreAscii;
+
+                return numAsciiBytes;
+            }
+        }
+    }
+}

src/System.Private.CoreLib/shared/System/Text/ASCIIUtility.cs

@@ -21,19 +21,20 @@ namespace System.Text
 {
     internal static partial class ASCIIUtility
     {
-        /// <summary>
-        /// Returns <see langword="true"/> iff all bytes in <paramref name="value"/> are ASCII.
-        /// </summary>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static bool AllBytesInUInt32AreAscii(uint value)
+#if DEBUG
+        static ASCIIUtility()
         {
-            return ((value & 0x80808080u) == 0);
+            Debug.Assert(sizeof(nint) == IntPtr.Size && nint.MinValue < 0, "nint is defined incorrectly.");
+            Debug.Assert(sizeof(nuint) == IntPtr.Size && nuint.MinValue == 0, "nuint is defined incorrectly.");
         }
+#endif // DEBUG
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private static bool AllBytesInUInt64AreAscii(ulong value)
         {
-            return ((value & 0x80808080_80808080ul) == 0);
+            // If the high bit of any byte is set, that byte is non-ASCII.
+
+            return ((value & UInt64HighBitsOnlyMask) == 0);
         }
 
         /// <summary>
@@ -54,56 +55,6 @@ private static bool AllCharsInUInt64AreAscii(ulong value)
             return ((value & ~0x007F007F_007F007Ful) == 0);
         }
 
-        /// <summary>
-        /// Given a 24-bit integer which represents a three-byte buffer read in machine endianness,
-        /// counts the number of consecutive ASCII bytes starting from the beginning of the buffer.
-        /// Returns a value 0 - 3, inclusive.
-        /// </summary>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static uint CountNumberOfLeadingAsciiBytesFrom24BitInteger(uint value)
-        {
-            // This implementation seems to have better performance than tzcnt.
-
-            // The 'allBytesUpToNowAreAscii' DWORD uses bit twiddling to hold a 1 or a 0 depending
-            // on whether all processed bytes were ASCII. Then we accumulate all of the
-            // results to calculate how many consecutive ASCII bytes are present.
-
-            value = ~value;
-
-            if (BitConverter.IsLittleEndian)
-            {
-                // Read first byte
-                uint allBytesUpToNowAreAscii = (value >>= 7) & 1;
-                uint numAsciiBytes = allBytesUpToNowAreAscii;
-
-                // Read second byte
-                allBytesUpToNowAreAscii &= (value >>= 8);
-                numAsciiBytes += allBytesUpToNowAreAscii;
-
-                // Read third byte
-                allBytesUpToNowAreAscii &= (value >>= 8);
-                numAsciiBytes += allBytesUpToNowAreAscii;
-
-                return numAsciiBytes;
-            }
-            else
-            {
-                // Read first byte
-                uint allBytesUpToNowAreAscii = (value = ROL32(value, 1)) & 1;
-                uint numAsciiBytes = allBytesUpToNowAreAscii;
-
-                // Read second byte
-                allBytesUpToNowAreAscii &= (value = ROL32(value, 8));
-                numAsciiBytes += allBytesUpToNowAreAscii;
-
-                // Read third byte
-                allBytesUpToNowAreAscii &= (value = ROL32(value, 8));
-                numAsciiBytes += allBytesUpToNowAreAscii;
-
-                return numAsciiBytes;
-            }
-        }
-
         /// <summary>
         /// Given a DWORD which represents two packed chars in machine-endian order,
         /// <see langword="true"/> iff the first char (in machine-endian order) is ASCII.
@@ -273,7 +224,7 @@ private static unsafe nuint GetIndexOfFirstNonAsciiByte_Default(byte* pBuffer, n
             // we get to the high byte; or (b) all of the earlier bytes are ASCII, so the high byte must be
             // non-ASCII. In both cases we only care about the low 24 bits.
 
-            pBuffer += CountNumberOfLeadingAsciiBytesFrom24BitInteger(currentUInt32);
+            pBuffer += CountNumberOfLeadingAsciiBytesFromUInt32WithSomeNonAsciiData(currentUInt32);
             goto Finish;
         }
 
@@ -435,7 +386,7 @@ private static unsafe nuint GetIndexOfFirstNonAsciiByte_Sse2(byte* pBuffer, nuin
 
             uint currentDWord;
             Debug.Assert(!AllBytesInUInt32AreAscii(currentDWord), "Shouldn't be here unless we see non-ASCII data.");
-            pBuffer += CountNumberOfLeadingAsciiBytesFrom24BitInteger(currentDWord);
+            pBuffer += CountNumberOfLeadingAsciiBytesFromUInt32WithSomeNonAsciiData(currentDWord);
 
             goto Finish;
 
@@ -461,7 +412,7 @@ private static unsafe nuint GetIndexOfFirstNonAsciiByte_Sse2(byte* pBuffer, nuin
                         // Clear everything but the high bit of each byte, then tzcnt.
                         // Remember the / 8 at the end to convert bit count to byte count.
 
-                        candidateUInt64 &= 0x80808080_80808080ul;
+                        candidateUInt64 &= UInt64HighBitsOnlyMask;
                         pBuffer += (nuint)(Bmi1.X64.TrailingZeroCount(candidateUInt64) / 8);
                         goto Finish;
                     }
@@ -1395,17 +1346,7 @@ private static unsafe nuint NarrowUtf16ToAscii_Sse2(char* pUtf16Buffer, byte* pA
             // Turn the 8 ASCII chars we just read into 8 ASCII bytes, then copy it to the destination.
 
             Vector128<byte> asciiVector = Sse2.PackUnsignedSaturate(utf16VectorFirst, utf16VectorFirst);
-
-            if (Sse41.X64.IsSupported)
-            {
-                // Use PEXTRQ instruction if available, since it can extract from the vector directly to the destination address.
-                Unsafe.WriteUnaligned<ulong>(pAsciiBuffer, Sse41.X64.Extract(asciiVector.AsUInt64(), 0));
-            }
-            else
-            {
-                // Bounce this through a temporary register (with potential stack spillage) before writing to memory.
-                Unsafe.WriteUnaligned<ulong>(pAsciiBuffer, asciiVector.AsUInt64().GetElement(0));
-            }
+            Sse2.StoreLow((ulong*)pAsciiBuffer, asciiVector.AsUInt64()); // ulong* calculated here is UNALIGNED
 
             nuint currentOffsetInElements = SizeOfVector128 / 2; // we processed 8 elements so far
 
@@ -1444,16 +1385,7 @@ private static unsafe nuint NarrowUtf16ToAscii_Sse2(char* pUtf16Buffer, byte* pA
 
                 // Turn the 8 ASCII chars we just read into 8 ASCII bytes, then copy it to the destination.
                 asciiVector = Sse2.PackUnsignedSaturate(utf16VectorFirst, utf16VectorFirst);
-
-                // See comments earlier in this method for information about how this works.
-                if (Sse41.X64.IsSupported)
-                {
-                    Unsafe.WriteUnaligned<ulong>(pAsciiBuffer + currentOffsetInElements, Sse41.X64.Extract(asciiVector.AsUInt64(), 0));
-                }
-                else
-                {
-                    Unsafe.WriteUnaligned<ulong>(pAsciiBuffer + currentOffsetInElements, asciiVector.AsUInt64().GetElement(0));
-                }
+                Sse2.StoreLow((ulong*)(pAsciiBuffer + currentOffsetInElements), asciiVector.AsUInt64()); // ulong* calculated here is UNALIGNED
             }
 
             // Calculate how many elements we wrote in order to get pAsciiBuffer to its next alignment
@@ -1529,26 +1461,12 @@ private static unsafe nuint NarrowUtf16ToAscii_Sse2(char* pUtf16Buffer, byte* pA
 
             Debug.Assert(((nuint)pAsciiBuffer + currentOffsetInElements) % sizeof(ulong) == 0, "Destination should be ulong-aligned.");
 
-            // See comments earlier in this method for information about how this works.
-            if (Sse41.X64.IsSupported)
-            {
-                *(ulong*)(pAsciiBuffer + currentOffsetInElements) = Sse41.X64.Extract(asciiVector.AsUInt64(), 0);
-            }
-            else
-            {
-                *(ulong*)(pAsciiBuffer + currentOffsetInElements) = asciiVector.AsUInt64().GetElement(0);
-            }
+            Sse2.StoreLow((ulong*)(pAsciiBuffer + currentOffsetInElements), asciiVector.AsUInt64()); // ulong* calculated here is aligned
             currentOffsetInElements += SizeOfVector128 / 2;
 
             goto Finish;
         }
 
-        /// <summary>
-        /// Rotates a <see cref="uint"/> left. The JIT is smart enough to turn this into a ROL / ROR instruction.
-        /// </summary>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static uint ROL32(uint value, int shift) => (value << shift) | (value >> (32 - shift));
-
         /// <summary>
         /// Copies as many ASCII bytes (00..7F) as possible from <paramref name="pAsciiBuffer"/>
         /// to <paramref name="pUtf16Buffer"/>, stopping when the first non-ASCII byte is encountered