Poor code quality for Interlocked.{Compare}Exchange(nint)

[alexrp]

C#:

using System;
using System.Runtime.CompilerServices;
using System.Threading;

static class Program
{
    [MethodImpl(MethodImplOptions.AggressiveInlining |
                MethodImplOptions.AggressiveOptimization)]
    static void PtrAtomic(nint x)
    {
        Interlocked.Exchange(ref x, x);
        Interlocked.CompareExchange(ref x, x, x);
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining |
                MethodImplOptions.AggressiveOptimization)]
    static void IntAtomic(int x)
    {
        Interlocked.Exchange(ref x, x);
        Interlocked.CompareExchange(ref x, x, x);
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining |
                MethodImplOptions.AggressiveOptimization)]
    static void LongAtomic(long x)
    {
        Interlocked.Exchange(ref x, x);
        Interlocked.CompareExchange(ref x, x, x);
    }
}

Result on .NET 5 (x64):

Program.PtrAtomic(IntPtr)
    L0000: sub rsp, 0x28
    L0004: mov [rsp+0x30], rcx
    L0009: lea rcx, [rsp+0x30]
    L000e: mov rdx, [rsp+0x30]
    L0013: call 0x00007ff973089af0
    L0018: lea rcx, [rsp+0x30]
    L001d: mov rdx, [rsp+0x30]
    L0022: mov r8, [rsp+0x30]
    L0027: call 0x00007ff9730920f0
    L002c: nop
    L002d: add rsp, 0x28
    L0031: ret

Program.IntAtomic(Int32)
    L0000: mov [rsp+8], ecx
    L0004: lea rax, [rsp+8]
    L0009: mov edx, [rsp+8]
    L000d: xchg [rax], edx
    L000f: lea rdx, [rsp+8]
    L0014: mov ecx, [rsp+8]
    L0018: mov eax, [rsp+8]
    L001c: lock cmpxchg [rdx], ecx
    L0020: ret

Program.LongAtomic(Int64)
    L0000: mov [rsp+8], rcx
    L0005: lea rax, [rsp+8]
    L000a: mov rdx, [rsp+8]
    L000f: xchg [rax], rdx
    L0012: lea rdx, [rsp+8]
    L0017: mov rcx, [rsp+8]
    L001c: mov rax, [rsp+8]
    L0021: lock cmpxchg [rdx], rcx
    L0026: ret

I would expect the JIT to expand the nint methods to the exact same code as either the int or long methods.

[EgorBo]

The easiest fix is probably to just expand it: EgorBo@34fdd14

Or we can convert Interlocked intrinsics to the new-style NamedIntrinsics and handle it there.

[jkotas]

The easiest fix is probably to just expand it: EgorBo/runtime-1@34fdd14

I have left a few comments on the commit.

convert Interlocked intrinsics to the new-style NamedIntrinsics and handle it there.

That would be nice too. But the easiest fix above is still useful to reduce number of FCalls.