SequenceEqual()

static unsafe bool System.SpanHelpers.SequenceEqual ( ref byte first, ref byte second, nuint length )

inlinestatic

Definition at line 1190 of file SpanHelpers.cs.

    {
        if (length < (nuint)sizeof(UIntPtr))
        {
            if (length < 4)
            {
                uint num = 0u;
                nuint num2 = length & 2;
                if (num2 != 0)
                {
                    num = LoadUShort(ref first);
                    num -= LoadUShort(ref second);
                }
                if ((length & 1) != 0)
                {
                    num |= (uint)(Unsafe.AddByteOffset(ref first, num2) - Unsafe.AddByteOffset(ref second, num2));
                }
                return num == 0;
            }
            nuint offset = length - 4;
            uint num3 = LoadUInt(ref first) - LoadUInt(ref second);
            num3 |= LoadUInt(ref first, offset) - LoadUInt(ref second, offset);
            return num3 == 0;
        }
        if (Unsafe.AreSame(ref first, ref second))
        {
            goto IL_0087;
        }
        nuint num5;
        nuint num7;
        nuint num9;
        Vector128<byte> value2;
        Vector256<byte> value;
        if (Sse2.IsSupported)
        {
            if (Avx2.IsSupported && length >= (nuint)Vector256<byte>.Count)
            {
                nuint num4 = 0u;
                num5 = length - (nuint)Vector256<byte>.Count;
                if (num5 == 0)
                {
                    goto IL_00ea;
                }
                while (true)
                {
                    value = Avx2.CompareEqual(LoadVector256(ref first, num4), LoadVector256(ref second, num4));
                    if (Avx2.MoveMask(value) != -1)
                    {
                        break;
                    }
                    num4 += (nuint)Vector256<byte>.Count;
                    if (num5 > num4)
                    {
                        continue;
                    }
                    goto IL_00ea;
                }
            }
            else
            {
                if (length < 16)
                {
                    goto IL_01fc;
                }
                nuint num6 = 0u;
                num7 = length - 16;
                if (num7 == 0)
                {
                    goto IL_0161;
                }
                while (true)
                {
                    value2 = Sse2.CompareEqual(LoadVector128(ref first, num6), LoadVector128(ref second, num6));
                    if (Sse2.MoveMask(value2) != 65535)
                    {
                        break;
                    }
                    num6 += 16;
                    if (num7 > num6)
                    {
                        continue;
                    }
                    goto IL_0161;
                }
            }
        }
        else
        {
            if (!Vector.IsHardwareAccelerated || length < (nuint)Vector<byte>.Count)
            {
                goto IL_01fc;
            }
            nuint num8 = 0u;
            num9 = length - (nuint)Vector<byte>.Count;
            if (num9 == 0)
            {
                goto IL_01dd;
            }
            while (!(LoadVector(ref first, num8) != LoadVector(ref second, num8)))
            {
                num8 += (nuint)Vector<byte>.Count;
                if (num9 > num8)
                {
                    continue;
                }
                goto IL_01dd;
            }
        }
        goto IL_0290;
        IL_01dd:
        if (LoadVector(ref first, num9) == LoadVector(ref second, num9))
        {
            goto IL_0087;
        }
        goto IL_0290;
        IL_0278:
        nuint num10;
        return LoadNUInt(ref first, num10) == LoadNUInt(ref second, num10);
        IL_0161:
        value2 = Sse2.CompareEqual(LoadVector128(ref first, num7), LoadVector128(ref second, num7));
        if (Sse2.MoveMask(value2) == 65535)
        {
            goto IL_0087;
        }
        goto IL_0290;
        IL_00ea:
        value = Avx2.CompareEqual(LoadVector256(ref first, num5), LoadVector256(ref second, num5));
        if (Avx2.MoveMask(value) == -1)
        {
            goto IL_0087;
        }
        goto IL_0290;
        IL_0290:
        return false;
        IL_0087:
        return true;
        IL_01fc:
        if (Sse2.IsSupported)
        {
            nuint offset2 = length - (nuint)sizeof(UIntPtr);
            nuint num11 = LoadNUInt(ref first) - LoadNUInt(ref second);
            num11 |= LoadNUInt(ref first, offset2) - LoadNUInt(ref second, offset2);
            return num11 == 0;
        }
        nuint num12 = 0u;
        num10 = length - (nuint)sizeof(UIntPtr);
        if (num10 == 0)
        {
            goto IL_0278;
        }
        while (LoadNUInt(ref first, num12) == LoadNUInt(ref second, num12))
        {
            num12 += (nuint)sizeof(UIntPtr);
            if (num10 > num12)
            {
                continue;
            }
            goto IL_0278;
        }
        goto IL_0290;
    }

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.length, System.SpanHelpers.LoadNUInt(), System.SpanHelpers.LoadUInt(), System.SpanHelpers.LoadUShort(), System.SpanHelpers.LoadVector(), System.SpanHelpers.LoadVector128(), System.SpanHelpers.LoadVector256(), System.Runtime.Intrinsics.X86.Sse2.MoveMask(), System.Runtime.Intrinsics.X86.Avx2.MoveMask(), System.offset, and System.value.

Referenced by System.MemoryExtensions.EndsWith< T >(), System.MemoryExtensions.EndsWith< T >(), System.MdUtf8String.Equals(), System.String.EqualsHelper(), System.SpanHelpers.IndexOf(), System.SpanHelpers.IndexOf(), System.SpanHelpers.IndexOf< T >(), System.SpanHelpers.LastIndexOf(), System.SpanHelpers.LastIndexOf< T >(), System.MemoryExtensions.SequenceEqual< T >(), System.MemoryExtensions.SequenceEqual< T >(), System.MemoryExtensions.SequenceEqual< T >(), System.String.StartsWith(), System.MemoryExtensions.StartsWith< T >(), and System.MemoryExtensions.StartsWith< T >().