[JIT] Naiive implementation of Span Reverse should produce optimal codegen

[ahsonkhan]

From dotnet/corefx#26381 (comment):

Here is the naiive implementation which uses a single temporary local for swapping elements. This produces sub-optimal disassembly since it contains an unnecessary mov/lea in the loop body.:

public static void Reverse<T>(this Span<T> span)
{
    ref T p = ref MemoryMarshal.GetReference(span);
    int i = 0;
    int j = span.Length - 1;
    while (i < j)
    {
        T temp = Unsafe.Add(ref p, i);
        Unsafe.Add(ref p, i) = Unsafe.Add(ref p, j);
        Unsafe.Add(ref p, j) = temp;
        i++;
        j--;
    }
}

The following implementation results in better disassembly, but we shouldn't expect users to write code in this way without the unnecessary mov/lea instructions within the loop body:

public static unsafe void Reverse<T>(Span<T> span)
{
    if (span.Length > 1)
    {
        ref T p = ref MemoryMarshal.GetReference(span);
        IntPtr i = IntPtr.Zero;
        IntPtr j = (IntPtr)span.Length - 1;

        do
        {
            var temp1 = Unsafe.Add(ref p, i);
            var temp2 = Unsafe.Add(ref p, j);
            Unsafe.Add(ref p, i) = temp2;
            Unsafe.Add(ref p, j) = temp1;

            i += 1;
            j -= 1;
        } while (i.ToPointer() < j.ToPointer());
    }
}

cc @jkotas, @AndyAyersMS, @GrabYourPitchforks

category:cq
theme:basic-cq
skill-level:intermediate
cost:medium