JIT: Suboptimal inlined unsafe method

[JeremyKuhne]

From discussion here:

dotnet/corefxlab#2595 (review)

        public unsafe bool TryGetValue<T>(out T value) where T : unmanaged
        {
            value = default;
            bool success = false;

            if((typeof(T) == typeof(bool) && Type == VariantType.Boolean)
                // ... elided for brevity
                || (typeof(T) == typeof(uint) && Type == VariantType.UInt32)
                || (typeof(T) == typeof(ulong) && Type == VariantType.UInt64))
            {
                fixed (void* u = &_union)
                {
                    value = *(T*)u;
                }

                // value = CastTo<T>();
                success = true;
            }

            return success;
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        private unsafe T CastTo<T>() where T : unmanaged
        {
            fixed (void* u = &_union)
            {
                return *(T*)u;
            }
        }

This generates the following:

00007ffa`ae692da0 System.Variant.TryGetValue[[System.Int32, System.Private.CoreLib]](Int32 ByRef)
00007ffa`ae692da7 33c0            xor     eax,eax
00007ffa`ae692da9 8902            mov     dword ptr [rdx],eax
00007ffa`ae692dab 83790807        cmp     dword ptr [rcx+8],7
00007ffa`ae692daf 751d            jne     00007ffa`ae692dce
00007ffa`ae692db1 3909            cmp     dword ptr [rcx],ecx
00007ffa`ae692db3 4883c110        add     rcx,10h
00007ffa`ae692db7 48890c24        mov     qword ptr [rsp],rcx
00007ffa`ae692dbb 488b0424        mov     rax,qword ptr [rsp]
00007ffa`ae692dbf 8b00            mov     eax,dword ptr [rax]
00007ffa`ae692dc1 8902            mov     dword ptr [rdx],eax
00007ffa`ae692dc3 33c0            xor     eax,eax
00007ffa`ae692dc5 48890424        mov     qword ptr [rsp],rax
00007ffa`ae692dc9 b801000000      mov     eax,1
00007ffa`ae692dce 4883c408        add     rsp,8

If including the same fixed block through the inlined helper we end up with less optimal generated assembly:

00007ffa`ae673370 System.Variant.TryGetValue[[System.Int32, System.Private.CoreLib]](Int32 ByRef)
00007ffa`ae673377 33c0            xor     eax,eax
00007ffa`ae673379 8902            mov     dword ptr [rdx],eax
00007ffa`ae67337b 83790807        cmp     dword ptr [rcx+8],7
00007ffa`ae67337f 7523            jne     00007ffa`ae6733a4
00007ffa`ae673381 33c0            xor     eax,eax
00007ffa`ae673383 48890424        mov     qword ptr [rsp],rax
00007ffa`ae673387 3909            cmp     dword ptr [rcx],ecx
00007ffa`ae673389 4883c110        add     rcx,10h
00007ffa`ae67338d 48890c24        mov     qword ptr [rsp],rcx
00007ffa`ae673391 488b0424        mov     rax,qword ptr [rsp]
00007ffa`ae673395 8b00            mov     eax,dword ptr [rax]
00007ffa`ae673397 33c9            xor     ecx,ecx
00007ffa`ae673399 48890c24        mov     qword ptr [rsp],rcx
00007ffa`ae67339d 8902            mov     dword ptr [rdx],eax
00007ffa`ae67339f b801000000      mov     eax,1
00007ffa`ae6733a4 4883c408        add     rsp,8

category:cq
theme:inlining
skill-level:expert
cost:medium

[AndyAyersMS]

Note

AI-assisted (Copilot CLI).

Verified resolved on current main. The 2018 codegen gap between calling fixed directly vs. through an [AggressiveInlining] helper is gone — both patterns now emit equivalent code.

Linux x64 codegen on current main (crossgen2 --targetos=linux --targetarch=x64)

TryGetValueDirect (48 B) — fixed directly in the method:

push rax
xor  eax, eax
mov  qword ptr [rsp], rax       ; init pin slot
xor  eax, eax
mov  dword ptr [rsi], eax       ; value = 0
cmp  dword ptr [rdi+0x08], 2    ; Type == I32 ?
je   IG05
xor  eax, eax
add  rsp, 8
ret
IG05:
mov  bword ptr [rsp], rdi       ; pin
mov  eax, dword ptr [rdi]       ; load int
mov  dword ptr [rsi], eax       ; write to out
xor  eax, eax
mov  bword ptr [rsp], rax       ; clear pin
mov  eax, 1
add  rsp, 8
ret

TryGetValueViaHelper (48 B) — fixed inside an [AggressiveInlining] helper:

push rax
xor  eax, eax
mov  qword ptr [rsp], rax       ; init pin slot
xor  eax, eax
mov  dword ptr [rsi], eax       ; value = 0
cmp  dword ptr [rdi+0x08], 2
je   IG05
xor  eax, eax
add  rsp, 8
ret
IG05:
mov  bword ptr [rsp], rdi       ; pin
mov  eax, dword ptr [rdi]       ; load int
xor  rcx, rcx
mov  bword ptr [rsp], rcx       ; clear pin
mov  dword ptr [rsi], eax       ; write to out
mov  eax, 1
add  rsp, 8
ret

Both are 48 bytes / 14 instructions. The only differences are (a) the order of "clear pin slot" vs "write to out" in the success path and (b) xor rcx, rcx vs reusing eax for the zero constant — neither affects perf. The redundant pin-slot zero-init and extra spill/reload the 2018 report showed are gone.

Same equivalence on arm64 (both methods emit 68 B with structurally identical code).

Suggest

Closing as resolved.

[AndyAyersMS]

Closing as resolved per analysis above.