Replace uses of TestZ intrinsic

xtqqczze · xtqqczze · commit bec9604f2cd8 · 2024-07-05T20:26:45.000+01:00
diff --git a/src/libraries/System.Private.CoreLib/src/System/Buffers/Text/Base64Decoder.cs b/src/libraries/System.Private.CoreLib/src/System/Buffers/Text/Base64Decoder.cs
@@ -791,7 +791,7 @@ private static unsafe void Avx2Decode(ref byte* srcBytes, ref byte* destBytes, b
                 Vector256<sbyte> hi = Avx2.Shuffle(lutHi, hiNibbles);
                 Vector256<sbyte> lo = Avx2.Shuffle(lutLo, loNibbles);
 
-                if (!Avx.TestZ(lo, hi))
+                if ((lo & hi) != Vector256<sbyte>.Zero)
                 {
                     break;
                 }
diff --git a/src/libraries/System.Private.CoreLib/src/System/Text/Ascii.Utility.cs b/src/libraries/System.Private.CoreLib/src/System/Text/Ascii.Utility.cs
@@ -1503,7 +1503,7 @@ private static bool VectorContainsNonAsciiChar(Vector128<byte> asciiVector)
             // prefer architecture specific intrinsic as they offer better perf
             if (Sse41.IsSupported)
             {
-                return !Sse41.TestZ(asciiVector, Vector128.Create((byte)0x80));
+                return (asciiVector & Vector128.Create((byte)0x80)) != Vector128<byte>.Zero;
             }
             else if (AdvSimd.Arm64.IsSupported)
             {
@@ -1520,22 +1520,13 @@ private static bool VectorContainsNonAsciiChar(Vector128<byte> asciiVector)
         private static bool VectorContainsNonAsciiChar(Vector128<ushort> utf16Vector)
         {
             // prefer architecture specific intrinsic as they offer better perf
-            if (Sse2.IsSupported)
+            if (Sse2.IsSupported && !Sse41.IsSupported)
             {
-                if (Sse41.IsSupported)
-                {
-                    Vector128<ushort> asciiMaskForTestZ = Vector128.Create((ushort)0xFF80);
-                    // If a non-ASCII bit is set in any WORD of the vector, we have seen non-ASCII data.
-                    return !Sse41.TestZ(utf16Vector.AsInt16(), asciiMaskForTestZ.AsInt16());
-                }
-                else
-                {
-                    Vector128<ushort> asciiMaskForAddSaturate = Vector128.Create((ushort)0x7F80);
-                    // The operation below forces the 0x8000 bit of each WORD to be set iff the WORD element
-                    // has value >= 0x0800 (non-ASCII). Then we'll treat the vector as a BYTE vector in order
-                    // to extract the mask. Reminder: the 0x0080 bit of each WORD should be ignored.
-                    return (Sse2.MoveMask(Sse2.AddSaturate(utf16Vector, asciiMaskForAddSaturate).AsByte()) & 0b_1010_1010_1010_1010) != 0;
-                }
+                Vector128<ushort> asciiMaskForAddSaturate = Vector128.Create((ushort)0x7F80);
+                // The operation below forces the 0x8000 bit of each WORD to be set iff the WORD element
+                // has value >= 0x0800 (non-ASCII). Then we'll treat the vector as a BYTE vector in order
+                // to extract the mask. Reminder: the 0x0080 bit of each WORD should be ignored.
+                return (Sse2.MoveMask(Sse2.AddSaturate(utf16Vector, asciiMaskForAddSaturate).AsByte()) & 0b_1010_1010_1010_1010) != 0;
             }
             else if (AdvSimd.Arm64.IsSupported)
             {
@@ -1556,18 +1547,10 @@ private static bool VectorContainsNonAsciiChar(Vector128<ushort> utf16Vector)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private static bool VectorContainsNonAsciiChar(Vector256<ushort> utf16Vector)
         {
-            if (Avx.IsSupported)
-            {
-                Vector256<ushort> asciiMaskForTestZ = Vector256.Create((ushort)0xFF80);
-                return !Avx.TestZ(utf16Vector.AsInt16(), asciiMaskForTestZ.AsInt16());
-            }
-            else
-            {
-                const ushort asciiMask = ushort.MaxValue - 127; // 0xFF80
-                Vector256<ushort> zeroIsAscii = utf16Vector & Vector256.Create(asciiMask);
-                // If a non-ASCII bit is set in any WORD of the vector, we have seen non-ASCII data.
-                return zeroIsAscii != Vector256<ushort>.Zero;
-            }
+            const ushort asciiMask = ushort.MaxValue - 127; // 0xFF80
+            Vector256<ushort> zeroIsAscii = utf16Vector & Vector256.Create(asciiMask);
+            // If a non-ASCII bit is set in any WORD of the vector, we have seen non-ASCII data.
+            return zeroIsAscii != Vector256<ushort>.Zero;
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -1600,14 +1583,13 @@ private static bool AllCharsInVectorAreAscii<T>(Vector128<T> vector)
             if (typeof(T) == typeof(byte))
             {
                 return
-                    Sse41.IsSupported ? Sse41.TestZ(vector.AsByte(), Vector128.Create((byte)0x80)) :
+                    Sse41.IsSupported ? (vector.AsByte(), Vector128.Create((byte)0x80)) != Vector128<byte>.Zero :
                     AdvSimd.Arm64.IsSupported ? AllBytesInUInt64AreAscii(AdvSimd.Arm64.MaxPairwise(vector.AsByte(), vector.AsByte()).AsUInt64().ToScalar()) :
                     vector.AsByte().ExtractMostSignificantBits() == 0;
             }
             else
             {
                 return
-                    Sse41.IsSupported ? Sse41.TestZ(vector.AsUInt16(), Vector128.Create((ushort)0xFF80)) :
                     AdvSimd.Arm64.IsSupported ? AllCharsInUInt64AreAscii(AdvSimd.Arm64.MaxPairwise(vector.AsUInt16(), vector.AsUInt16()).AsUInt64().ToScalar()) :
                     (vector.AsUInt16() & Vector128.Create((ushort)0xFF80)) == Vector128<ushort>.Zero;
             }
@@ -1623,14 +1605,12 @@ private static bool AllCharsInVectorAreAscii<T>(Vector256<T> vector)
             if (typeof(T) == typeof(byte))
             {
                 return
-                    Avx.IsSupported ? Avx.TestZ(vector.AsByte(), Vector256.Create((byte)0x80)) :
+                    Avx.IsSupported ? (vector.AsByte() & Vector256.Create((byte)0x80)) == Vector256<byte>.Zero:
                     vector.AsByte().ExtractMostSignificantBits() == 0;
             }
             else
             {
-                return
-                    Avx.IsSupported ? Avx.TestZ(vector.AsUInt16(), Vector256.Create((ushort)0xFF80)) :
-                    (vector.AsUInt16() & Vector256.Create((ushort)0xFF80)) == Vector256<ushort>.Zero;
+                return (vector.AsUInt16() & Vector256.Create((ushort)0xFF80)) == Vector256<ushort>.Zero:
             }
         }
 
diff --git a/src/libraries/System.Private.CoreLib/src/System/Text/Latin1Utility.cs b/src/libraries/System.Private.CoreLib/src/System/Text/Latin1Utility.cs
@@ -267,7 +267,7 @@ private static unsafe nuint GetIndexOfFirstNonLatin1Char_Sse2(char* pBuffer, nui
                     {
                         // If a non-Latin-1 bit is set in any WORD of the combined vector, we have seen non-Latin-1 data.
                         // Jump to the non-Latin-1 handler to figure out which particular vector contained non-Latin-1 data.
-                        if (!Sse41.TestZ(combinedVector, latin1MaskForTestZ))
+                        if ((combinedVector & latin1MaskForTestZ) != Vector128<ushort>.Zero)
                         {
                             goto FoundNonLatin1DataInFirstOrSecondVector;
                         }
@@ -312,7 +312,7 @@ private static unsafe nuint GetIndexOfFirstNonLatin1Char_Sse2(char* pBuffer, nui
             {
                 // If a non-Latin-1 bit is set in any WORD of the combined vector, we have seen non-Latin-1 data.
                 // Jump to the non-Latin-1 handler to figure out which particular vector contained non-Latin-1 data.
-                if (!Sse41.TestZ(firstVector, latin1MaskForTestZ))
+                if ((firstVector & latin1MaskForTestZ) != Vector128<ushort>.Zero)
                 {
                     goto FoundNonLatin1DataInFirstVector;
                 }
@@ -347,7 +347,7 @@ private static unsafe nuint GetIndexOfFirstNonLatin1Char_Sse2(char* pBuffer, nui
                 {
                     // If a non-Latin-1 bit is set in any WORD of the combined vector, we have seen non-Latin-1 data.
                     // Jump to the non-Latin-1 handler to figure out which particular vector contained non-Latin-1 data.
-                    if (!Sse41.TestZ(firstVector, latin1MaskForTestZ))
+                    if ((firstVector & latin1MaskForTestZ) != Vector128<ushort>.Zero)
                     {
                         goto FoundNonLatin1DataInFirstVector;
                     }
@@ -381,7 +381,7 @@ private static unsafe nuint GetIndexOfFirstNonLatin1Char_Sse2(char* pBuffer, nui
             if (Sse41.IsSupported)
 #pragma warning restore IntrinsicsInSystemPrivateCoreLibAttributeNotSpecificEnough
             {
-                if (!Sse41.TestZ(firstVector, latin1MaskForTestZ))
+                if ((firstVector & latin1MaskForTestZ) != Vector128<ushort>.Zero)
                 {
                     goto FoundNonLatin1DataInFirstVector;
                 }
@@ -795,7 +795,7 @@ private static unsafe nuint NarrowUtf16ToLatin1_Sse2(char* pUtf16Buffer, byte* p
             if (Sse41.IsSupported)
 #pragma warning restore IntrinsicsInSystemPrivateCoreLibAttributeNotSpecificEnough
             {
-                if (!Sse41.TestZ(utf16VectorFirst, latin1MaskForTestZ))
+                if ((utf16VectorFirst & latin1MaskForTestZ) != Vector128<short>.Zero)
                 {
                     return 0;
                 }
@@ -837,7 +837,7 @@ private static unsafe nuint NarrowUtf16ToLatin1_Sse2(char* pUtf16Buffer, byte* p
                 if (Sse41.IsSupported)
 #pragma warning restore IntrinsicsInSystemPrivateCoreLibAttributeNotSpecificEnough
                 {
-                    if (!Sse41.TestZ(utf16VectorFirst, latin1MaskForTestZ))
+                    if ((utf16VectorFirst & latin1MaskForTestZ) != Vector128<short>.Zero)
                     {
                         goto Finish;
                     }
@@ -878,7 +878,7 @@ private static unsafe nuint NarrowUtf16ToLatin1_Sse2(char* pUtf16Buffer, byte* p
                 if (Sse41.IsSupported)
 #pragma warning restore IntrinsicsInSystemPrivateCoreLibAttributeNotSpecificEnough
                 {
-                    if (!Sse41.TestZ(combinedVector, latin1MaskForTestZ))
+                    if ((combinedVector, & latin1MaskForTestZ) != Vector128<short>.Zero)
                     {
                         goto FoundNonLatin1DataInLoop;
                     }
@@ -914,7 +914,7 @@ private static unsafe nuint NarrowUtf16ToLatin1_Sse2(char* pUtf16Buffer, byte* p
             if (Sse41.IsSupported)
 #pragma warning restore IntrinsicsInSystemPrivateCoreLibAttributeNotSpecificEnough
             {
-                if (!Sse41.TestZ(utf16VectorFirst, latin1MaskForTestZ))
+                if ((utf16VectorFirst & latin1MaskForTestZ) != Vector128<short>.Zero)
                 {
                     goto Finish; // found non-Latin-1 data
                 }
diff --git a/src/libraries/System.Private.CoreLib/src/System/Text/Unicode/Utf8Utility.Transcoding.cs b/src/libraries/System.Private.CoreLib/src/System/Text/Unicode/Utf8Utility.Transcoding.cs
@@ -968,7 +968,7 @@ public static OperationStatus TranscodeToUtf8(char* pInputBuffer, int inputLengt
                             }
                             else
                             {
-                                if (!Sse41.TestZ(utf16Data, nonAsciiUtf16DataMask))
+                                if ((utf16Data & nonAsciiUtf16DataMask) != Vector128<short>.Zero)
                                 {
                                     goto LoopTerminatedDueToNonAsciiDataInVectorLocal;
                                 }

Original file line number	Diff line number	Diff line change
`@@ -791,7 +791,7 @@ private static unsafe void Avx2Decode(ref byte* srcBytes, ref byte* destBytes, b`
`791`	`791`	`Vector256<sbyte> hi = Avx2.Shuffle(lutHi, hiNibbles);`
`792`	`792`	`Vector256<sbyte> lo = Avx2.Shuffle(lutLo, loNibbles);`
`793`	`793`
`794`		`- if (!Avx.TestZ(lo, hi))`
	`794`	`+ if ((lo & hi) != Vector256<sbyte>.Zero)`
`795`	`795`	`{`
`796`	`796`	`break;`
`797`	`797`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1503,7 +1503,7 @@ private static bool VectorContainsNonAsciiChar(Vector128<byte> asciiVector)`
`1503`	`1503`	`// prefer architecture specific intrinsic as they offer better perf`
`1504`	`1504`	`if (Sse41.IsSupported)`
`1505`	`1505`	`{`
`1506`		`- return !Sse41.TestZ(asciiVector, Vector128.Create((byte)0x80));`
	`1506`	`+ return (asciiVector & Vector128.Create((byte)0x80)) != Vector128<byte>.Zero;`
`1507`	`1507`	`}`
`1508`	`1508`	`else if (AdvSimd.Arm64.IsSupported)`
`1509`	`1509`	`{`
`@@ -1520,22 +1520,13 @@ private static bool VectorContainsNonAsciiChar(Vector128<byte> asciiVector)`
`1520`	`1520`	`private static bool VectorContainsNonAsciiChar(Vector128<ushort> utf16Vector)`
`1521`	`1521`	`{`
`1522`	`1522`	`// prefer architecture specific intrinsic as they offer better perf`
`1523`		`- if (Sse2.IsSupported)`
	`1523`	`+ if (Sse2.IsSupported && !Sse41.IsSupported)`
`1524`	`1524`	`{`
`1525`		`- if (Sse41.IsSupported)`
`1526`		`- {`
`1527`		`- Vector128<ushort> asciiMaskForTestZ = Vector128.Create((ushort)0xFF80);`
`1528`		`- // If a non-ASCII bit is set in any WORD of the vector, we have seen non-ASCII data.`
`1529`		`- return !Sse41.TestZ(utf16Vector.AsInt16(), asciiMaskForTestZ.AsInt16());`
`1530`		`- }`
`1531`		`- else`
`1532`		`- {`
`1533`		`- Vector128<ushort> asciiMaskForAddSaturate = Vector128.Create((ushort)0x7F80);`
`1534`		`- // The operation below forces the 0x8000 bit of each WORD to be set iff the WORD element`
`1535`		`- // has value >= 0x0800 (non-ASCII). Then we'll treat the vector as a BYTE vector in order`
`1536`		`- // to extract the mask. Reminder: the 0x0080 bit of each WORD should be ignored.`
`1537`		`- return (Sse2.MoveMask(Sse2.AddSaturate(utf16Vector, asciiMaskForAddSaturate).AsByte()) & 0b_1010_1010_1010_1010) != 0;`
`1538`		`- }`
	`1525`	`+ Vector128<ushort> asciiMaskForAddSaturate = Vector128.Create((ushort)0x7F80);`
	`1526`	`+ // The operation below forces the 0x8000 bit of each WORD to be set iff the WORD element`
	`1527`	`+ // has value >= 0x0800 (non-ASCII). Then we'll treat the vector as a BYTE vector in order`
	`1528`	`+ // to extract the mask. Reminder: the 0x0080 bit of each WORD should be ignored.`
	`1529`	`+ return (Sse2.MoveMask(Sse2.AddSaturate(utf16Vector, asciiMaskForAddSaturate).AsByte()) & 0b_1010_1010_1010_1010) != 0;`
`1539`	`1530`	`}`
`1540`	`1531`	`else if (AdvSimd.Arm64.IsSupported)`
`1541`	`1532`	`{`
`@@ -1556,18 +1547,10 @@ private static bool VectorContainsNonAsciiChar(Vector128<ushort> utf16Vector)`
`1556`	`1547`	`[MethodImpl(MethodImplOptions.AggressiveInlining)]`
`1557`	`1548`	`private static bool VectorContainsNonAsciiChar(Vector256<ushort> utf16Vector)`
`1558`	`1549`	`{`
`1559`		`- if (Avx.IsSupported)`
`1560`		`- {`
`1561`		`- Vector256<ushort> asciiMaskForTestZ = Vector256.Create((ushort)0xFF80);`
`1562`		`- return !Avx.TestZ(utf16Vector.AsInt16(), asciiMaskForTestZ.AsInt16());`
`1563`		`- }`
`1564`		`- else`
`1565`		`- {`
`1566`		`- const ushort asciiMask = ushort.MaxValue - 127; // 0xFF80`
`1567`		`- Vector256<ushort> zeroIsAscii = utf16Vector & Vector256.Create(asciiMask);`
`1568`		`- // If a non-ASCII bit is set in any WORD of the vector, we have seen non-ASCII data.`
`1569`		`- return zeroIsAscii != Vector256<ushort>.Zero;`
`1570`		`- }`
	`1550`	`+ const ushort asciiMask = ushort.MaxValue - 127; // 0xFF80`
	`1551`	`+ Vector256<ushort> zeroIsAscii = utf16Vector & Vector256.Create(asciiMask);`
	`1552`	`+ // If a non-ASCII bit is set in any WORD of the vector, we have seen non-ASCII data.`
	`1553`	`+ return zeroIsAscii != Vector256<ushort>.Zero;`
`1571`	`1554`	`}`
`1572`	`1555`
`1573`	`1556`	`[MethodImpl(MethodImplOptions.AggressiveInlining)]`
`@@ -1600,14 +1583,13 @@ private static bool AllCharsInVectorAreAscii<T>(Vector128<T> vector)`
`1600`	`1583`	`if (typeof(T) == typeof(byte))`
`1601`	`1584`	`{`
`1602`	`1585`	`return`
`1603`		`- Sse41.IsSupported ? Sse41.TestZ(vector.AsByte(), Vector128.Create((byte)0x80)) :`
	`1586`	`+ Sse41.IsSupported ? (vector.AsByte(), Vector128.Create((byte)0x80)) != Vector128<byte>.Zero :`
`1604`	`1587`	`AdvSimd.Arm64.IsSupported ? AllBytesInUInt64AreAscii(AdvSimd.Arm64.MaxPairwise(vector.AsByte(), vector.AsByte()).AsUInt64().ToScalar()) :`
`1605`	`1588`	`vector.AsByte().ExtractMostSignificantBits() == 0;`
`1606`	`1589`	`}`
`1607`	`1590`	`else`
`1608`	`1591`	`{`
`1609`	`1592`	`return`
`1610`		`- Sse41.IsSupported ? Sse41.TestZ(vector.AsUInt16(), Vector128.Create((ushort)0xFF80)) :`
`1611`	`1593`	`AdvSimd.Arm64.IsSupported ? AllCharsInUInt64AreAscii(AdvSimd.Arm64.MaxPairwise(vector.AsUInt16(), vector.AsUInt16()).AsUInt64().ToScalar()) :`
`1612`	`1594`	`(vector.AsUInt16() & Vector128.Create((ushort)0xFF80)) == Vector128<ushort>.Zero;`
`1613`	`1595`	`}`
`@@ -1623,14 +1605,12 @@ private static bool AllCharsInVectorAreAscii<T>(Vector256<T> vector)`
`1623`	`1605`	`if (typeof(T) == typeof(byte))`
`1624`	`1606`	`{`
`1625`	`1607`	`return`
`1626`		`- Avx.IsSupported ? Avx.TestZ(vector.AsByte(), Vector256.Create((byte)0x80)) :`
	`1608`	`+ Avx.IsSupported ? (vector.AsByte() & Vector256.Create((byte)0x80)) == Vector256<byte>.Zero:`
`1627`	`1609`	`vector.AsByte().ExtractMostSignificantBits() == 0;`
`1628`	`1610`	`}`
`1629`	`1611`	`else`
`1630`	`1612`	`{`
`1631`		`- return`
`1632`		`- Avx.IsSupported ? Avx.TestZ(vector.AsUInt16(), Vector256.Create((ushort)0xFF80)) :`
`1633`		`- (vector.AsUInt16() & Vector256.Create((ushort)0xFF80)) == Vector256<ushort>.Zero;`
	`1613`	`+ return (vector.AsUInt16() & Vector256.Create((ushort)0xFF80)) == Vector256<ushort>.Zero:`
`1634`	`1614`	`}`
`1635`	`1615`	`}`
`1636`	`1616`
Original file line number	Diff line number	Diff line change
`@@ -267,7 +267,7 @@ private static unsafe nuint GetIndexOfFirstNonLatin1Char_Sse2(char* pBuffer, nui`
`267`	`267`	`{`
`268`	`268`	`// If a non-Latin-1 bit is set in any WORD of the combined vector, we have seen non-Latin-1 data.`
`269`	`269`	`// Jump to the non-Latin-1 handler to figure out which particular vector contained non-Latin-1 data.`
`270`		`- if (!Sse41.TestZ(combinedVector, latin1MaskForTestZ))`
	`270`	`+ if ((combinedVector & latin1MaskForTestZ) != Vector128<ushort>.Zero)`
`271`	`271`	`{`
`272`	`272`	`goto FoundNonLatin1DataInFirstOrSecondVector;`
`273`	`273`	`}`
`@@ -312,7 +312,7 @@ private static unsafe nuint GetIndexOfFirstNonLatin1Char_Sse2(char* pBuffer, nui`
`312`	`312`	`{`
`313`	`313`	`// If a non-Latin-1 bit is set in any WORD of the combined vector, we have seen non-Latin-1 data.`
`314`	`314`	`// Jump to the non-Latin-1 handler to figure out which particular vector contained non-Latin-1 data.`
`315`		`- if (!Sse41.TestZ(firstVector, latin1MaskForTestZ))`
	`315`	`+ if ((firstVector & latin1MaskForTestZ) != Vector128<ushort>.Zero)`
`316`	`316`	`{`
`317`	`317`	`goto FoundNonLatin1DataInFirstVector;`
`318`	`318`	`}`
`@@ -347,7 +347,7 @@ private static unsafe nuint GetIndexOfFirstNonLatin1Char_Sse2(char* pBuffer, nui`
`347`	`347`	`{`
`348`	`348`	`// If a non-Latin-1 bit is set in any WORD of the combined vector, we have seen non-Latin-1 data.`
`349`	`349`	`// Jump to the non-Latin-1 handler to figure out which particular vector contained non-Latin-1 data.`
`350`		`- if (!Sse41.TestZ(firstVector, latin1MaskForTestZ))`
	`350`	`+ if ((firstVector & latin1MaskForTestZ) != Vector128<ushort>.Zero)`
`351`	`351`	`{`
`352`	`352`	`goto FoundNonLatin1DataInFirstVector;`
`353`	`353`	`}`
`@@ -381,7 +381,7 @@ private static unsafe nuint GetIndexOfFirstNonLatin1Char_Sse2(char* pBuffer, nui`
`381`	`381`	`if (Sse41.IsSupported)`
`382`	`382`	`#pragma warning restore IntrinsicsInSystemPrivateCoreLibAttributeNotSpecificEnough`
`383`	`383`	`{`
`384`		`- if (!Sse41.TestZ(firstVector, latin1MaskForTestZ))`
	`384`	`+ if ((firstVector & latin1MaskForTestZ) != Vector128<ushort>.Zero)`
`385`	`385`	`{`
`386`	`386`	`goto FoundNonLatin1DataInFirstVector;`
`387`	`387`	`}`
`@@ -795,7 +795,7 @@ private static unsafe nuint NarrowUtf16ToLatin1_Sse2(char* pUtf16Buffer, byte* p`
`795`	`795`	`if (Sse41.IsSupported)`
`796`	`796`	`#pragma warning restore IntrinsicsInSystemPrivateCoreLibAttributeNotSpecificEnough`
`797`	`797`	`{`
`798`		`- if (!Sse41.TestZ(utf16VectorFirst, latin1MaskForTestZ))`
	`798`	`+ if ((utf16VectorFirst & latin1MaskForTestZ) != Vector128<short>.Zero)`
`799`	`799`	`{`
`800`	`800`	`return 0;`
`801`	`801`	`}`
`@@ -837,7 +837,7 @@ private static unsafe nuint NarrowUtf16ToLatin1_Sse2(char* pUtf16Buffer, byte* p`
`837`	`837`	`if (Sse41.IsSupported)`
`838`	`838`	`#pragma warning restore IntrinsicsInSystemPrivateCoreLibAttributeNotSpecificEnough`
`839`	`839`	`{`
`840`		`- if (!Sse41.TestZ(utf16VectorFirst, latin1MaskForTestZ))`
	`840`	`+ if ((utf16VectorFirst & latin1MaskForTestZ) != Vector128<short>.Zero)`
`841`	`841`	`{`
`842`	`842`	`goto Finish;`
`843`	`843`	`}`
`@@ -878,7 +878,7 @@ private static unsafe nuint NarrowUtf16ToLatin1_Sse2(char* pUtf16Buffer, byte* p`
`878`	`878`	`if (Sse41.IsSupported)`
`879`	`879`	`#pragma warning restore IntrinsicsInSystemPrivateCoreLibAttributeNotSpecificEnough`
`880`	`880`	`{`
`881`		`- if (!Sse41.TestZ(combinedVector, latin1MaskForTestZ))`
	`881`	`+ if ((combinedVector, & latin1MaskForTestZ) != Vector128<short>.Zero)`
`882`	`882`	`{`
`883`	`883`	`goto FoundNonLatin1DataInLoop;`
`884`	`884`	`}`
`@@ -914,7 +914,7 @@ private static unsafe nuint NarrowUtf16ToLatin1_Sse2(char* pUtf16Buffer, byte* p`
`914`	`914`	`if (Sse41.IsSupported)`
`915`	`915`	`#pragma warning restore IntrinsicsInSystemPrivateCoreLibAttributeNotSpecificEnough`
`916`	`916`	`{`
`917`		`- if (!Sse41.TestZ(utf16VectorFirst, latin1MaskForTestZ))`
	`917`	`+ if ((utf16VectorFirst & latin1MaskForTestZ) != Vector128<short>.Zero)`
`918`	`918`	`{`
`919`	`919`	`goto Finish; // found non-Latin-1 data`
`920`	`920`	`}`
Original file line number	Diff line number	Diff line change
`@@ -968,7 +968,7 @@ public static OperationStatus TranscodeToUtf8(char* pInputBuffer, int inputLengt`
`968`	`968`	`}`
`969`	`969`	`else`
`970`	`970`	`{`
`971`		`- if (!Sse41.TestZ(utf16Data, nonAsciiUtf16DataMask))`
	`971`	`+ if ((utf16Data & nonAsciiUtf16DataMask) != Vector128<short>.Zero)`
`972`	`972`	`{`
`973`	`973`	`goto LoopTerminatedDueToNonAsciiDataInVectorLocal;`
`974`	`974`	`}`