IndexOfAny() [1/6]

static int System.SpanHelpers.IndexOfAny ( ref byte searchSpace, byte value0, byte value1, byte value2, int length )

inlinestatic

Definition at line 717 of file SpanHelpers.cs.

    {
        nuint num = 0u;
        nuint num2 = (uint)length;
        if (Sse2.IsSupported || AdvSimd.Arm64.IsSupported)
        {
            if (length >= Vector128<byte>.Count * 2)
            {
                num2 = UnalignedCountVector128(ref searchSpace);
            }
        }
        else if (Vector.IsHardwareAccelerated && length >= Vector<byte>.Count * 2)
        {
            num2 = UnalignedCountVector(ref searchSpace);
        }
        while (true)
        {
            if (num2 >= 8)
            {
                num2 -= 8;
                uint num3 = Unsafe.AddByteOffset(ref searchSpace, num);
                if (value0 == num3 || value1 == num3 || value2 == num3)
                {
                    goto IL_0504;
                }
                num3 = Unsafe.AddByteOffset(ref searchSpace, num + 1);
                if (value0 == num3 || value1 == num3 || value2 == num3)
                {
                    goto IL_0507;
                }
                num3 = Unsafe.AddByteOffset(ref searchSpace, num + 2);
                if (value0 == num3 || value1 == num3 || value2 == num3)
                {
                    goto IL_050d;
                }
                num3 = Unsafe.AddByteOffset(ref searchSpace, num + 3);
                if (value0 != num3 && value1 != num3 && value2 != num3)
                {
                    num3 = Unsafe.AddByteOffset(ref searchSpace, num + 4);
                    if (value0 != num3 && value1 != num3 && value2 != num3)
                    {
                        num3 = Unsafe.AddByteOffset(ref searchSpace, num + 5);
                        if (value0 != num3 && value1 != num3 && value2 != num3)
                        {
                            num3 = Unsafe.AddByteOffset(ref searchSpace, num + 6);
                            if (value0 != num3 && value1 != num3 && value2 != num3)
                            {
                                num3 = Unsafe.AddByteOffset(ref searchSpace, num + 7);
                                if (value0 == num3 || value1 == num3 || value2 == num3)
                                {
                                    break;
                                }
                                num += 8;
                                continue;
                            }
                            return (int)(num + 6);
                        }
                        return (int)(num + 5);
                    }
                    return (int)(num + 4);
                }
                goto IL_0513;
            }
            if (num2 >= 4)
            {
                num2 -= 4;
                uint num3 = Unsafe.AddByteOffset(ref searchSpace, num);
                if (value0 == num3 || value1 == num3 || value2 == num3)
                {
                    goto IL_0504;
                }
                num3 = Unsafe.AddByteOffset(ref searchSpace, num + 1);
                if (value0 == num3 || value1 == num3 || value2 == num3)
                {
                    goto IL_0507;
                }
                num3 = Unsafe.AddByteOffset(ref searchSpace, num + 2);
                if (value0 == num3 || value1 == num3 || value2 == num3)
                {
                    goto IL_050d;
                }
                num3 = Unsafe.AddByteOffset(ref searchSpace, num + 3);
                if (value0 == num3 || value1 == num3 || value2 == num3)
                {
                    goto IL_0513;
                }
                num += 4;
            }
            while (num2 != 0)
            {
                num2--;
                uint num3 = Unsafe.AddByteOffset(ref searchSpace, num);
                if (value0 != num3 && value1 != num3 && value2 != num3)
                {
                    num++;
                    continue;
                }
                goto IL_0504;
            }
            if (Avx2.IsSupported)
            {
                if (num < (uint)length)
                {
                    num2 = GetByteVector256SpanLength(num, length);
                    if (num2 > num)
                    {
                        Vector256<byte> left = Vector256.Create(value0);
                        Vector256<byte> left2 = Vector256.Create(value1);
                        Vector256<byte> left3 = Vector256.Create(value2);
                        do
                        {
                            Vector256<byte> right = LoadVector256(ref searchSpace, num);
                            Vector256<byte> left4 = Avx2.CompareEqual(left, right);
                            Vector256<byte> right2 = Avx2.CompareEqual(left2, right);
                            Vector256<byte> right3 = Avx2.CompareEqual(left3, right);
                            int num4 = Avx2.MoveMask(Avx2.Or(Avx2.Or(left4, right2), right3));
                            if (num4 == 0)
                            {
                                num += (nuint)Vector256<byte>.Count;
                                continue;
                            }
                            return (int)(num + (uint)BitOperations.TrailingZeroCount(num4));
                        }
                        while (num2 > num);
                    }
                    num2 = GetByteVector128SpanLength(num, length);
                    if (num2 > num)
                    {
                        Vector128<byte> left5 = Vector128.Create(value0);
                        Vector128<byte> left6 = Vector128.Create(value1);
                        Vector128<byte> left7 = Vector128.Create(value2);
                        Vector128<byte> right4 = LoadVector128(ref searchSpace, num);
                        Vector128<byte> left8 = Sse2.CompareEqual(left5, right4);
                        Vector128<byte> right5 = Sse2.CompareEqual(left6, right4);
                        Vector128<byte> right6 = Sse2.CompareEqual(left7, right4);
                        int num5 = Sse2.MoveMask(Sse2.Or(Sse2.Or(left8, right5), right6));
                        if (num5 != 0)
                        {
                            return (int)(num + (uint)BitOperations.TrailingZeroCount(num5));
                        }
                        num += (nuint)Vector128<byte>.Count;
                    }
                    if (num < (uint)length)
                    {
                        num2 = (uint)length - num;
                        continue;
                    }
                }
            }
            else if (Sse2.IsSupported)
            {
                if (num < (uint)length)
                {
                    num2 = GetByteVector128SpanLength(num, length);
                    Vector128<byte> left9 = Vector128.Create(value0);
                    Vector128<byte> left10 = Vector128.Create(value1);
                    Vector128<byte> left11 = Vector128.Create(value2);
                    for (; num2 > num; num += (nuint)Vector128<byte>.Count)
                    {
                        Vector128<byte> right7 = LoadVector128(ref searchSpace, num);
                        Vector128<byte> left12 = Sse2.CompareEqual(left9, right7);
                        Vector128<byte> right8 = Sse2.CompareEqual(left10, right7);
                        Vector128<byte> right9 = Sse2.CompareEqual(left11, right7);
                        int num6 = Sse2.MoveMask(Sse2.Or(Sse2.Or(left12, right8), right9));
                        if (num6 != 0)
                        {
                            return (int)(num + (uint)BitOperations.TrailingZeroCount(num6));
                        }
                    }
                    if (num < (uint)length)
                    {
                        num2 = (uint)length - num;
                        continue;
                    }
                }
            }
            else
            {
                if (AdvSimd.Arm64.IsSupported)
                {
                }
                if (Vector.IsHardwareAccelerated && num < (uint)length)
                {
                    num2 = GetByteVectorSpanLength(num, length);
                    Vector<byte> right10 = new Vector<byte>(value0);
                    Vector<byte> right11 = new Vector<byte>(value1);
                    Vector<byte> right12 = new Vector<byte>(value2);
                    for (; num2 > num; num += (nuint)Vector<byte>.Count)
                    {
                        Vector<byte> left13 = LoadVector(ref searchSpace, num);
                        Vector<byte> vector = Vector.BitwiseOr(Vector.BitwiseOr(Vector.Equals(left13, right10), Vector.Equals(left13, right11)), Vector.Equals(left13, right12));
                        if (!Vector<byte>.Zero.Equals(vector))
                        {
                            return (int)num + LocateFirstFoundByte(vector);
                        }
                    }
                    if (num < (uint)length)
                    {
                        num2 = (uint)length - num;
                        continue;
                    }
                }
            }
            return -1;
            IL_0507:
            return (int)(num + 1);
            IL_0513:
            return (int)(num + 3);
            IL_050d:
            return (int)(num + 2);
            IL_0504:
            return (int)num;
        }
        return (int)(num + 7);
    }

References System.Runtime.Intrinsics.X86.Sse2.CompareEqual(), System.Runtime.Intrinsics.X86.Avx2.CompareEqual(), System.Collections.Generic.Dictionary< TKey, TValue >.Count, System.Runtime.Intrinsics.Vector128< T >.Create(), System.Runtime.Intrinsics.Vector256< T >.Create(), System.Numerics.Vector< T >.Equals(), System.SpanHelpers.GetByteVector128SpanLength(), System.SpanHelpers.GetByteVector256SpanLength(), System.SpanHelpers.GetByteVectorSpanLength(), System.Numerics.Vector< T >.IsHardwareAccelerated, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.IsSupported, System.Runtime.Intrinsics.X86.Avx2.IsSupported, System.Runtime.Intrinsics.X86.Sse2.IsSupported, System.length, System.SpanHelpers.LoadVector(), System.SpanHelpers.LoadVector128(), System.SpanHelpers.LoadVector256(), System.SpanHelpers.LocateFirstFoundByte(), System.Runtime.Intrinsics.X86.Sse2.MoveMask(), System.Runtime.Intrinsics.X86.Avx2.MoveMask(), System.Runtime.Intrinsics.X86.Sse2.Or(), System.Runtime.Intrinsics.X86.Avx2.Or(), System.Numerics.BitOperations.TrailingZeroCount(), System.SpanHelpers.UnalignedCountVector(), and System.SpanHelpers.UnalignedCountVector128().