◆ IndexOf() [1/4]

static unsafe int System.SpanHelpers.IndexOf	(	ref byte	searchSpace,
		byte	value,
		int	length )
inlinestatic
Definition at line 167 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;
                if (value == Unsafe.AddByteOffset(ref searchSpace, num))
                {
                    goto IL_033c;
                }
                if (value == Unsafe.AddByteOffset(ref searchSpace, num + 1))
                {
                    goto IL_033f;
                }
                if (value == Unsafe.AddByteOffset(ref searchSpace, num + 2))
                {
                    goto IL_0345;
                }
                if (value != Unsafe.AddByteOffset(ref searchSpace, num + 3))
                {
                    if (value != Unsafe.AddByteOffset(ref searchSpace, num + 4))
                    {
                        if (value != Unsafe.AddByteOffset(ref searchSpace, num + 5))
                        {
                            if (value != Unsafe.AddByteOffset(ref searchSpace, num + 6))
                            {
                                if (value == Unsafe.AddByteOffset(ref searchSpace, num + 7))
                                {
                                    break;
                                }
                                num += 8;
                                continue;
                            }
                            return (int)(num + 6);
                        }
                        return (int)(num + 5);
                    }
                    return (int)(num + 4);
                }
                goto IL_034b;
            }
            if (num2 >= 4)
            {
                num2 -= 4;
                if (value == Unsafe.AddByteOffset(ref searchSpace, num))
                {
                    goto IL_033c;
                }
                if (value == Unsafe.AddByteOffset(ref searchSpace, num + 1))
                {
                    goto IL_033f;
                }
                if (value == Unsafe.AddByteOffset(ref searchSpace, num + 2))
                {
                    goto IL_0345;
                }
                if (value == Unsafe.AddByteOffset(ref searchSpace, num + 3))
                {
                    goto IL_034b;
                }
                num += 4;
            }
            while (num2 != 0)
            {
                num2--;
                if (value != Unsafe.AddByteOffset(ref searchSpace, num))
                {
                    num++;
                    continue;
                }
                goto IL_033c;
            }
            if (Avx2.IsSupported)
            {
                if (num < (uint)length)
                {
                    if ((((uint)Unsafe.AsPointer(ref searchSpace) + num) & (nuint)(Vector256<byte>.Count - 1)) != 0)
                    {
                        Vector128<byte> left = Vector128.Create(value);
                        Vector128<byte> right = LoadVector128(ref searchSpace, num);
                        int num3 = Sse2.MoveMask(Sse2.CompareEqual(left, right));
                        if (num3 != 0)
                        {
                            return (int)(num + (uint)BitOperations.TrailingZeroCount(num3));
                        }
                        num += (nuint)Vector128<byte>.Count;
                    }
                    num2 = GetByteVector256SpanLength(num, length);
                    if (num2 > num)
                    {
                        Vector256<byte> left2 = Vector256.Create(value);
                        do
                        {
                            Vector256<byte> right2 = LoadVector256(ref searchSpace, num);
                            int num4 = Avx2.MoveMask(Avx2.CompareEqual(left2, right2));
                            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> left3 = Vector128.Create(value);
                        Vector128<byte> right3 = LoadVector128(ref searchSpace, num);
                        int num5 = Sse2.MoveMask(Sse2.CompareEqual(left3, right3));
                        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> left4 = Vector128.Create(value);
                    for (; num2 > num; num += (nuint)Vector128<byte>.Count)
                    {
                        Vector128<byte> right4 = LoadVector128(ref searchSpace, num);
                        int num6 = Sse2.MoveMask(Sse2.CompareEqual(left4, right4));
                        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> left5 = new Vector<byte>(value);
                    for (; num2 > num; num += (nuint)Vector<byte>.Count)
                    {
                        Vector<byte> vector = Vector.Equals(left5, LoadVector(ref searchSpace, num));
                        if (!Vector<byte>.Zero.Equals(vector))
                        {
                            return (int)num + LocateFirstFoundByte(vector);
                        }
                    }
                    if (num < (uint)length)
                    {
                        num2 = (uint)length - num;
                        continue;
                    }
                }
            }
            return -1;
            IL_0345:
            return (int)(num + 2);
            IL_033f:
            return (int)(num + 1);
            IL_034b:
            return (int)(num + 3);
            IL_033c:
            return (int)num;
        }
        return (int)(num + 7);
    }