◆ IndexOf() [3/4]

static unsafe int System.SpanHelpers.IndexOf	(	ref char	searchSpace,
		char	value,
		int	length )
inlinestatic
Definition at line 1760 of file SpanHelpers.cs.
    {
        nint num = 0;
        nint num2 = length;
        if (((int)Unsafe.AsPointer(ref searchSpace) & 1) == 0)
        {
            if (Sse2.IsSupported || AdvSimd.Arm64.IsSupported)
            {
                if (length >= Vector128<ushort>.Count * 2)
                {
                    num2 = UnalignedCountVector128(ref searchSpace);
                }
            }
            else if (Vector.IsHardwareAccelerated && length >= Vector<ushort>.Count * 2)
            {
                num2 = UnalignedCountVector(ref searchSpace);
            }
        }
        while (true)
        {
            if (num2 >= 4)
            {
                ref char reference = ref Unsafe.Add(ref searchSpace, num);
                if (value == reference)
                {
                    break;
                }
                if (value != Unsafe.Add(ref reference, 1))
                {
                    if (value != Unsafe.Add(ref reference, 2))
                    {
                        if (value != Unsafe.Add(ref reference, 3))
                        {
                            num += 4;
                            num2 -= 4;
                            continue;
                        }
                        return (int)(num + 3);
                    }
                    return (int)(num + 2);
                }
                return (int)(num + 1);
            }
            while (num2 > 0)
            {
                if (value == Unsafe.Add(ref searchSpace, num))
                {
                    goto end_IL_0090;
                }
                num++;
                num2--;
            }
            if (Avx2.IsSupported)
            {
                if (num < length)
                {
                    if (((nuint)Unsafe.AsPointer(ref Unsafe.Add(ref searchSpace, num)) & (nuint)(Vector256<byte>.Count - 1)) != 0)
                    {
                        Vector128<ushort> left = Vector128.Create(value);
                        Vector128<ushort> right = LoadVector128(ref searchSpace, num);
                        int num3 = Sse2.MoveMask(Sse2.CompareEqual(left, right).AsByte());
                        if (num3 != 0)
                        {
                            return (int)(num + (uint)BitOperations.TrailingZeroCount(num3) / 2u);
                        }
                        num += Vector128<ushort>.Count;
                    }
                    num2 = GetCharVector256SpanLength(num, length);
                    if (num2 > 0)
                    {
                        Vector256<ushort> left2 = Vector256.Create(value);
                        do
                        {
                            Vector256<ushort> right2 = LoadVector256(ref searchSpace, num);
                            int num4 = Avx2.MoveMask(Avx2.CompareEqual(left2, right2).AsByte());
                            if (num4 == 0)
                            {
                                num += Vector256<ushort>.Count;
                                num2 -= Vector256<ushort>.Count;
                                continue;
                            }
                            return (int)(num + (uint)BitOperations.TrailingZeroCount(num4) / 2u);
                        }
                        while (num2 > 0);
                    }
                    num2 = GetCharVector128SpanLength(num, length);
                    if (num2 > 0)
                    {
                        Vector128<ushort> left3 = Vector128.Create(value);
                        Vector128<ushort> right3 = LoadVector128(ref searchSpace, num);
                        int num5 = Sse2.MoveMask(Sse2.CompareEqual(left3, right3).AsByte());
                        if (num5 != 0)
                        {
                            return (int)(num + (uint)BitOperations.TrailingZeroCount(num5) / 2u);
                        }
                        num += Vector128<ushort>.Count;
                    }
                    if (num < length)
                    {
                        num2 = length - num;
                        continue;
                    }
                }
            }
            else if (Sse2.IsSupported)
            {
                if (num < length)
                {
                    num2 = GetCharVector128SpanLength(num, length);
                    if (num2 > 0)
                    {
                        Vector128<ushort> left4 = Vector128.Create(value);
                        do
                        {
                            Vector128<ushort> right4 = LoadVector128(ref searchSpace, num);
                            int num6 = Sse2.MoveMask(Sse2.CompareEqual(left4, right4).AsByte());
                            if (num6 == 0)
                            {
                                num += Vector128<ushort>.Count;
                                num2 -= Vector128<ushort>.Count;
                                continue;
                            }
                            return (int)(num + (uint)BitOperations.TrailingZeroCount(num6) / 2u);
                        }
                        while (num2 > 0);
                    }
                    if (num < length)
                    {
                        num2 = length - num;
                        continue;
                    }
                }
            }
            else
            {
                if (AdvSimd.Arm64.IsSupported)
                {
                }
                if (Vector.IsHardwareAccelerated && num < length)
                {
                    num2 = GetCharVectorSpanLength(num, length);
                    if (num2 > 0)
                    {
                        Vector<ushort> left5 = new Vector<ushort>(value);
                        do
                        {
                            Vector<ushort> vector = Vector.Equals(left5, LoadVector(ref searchSpace, num));
                            if (Vector<ushort>.Zero.Equals(vector))
                            {
                                num += Vector<ushort>.Count;
                                num2 -= Vector<ushort>.Count;
                                continue;
                            }
                            return (int)(num + LocateFirstFoundChar(vector));
                        }
                        while (num2 > 0);
                    }
                    if (num < length)
                    {
                        num2 = length - num;
                        continue;
                    }
                }
            }
            return -1;
            continue;
            end_IL_0090:
            break;
        }
        return (int)num;
    }