JIT generates better code when expression is stored in variable

[oleg-st]

Description

Code:

using System.Runtime.CompilerServices;
using System.Numerics;

public unsafe class C {
    
    public unsafe struct BIT_DStream_t
    {
        public nuint bitContainer;
        public uint bitsConsumed;
        public sbyte* ptr;
        public sbyte* start;
        public sbyte* limitPtr;
    }
    
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    private static nuint BIT_initDStream1(ref BIT_DStream_t bitD, void* srcBuffer, nuint srcSize)
    {
        byte lastByte = ((byte*)srcBuffer)[srcSize - 1];
        bitD.bitsConsumed = lastByte != 0 ? 8 - (uint)BitOperations.Log2(lastByte) : 0;
        
        return 0;
    }
    
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    private static nuint BIT_initDStream2(ref BIT_DStream_t bitD, void* srcBuffer, nuint srcSize)
    {
        byte lastByte = ((byte*)srcBuffer)[srcSize - 1];
        // difference here
        var v = lastByte != 0 ? 8 - (uint)BitOperations.Log2(lastByte) : 0;
        bitD.bitsConsumed = v;
        
        return 0;
    }
    
    private static nuint M1(byte *ip, byte *iend) {
        BIT_DStream_t seqState_DStream = new ();
        BIT_initDStream1(ref seqState_DStream, ip, (nuint)(iend - ip));
        return seqState_DStream.bitContainer;
    }
    
    private static nuint M2(byte *ip, byte *iend) {
        BIT_DStream_t seqState_DStream = new ();
        BIT_initDStream2(ref seqState_DStream, ip, (nuint)(iend - ip));
        return seqState_DStream.bitContainer;
    }
}

M1:

    L0000: sub rsp, 0x28
    L0004: vxorps xmm4, xmm4, xmm4
    L0008: vmovdqa [rsp], xmm4
    L000d: vmovdqa [rsp+0x10], xmm4
    L0013: xor eax, eax
    L0015: mov [rsp+0x20], rax
    L001a: sub rdx, rcx
    L001d: movzx eax, byte ptr [rdx+rcx-1]
    L0022: lea rcx, [rsp]
    L0026: test eax, eax
    L0028: jne short L002e
    L002a: xor edx, edx
    L002c: jmp short L003f
    L002e: or eax, 1
    L0031: xor edx, edx
    L0033: lzcnt edx, eax
    L0037: xor edx, 0x1f
    L003a: neg edx
    L003c: add edx, 8
    L003f: mov [rcx+8], edx
    L0042: mov rax, [rsp]
    L0046: add rsp, 0x28
    L004a: ret

M2:

    L0000: sub rdx, rcx
    L0003: movsx rax, byte ptr [rdx+rcx-1]
    L0009: xor eax, eax
    L000b: ret

SharpLab

Configuration

.NET 8.0.204

[dotnet-policy-service]

Tagging subscribers to this area: @JulieLeeMSFT, @jakobbotsch
See info in area-owners.md if you want to be subscribed.

[EgorBo]

Sounds like #87072 cc @jakobbotsch @dotnet/jit-contrib

[jakobbotsch]

Yeah looks like it. The good news is that it is in my plans for .NET 9 to fix this.

BTW, also looks like we are missing a simple transform in morph for the M2 case:

fgMorphTree BB01, STMT00004 (after)
               [000026] DA-XG+-----                         ▌  STORE_LCL_VAR int    V05 tmp2         
               [000025] ---XG+-----                         └──▌  IND       ubyte 
               [000024] -----+-----                            └──▌  ADD       long  
               [000023] -----+-----                               ├──▌  ADD       long  
               [000004] -----+-----                               │  ├──▌  LCL_VAR   long   V00 arg0         
               [000007] -----+-----                               │  └──▌  SUB       long  
               [000005] -----+-----                               │     ├──▌  LCL_VAR   long   V01 arg1          (last use)
               [000006] -----+-----                               │     └──▌  LCL_VAR   long   V00 arg0         
               [000022] -----+-----                               └──▌  CNS_INT   long   -1

(x + (y - x)) => y