SequenceCompareTo() [1/2]

static unsafe int System.SpanHelpers.SequenceCompareTo ( ref byte first, int firstLength, ref byte second, int secondLength )

inlinestatic

Definition at line 1370 of file SpanHelpers.cs.

    {
        nuint num;
        uint num6;
        nuint num3;
        nuint num2;
        if (!Unsafe.AreSame(ref first, ref second))
        {
            num = (uint)(((uint)firstLength < (uint)secondLength) ? firstLength : secondLength);
            num2 = 0u;
            num3 = num;
            if (!Avx2.IsSupported)
            {
                if (Sse2.IsSupported)
                {
                    if (num3 >= (nuint)Vector128<byte>.Count)
                    {
                        num3 -= (nuint)Vector128<byte>.Count;
                        while (true)
                        {
                            uint num4;
                            if (num3 > num2)
                            {
                                num4 = (uint)Sse2.MoveMask(Sse2.CompareEqual(LoadVector128(ref first, num2), LoadVector128(ref second, num2)));
                                if (num4 == 65535)
                                {
                                    num2 += (nuint)Vector128<byte>.Count;
                                    continue;
                                }
                            }
                            else
                            {
                                num2 = num3;
                                num4 = (uint)Sse2.MoveMask(Sse2.CompareEqual(LoadVector128(ref first, num2), LoadVector128(ref second, num2)));
                                if (num4 == 65535)
                                {
                                    break;
                                }
                            }
                            uint value = ~num4;
                            num2 += (uint)BitOperations.TrailingZeroCount(value);
                            return Unsafe.AddByteOffset(ref first, num2).CompareTo(Unsafe.AddByteOffset(ref second, num2));
                        }
                        goto IL_0277;
                    }
                }
                else if (Vector.IsHardwareAccelerated && num3 > (nuint)Vector<byte>.Count)
                {
                    for (num3 -= (nuint)Vector<byte>.Count; num3 > num2 && !(LoadVector(ref first, num2) != LoadVector(ref second, num2)); num2 += (nuint)Vector<byte>.Count)
                    {
                    }
                    goto IL_0273;
                }
                goto IL_021b;
            }
            if (num3 >= (nuint)Vector256<byte>.Count)
            {
                num3 -= (nuint)Vector256<byte>.Count;
                while (true)
                {
                    uint num5;
                    if (num3 > num2)
                    {
                        num5 = (uint)Avx2.MoveMask(Avx2.CompareEqual(LoadVector256(ref first, num2), LoadVector256(ref second, num2)));
                        if (num5 == uint.MaxValue)
                        {
                            num2 += (nuint)Vector256<byte>.Count;
                            continue;
                        }
                    }
                    else
                    {
                        num2 = num3;
                        num5 = (uint)Avx2.MoveMask(Avx2.CompareEqual(LoadVector256(ref first, num2), LoadVector256(ref second, num2)));
                        if (num5 == uint.MaxValue)
                        {
                            break;
                        }
                    }
                    uint value2 = ~num5;
                    num2 += (uint)BitOperations.TrailingZeroCount(value2);
                    return Unsafe.AddByteOffset(ref first, num2).CompareTo(Unsafe.AddByteOffset(ref second, num2));
                }
            }
            else
            {
                if (num3 < (nuint)Vector128<byte>.Count)
                {
                    goto IL_021b;
                }
                num3 -= (nuint)Vector128<byte>.Count;
                if (num3 > num2)
                {
                    num6 = (uint)Sse2.MoveMask(Sse2.CompareEqual(LoadVector128(ref first, num2), LoadVector128(ref second, num2)));
                    if (num6 != 65535)
                    {
                        goto IL_0111;
                    }
                }
                num2 = num3;
                num6 = (uint)Sse2.MoveMask(Sse2.CompareEqual(LoadVector128(ref first, num2), LoadVector128(ref second, num2)));
                if (num6 != 65535)
                {
                    goto IL_0111;
                }
            }
        }
        goto IL_0277;
        IL_0277:
        return firstLength - secondLength;
        IL_0273:
        for (; num > num2; num2++)
        {
            int num7 = Unsafe.AddByteOffset(ref first, num2).CompareTo(Unsafe.AddByteOffset(ref second, num2));
            if (num7 != 0)
            {
                return num7;
            }
        }
        goto IL_0277;
        IL_021b:
        if (num3 > (nuint)sizeof(UIntPtr))
        {
            for (num3 -= (nuint)sizeof(UIntPtr); num3 > num2 && LoadNUInt(ref first, num2) == LoadNUInt(ref second, num2); num2 += (nuint)sizeof(UIntPtr))
            {
            }
        }
        goto IL_0273;
        IL_0111:
        uint value3 = ~num6;
        num2 += (uint)BitOperations.TrailingZeroCount(value3);
        return Unsafe.AddByteOffset(ref first, num2).CompareTo(Unsafe.AddByteOffset(ref second, num2));
    }

References System.Runtime.Intrinsics.X86.Sse2.CompareEqual(), System.Runtime.Intrinsics.X86.Avx2.CompareEqual(), System.Collections.Generic.Dictionary< TKey, TValue >.Count, System.Numerics.Vector< T >.IsHardwareAccelerated, System.Runtime.Intrinsics.X86.Avx2.IsSupported, System.Runtime.Intrinsics.X86.Sse2.IsSupported, System.SpanHelpers.LoadNUInt(), System.SpanHelpers.LoadVector(), System.SpanHelpers.LoadVector128(), System.SpanHelpers.LoadVector256(), System.Runtime.Intrinsics.X86.Sse2.MoveMask(), System.Runtime.Intrinsics.X86.Avx2.MoveMask(), System.Numerics.BitOperations.TrailingZeroCount(), and System.value.

Referenced by System.String.CompareOrdinal(), System.String.CompareOrdinalHelper(), System.MemoryExtensions.SequenceCompareTo< T >(), and System.MemoryExtensions.SequenceCompareTo< T >().