dotnet/runtime

JIT: Simplify arithmetic operations on memory, as is already done for register

Open

#125300 opened on Mar 8, 2026

View on GitHub
 (1 comment) (0 reactions) (0 assignees)C# (17,886 stars) (5,445 forks)batch import
area-CodeGen-coreclrhelp wantedoptimization

Description

I expected the reg and mem variant to have same codegen, https://godbolt.org/z/MGzTd3s3c JitOptRepeat seems to help a little for SubMem only.

static int AddReg(int mem)
{
    int a = mem;
    int b = mem;
    int c = mem;
    int r = a + b + c;
    return r;
}

static int AddMem(ref int mem)
{
    int a = mem;
    int b = mem;
    int c = mem;
    int r = a + b + c;
    return r;
}

static int SubReg(int mem)
{
    int a = mem;
    int b = mem;
    int c = mem;
    int r = a - b - c;
    return r;
}

static int SubMem(ref int mem)
{
    int a = mem;
    int b = mem;
    int c = mem;
    int r = a - b - c;
    return r;
}

Program:AddReg(int):int (FullOpts):
       lea      eax, [rdi+2*rdi]
       ret      

Program:AddMem(byref):int (FullOpts):
       mov      eax, dword ptr [rdi]
       lea      ecx, [rax+rax]
       add      eax, ecx
       ret      

Program:SubReg(int):int (FullOpts):
       xor      eax, eax
       sub      eax, edi
       ret      

Program:SubMem(byref):int (FullOpts):
       mov      eax, dword ptr [rdi]
       mov      ecx, eax
       sub      ecx, eax
       sub      ecx, eax
       mov      eax, ecx
       ret

Contributor guide

Tech stack
csharpcpp
Domain
backendperformance
Issue type
performance
DifficultyEstimated implementation difficulty for a new contributor, from 1 for very small changes to 5 for expert-level work.
4
Estimated timeA rough time range for an experienced contributor to investigate, implement, test, and prepare a pull request.
3-5 days
Activity statusHow available the issue appears right now: fresh, active, stale, blocked, or waiting on maintainer input.
fresh
ClarityHow clearly the issue explains the expected change, acceptance criteria, and next step.
clear
Prerequisites
C#JIT compiler conceptsx86 assemblydotnet/runtime build system
Newbie friendlinessA 1-100 score estimating how approachable this issue is for first-time contributors.
20
Research direction
Investigate the JIT code generation for arithmetic operations on memory vs register, focusing on AddMem and SubMem. Look at the JIT optimization passes and how register variants are simplified. The issue suggests JitOptRepeat may help for SubMem. Consider the compiler's ability to fold memory loads and arithmetic, and identify the missing optimization in the memory case.