JIT: Transform arithmetic using distributive property by BoyBaykiller · Pull Request #126852 · dotnet/runtime

BoyBaykiller · 2026-04-13T21:58:43Z

Generalization of #126070
Progress towards #93954

Basically we weren't doing any simplification based on distributive property before. So transforming
((A op1 B) op2 (A op1 C)) => (A op1 (B op2 C)). And this adds some basic support. Examples:

int MulDistedOverAdd(int A, int B, int C)
{
    return (A * B) + (A * C);
}

;; ------ BASE
G_M000_IG02:
       mov      eax, edx
       imul     eax, r8d
       imul     r9d, edx
       add      eax, r9d

;; ------ DIFF
G_M48043_IG02:  ;; offset=0x0000
       lea      eax, [r8+r9]
       imul     eax, edx

bool AfterOptimizeBools(int A, int B)
{
    return (A & 4) != 0 || (A & 8) != 0;
}

;; ------ BASE
       mov      eax, edx
       and      eax, 4
       and      edx, 8
       or       eax, edx
       setne    al
       movzx    rax, al

;; ------ DIFF
G_M55610_IG02:
       test     dl, 12
       setne    al
       movzx    rax, al

We still need something that changes order to enable this opt. So (A | B) | C becoming A | (B | C) in this case:

uint Reassociate(uint foo, uint flags)
{
    return (foo | (flags & 256)) | (flags & 512);
}

Or here, the C * A need to be reversed.

int Reassociate(int A, int B, int C)
{
    return (A * B) + (C * A);
}

dotnet-policy-service · 2026-04-13T21:59:55Z

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

rhuijben · 2026-04-14T06:03:46Z

+        return tree;
+    }
+
+    if (((tree->gtFlags & GTF_PERSISTENT_SIDE_EFFECTS) != 0) || ((tree->gtFlags & GTF_ORDER_SIDEEFF) != 0))


This could use the same optimization you are trying to apply😅... Probably handled by c++ though, so this is purely documentation ;-)

Lol. A new level of self documenting code. I didn't even notice that, I copied this check from elsewhere. I guess this just goes to show how useful the optimization is. Unfortunately even with this PR it's still not handled : (

Update: This now gets handled by calling this opt again after the "optimizeBools" phase where it simplifies e.g
(A & 4) != 0 || (A & 8) != 0 into ((A & 4) | (A & 8)) != 0.

BoyBaykiller · 2026-04-15T00:55:10Z

@EgorBo PTAL. Diffs are rather small, but nonetheless I believe it's a step in the right direction. I've written down some future work (which all improve diffs). I think the most interesting case for real-world code is arround bitwise ops.
Also should this go into post-order or pre-order morphing?

BoyBaykiller · 2026-04-15T03:24:52Z

Calling fgMorphBlockStmt after optimizeBools fixes point 2 in my list and produces much better diffs old new

BoyBaykiller · 2026-04-15T03:42:13Z

Regarding point 1. The issue is that this runs first:

runtime/src/coreclr/jit/morph.cpp

Lines 10665 to 10690 in e0fb1f9

    
           else if (mulShiftOpt && (lowestBit > 1) && jitIsScaleIndexMul(lowestBit)) 
        
           { 
        
               int     shift  = genLog2(lowestBit); 
        
               ssize_t factor = abs_mult >> shift; 
        
               if (factor == 3 || factor == 5 || factor == 9) 
        
               { 
        
                   // if negative negate (min-int does not need negation) 
        
                   if (mult < 0 && mult != SSIZE_T_MIN) 
        
                   { 
        
                       op1        = gtNewOperNode(GT_NEG, genActualType(op1), op1); 
        
                       mul->gtOp1 = op1; 
        
                       fgMorphTreeDone(op1); 
        
                   } 
        
                   // change the multiplication into a smaller multiplication (by 3, 5 or 9) and a shift 
        
                   GenTree* const factorNode = gtNewIconNodeWithVN(this, factor, mul->TypeGet()); 
        
                   factorNode->SetMorphed(this); 
        
                   op1        = gtNewOperNode(GT_MUL, mul->TypeGet(), op1, factorNode); 
        
                   mul->gtOp1 = op1; 
        
                   fgMorphTreeDone(op1); 
        
                   op2->AsIntConCommon()->SetIconValue(shift); 
        
                   changeToShift = true; 
        
               } 
        
           }

Perhaps this should be moved to Lower. LLVM also does it in "X86 DAG->DAG Instruction Selection" and not "InstCombine" https://godbolt.org/z/jsPea1PhP

EgorBo · 2026-04-27T13:55:57Z

+
+    auto isLeftDistributive = [](genTreeOps op1, genTreeOps op2) {
+        // op1 is left distributive over op2 iff:
+        // "A op1 (B op2 C)" <==> "(A op1 B) op2 (A op1 C)"


We already do something similar for GT_ADD somewhere, we should unify it with that

I didn't find what you are refering to here

* add OR and AND are 'distributive' over themselves

…implification like '(A & 4) != 0 || (A & 8) != 0'

…rm-using-distributive-property

BoyBaykiller · 2026-05-24T02:32:30Z

I've limited it to OperIsAnyLocal, as discussed. Ready for an other review.

Basically so we always have 0 at the right-side: 1. '(A & pow2) == pow2' -> '(A & pow2) != 0' 2. '(A & pow2) != pow2' -> '(A & pow2) == 0' Tthis currently helps optimizeBools, but I am also adding this with the future in mind. Here is one example: ```cs static bool Example(int foo) { return ((foo & 4) == 4) || ((foo & 8) == 8); } ``` ```assembly ;; ------ BASE G_M000_IG02: ;; offset=0x0000 test cl, 4 je SHORT G_M000_IG05 G_M000_IG03: ;; offset=0x0005 mov eax, 1 G_M000_IG04: ;; offset=0x000A ret G_M000_IG05: ;; offset=0x000B test cl, 8 setne al movzx rax, al G_M000_IG06: ;; offset=0x0014 ret ;; ------ DIFF G_M33938_IG02: ;; offset=0x0000 mov eax, ecx and eax, 4 and ecx, 8 or eax, ecx setne al movzx rax, al ``` Note: With #126852 this would then get transformed into just `test 12`.

…rm-using-distributive-property

JulieLeeMSFT · 2026-06-29T14:40:35Z

@EgorBo, PTAL.

EgorBo · 2026-06-30T23:51:49Z

@MihuBot -nuget

EgorBo · 2026-07-01T01:30:07Z

MihuBot/runtime-utils#2055 (comment)

MihaZupan · 2026-07-01T21:02:48Z

Just testing error reporting changes

@MihuBot -nuget

MihuBot · 2026-07-01T21:27:06Z

Warning

2 extra test assemblies failed to produce JIT diffs and were excluded from the diff analysis:

MathNet.Numerics.dll (pr)
Pipelines.Sockets.Unofficial.dll (pr)

All failures happened only on the PR branch, which likely indicates a bug introduced by the PR (e.g. a JIT assert or crash while compiling these assemblies).

_{See job details in MihuBot/runtime-utils#2058, triggered by #126852 (comment).}

Basically so we always have 0 at the right-side: 1. '(A & pow2) == pow2' -> '(A & pow2) != 0' 2. '(A & pow2) != pow2' -> '(A & pow2) == 0' Tthis currently helps optimizeBools, but I am also adding this with the future in mind. Here is one example: ```cs static bool Example(int foo) { return ((foo & 4) == 4) || ((foo & 8) == 8); } ``` ```assembly ;; ------ BASE G_M000_IG02: ;; offset=0x0000 test cl, 4 je SHORT G_M000_IG05 G_M000_IG03: ;; offset=0x0005 mov eax, 1 G_M000_IG04: ;; offset=0x000A ret G_M000_IG05: ;; offset=0x000B test cl, 8 setne al movzx rax, al G_M000_IG06: ;; offset=0x0014 ret ;; ------ DIFF G_M33938_IG02: ;; offset=0x0000 mov eax, ecx and eax, 4 and ecx, 8 or eax, ecx setne al movzx rax, al ``` Note: With #126852 this would then get transformed into just `test 12`.

github-actions · 2026-07-19T08:03:05Z

Workflow state for the Holistic Review Orchestrator.

{
  "version": 5,
  "last_dispatched_commit": "ef82e04e0d0ec0a577f66e436b30a9adf3b47b77",
  "last_dispatched_base_ref": "main",
  "last_dispatched_base_sha": "f32edc0223b18865778e8e4d335e31bf9a2933f0",
  "last_reviewed_commit": "ef82e04e0d0ec0a577f66e436b30a9adf3b47b77",
  "last_reviewed_base_ref": "main",
  "last_reviewed_base_sha": "f32edc0223b18865778e8e4d335e31bf9a2933f0",
  "last_recorded_worker_run_id": "29679146097",
  "review_attempt_commit": "",
  "review_attempt_base_ref": "",
  "review_attempt_count": 0,
  "max_review_attempts": 5,
  "review_history_format": "holistic-review-disclosure-v1",
  "review_history": [
    {
      "commit": "ef82e04e0d0ec0a577f66e436b30a9adf3b47b77",
      "review_id": 4730527763
    }
  ]
}

github-actions

Holistic Review

Motivation: Generalizes #126070 and makes progress on #93954 by teaching the JIT to simplify arithmetic via the distributive property, i.e. (A op1 B) op2 (A op1 C) => A op1 (B op2 C). This reduces instruction count in common patterns (e.g. (A*B)+(A*C) folding to A*(B+C), and bit-test patterns after optOptimizeBools), which is a worthwhile codegen improvement.

Approach: Adds gtFoldDistributiveArithmetic invoked from gtFoldExprBinary for GT_AND/GT_OR/GT_XOR/GT_ADD/GT_SUB trees. It uses an isLeftDistributive table (AND/OR/MUL over their duals) and, when both operands share the same outer op and their left children are matching locals, rebuilds the tree with the common factor extracted. It also re-runs gtFoldExpr on the newly-combined boolean fold result in optOptimizeBoolsUpdateTrees, and tidies an unrelated cmp->gtOp2 -> cmp->gtGetOp2() reference in morph.cpp.

Summary: The transform is conceptually sound for wrapping (unchecked) integer arithmetic, and the guarding on optimization level, overflow of the outer node, side effects, and integral type is a reasonable start. However there is one correctness concern worth resolving before merge: the overflow check only examines the outer tree, not the inner operands. For checked(A*B) + checked(A*C) the inner GT_MUL nodes carry GTF_OVERFLOW, yet the rebuilt A*(B+C) uses a plain unchecked GT_MUL, dropping the overflow checks and altering observable behavior (a missing OverflowException). See the inline comment on the guard. I'd recommend adding a targeted regression test covering the checked-arithmetic case (and confirming it is rejected) once the guard is tightened. A secondary, non-blocking note: the freshly-created newOp2 node does not get value numbers assigned even though gtFoldExpr may be reached post-VN via optOptimizeBools; only result receives SetVNsFromNode. Verify this is benign in that phase (constants typically fold away, but a non-constant B op C combination would leave an unnumbered node).

Detailed Findings

Checked-arithmetic correctness (see inline comment on gtFoldDistributiveArithmetic): outer-only overflow guard can drop inner checked-multiply/add/sub semantics. Recommend also bailing when the operands being merged have gtOverflowEx()/GTF_EXCEPT set.
VN coverage of newOp2 (non-blocking): SetVNsFromNode(tree) is applied to result only; the intermediate newOp2 = gtFoldExpr(B op C) node has no VN. Since this path is also reachable from optOptimizeBoolsUpdateTrees after value numbering, confirm an unnumbered non-constant intermediate cannot reach a consumer that requires valid VNs.
Scope observation (non-blocking): the transform requires the shared factor to be OperIsAnyLocal. This is a safe, conservative choice (no duplicated side effects / re-evaluation), consistent with the PR description noting reassociation is not yet handled.

Note

This review was generated by this repository's Holistic Review agentic workflow to complement the built-in Copilot review.

Generated by Holistic Review · 115.6 AIC · ⌖ 11 AIC · ⊞ 10K

github-actions · 2026-07-19T09:39:55Z

+{
+    assert(tree->OperIs(GT_AND, GT_OR, GT_XOR, GT_ADD, GT_SUB));
+
+    if (opts.OptimizationDisabled() || tree->gtOverflowEx() || !varTypeIsIntegralOrI(tree))


The overflow guard only inspects the outer tree, not the inner operands op1/op2. For an inner distributive op that can overflow-throw, this can silently drop checked semantics. Concretely, checked(A * B) + checked(A * C) has an unchecked outer GT_ADD but two inner GT_MUL nodes carrying GTF_OVERFLOW. isLeftDistributive(GT_MUL, GT_ADD) is true, so the transform rebuilds the tree as A * (B + C) via gtNewOperNode(GT_MUL, ...) with no overflow flag, discarding both checked multiplications. That changes observable behavior (a program that should throw OverflowException no longer does). For unchecked/wrapping arithmetic the distribution is correct mod 2^n, but the checked case is not. Consider also rejecting when op1/op2 (or their relevant children) have gtOverflowEx() set, or more conservatively bail when GTF_EXCEPT is present on the operands being merged.

@BoyBaykiller that is a good point, this PR basically breaks this:

static int F(int a, int b, int c) => checked(a * b) + checked(a * c);

With:

a = 2 b = 0x40000000 c = -0x40000000

EgorBo · 2026-07-20T19:12:21Z

+        {
+            GenTree* newOp1 = op1->gtGetOp1();
+            GenTree* newOp2 =
+                gtFoldExpr(gtNewOperNode(tree->OperGet(), tree->TypeGet(), op1->gtGetOp2(), op2->gtGetOp2()));


seems like this gtNewOperNode is not marked as MORPHED

…rm-using-distributive-property

* mark new op2 as fgMorphTreeDone

BoyBaykiller · 2026-07-21T02:12:30Z

Failures fixed?

@MihuBot -nuget

github-actions Bot added the area-CodeGen-coreclr CLR JIT compiler in src/coreclr/src/jit and related components such as SuperPMI label Apr 13, 2026

dotnet-policy-service Bot added the community-contribution Indicates that the PR has been added by a community member label Apr 13, 2026

build-analysis Bot mentioned this pull request Apr 14, 2026

System.Net.NameResolution.Tests DNS failures: Name or service not known #126641

Open

rhuijben reviewed Apr 14, 2026

View reviewed changes

BoyBaykiller marked this pull request as ready for review April 15, 2026 01:07

jakobbotsch reviewed Apr 15, 2026

View reviewed changes

Comment thread src/coreclr/jit/optimizebools.cpp Outdated

BoyBaykiller force-pushed the transform-using-distributive-property branch from e92d4c5 to 8e06971 Compare April 16, 2026 04:25

BoyBaykiller requested a review from EgorBo April 18, 2026 17:58

build-analysis Bot mentioned this pull request Apr 18, 2026

[wasm] WBT SatelliteAssembliesTests.CheckThatSatelliteAssembliesAreNotAOTed failing #90458

Open

BoyBaykiller closed this Apr 18, 2026

BoyBaykiller reopened this Apr 18, 2026

jakobbotsch reviewed Apr 20, 2026

View reviewed changes

Comment thread src/coreclr/jit/morph.cpp Outdated

BoyBaykiller closed this Apr 20, 2026

BoyBaykiller reopened this Apr 20, 2026

EgorBo reviewed Apr 27, 2026

View reviewed changes

Comment thread src/coreclr/jit/optimizebools.cpp Outdated

BoyBaykiller mentioned this pull request Apr 29, 2026

JIT: Refactor morph cmp optimizations #127548

Closed

build-analysis Bot mentioned this pull request Apr 29, 2026

Android arm32 device not found (armeabi-v7a architecture unavailable) #125440

Closed

BoyBaykiller mentioned this pull request Apr 29, 2026

Simplify arithmetic operations on registry and memory #125559

Draft

BoyBaykiller added 4 commits May 10, 2026 17:50

* initial impl

97985db

* call from fgMorphSmpOp

2c5e2eb

* add OR and AND are 'distributive' over themselves

* apply the opt to the code itself

538dd18

* call morph in optimizeBool to catch more cases after control flow s…

5f2952d

…implification like '(A & 4) != 0 || (A & 8) != 0'

* allow for any OperIsAnyLocal()

472e994

am11 reviewed May 10, 2026

View reviewed changes

Comment thread src/coreclr/jit/gentree.cpp Outdated

Merge branch 'main' of https://github.com/dotnet/runtime into transfo…

e06b1cf

…rm-using-distributive-property

BoyBaykiller mentioned this pull request May 24, 2026

Suboptimal codegen for Enum.HasFlag(A) || Enum.HasFlag(B) #93954

Open

* small changes

49d57ed

BoyBaykiller mentioned this pull request May 24, 2026

JIT: Canonicalize '(A & pow2) == pow2' -> '(A & pow2) != 0' #128533

Merged

BoyBaykiller added 2 commits June 4, 2026 18:13

Merge branch 'main' of https://github.com/dotnet/runtime into transfo…

dd17c02

…rm-using-distributive-property

* small changes

6de01c5

This was referenced Jun 5, 2026

slow macOS - "##[error]The job running on agent Azure Pipelines 9 ran longer than the maximum time of 60 minutes." dotnet/dnceng#1883

Open

browser-wasm linux Release LibraryTests queues timing out #117974

Open

BoyBaykiller requested a review from EgorBo June 5, 2026 18:48

JulieLeeMSFT assigned BoyBaykiller Jun 29, 2026

Merge branch 'main' into transform-using-distributive-property

ef82e04

MihuBot mentioned this pull request Jun 30, 2026

[JitDiff X64] [BoyBaykiller] JIT: Transform arithmetic using distributive pr ... MihuBot/runtime-utils#2055

Open

MihuBot mentioned this pull request Jul 1, 2026

[JitDiff X64] [BoyBaykiller] JIT: Transform arithmetic using distributive pr ... MihuBot/runtime-utils#2058

Open

github-actions Bot reviewed Jul 19, 2026

View reviewed changes

EgorBo reviewed Jul 20, 2026

View reviewed changes

BoyBaykiller added 2 commits July 20, 2026 23:42

Merge branch 'main' of https://github.com/dotnet/runtime into transfo…

4a56b46

…rm-using-distributive-property

* bail on GTF_EXCEPT instead of checking gtOverflowEx

d42ba20

* mark new op2 as fgMorphTreeDone

MihuBot mentioned this pull request Jul 21, 2026

[JitDiff X64] [BoyBaykiller] JIT: Transform arithmetic using distributive pr ... MihuBot/runtime-utils#2098

Open

Uh oh!

Conversation

BoyBaykiller commented Apr 13, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

dotnet-policy-service Bot commented Apr 13, 2026

Uh oh!

rhuijben Apr 14, 2026

Choose a reason for hiding this comment

Uh oh!

BoyBaykiller Apr 15, 2026

Choose a reason for hiding this comment

Uh oh!

BoyBaykiller Apr 27, 2026

Choose a reason for hiding this comment

Uh oh!

BoyBaykiller commented Apr 15, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

BoyBaykiller commented Apr 15, 2026

Uh oh!

BoyBaykiller commented Apr 15, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

Uh oh!

Uh oh!

EgorBo Apr 27, 2026

Choose a reason for hiding this comment

Uh oh!

BoyBaykiller Jun 4, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Uh oh!

BoyBaykiller commented May 24, 2026

Uh oh!

JulieLeeMSFT commented Jun 29, 2026

Uh oh!

EgorBo commented Jun 30, 2026

Uh oh!

EgorBo commented Jul 1, 2026

Uh oh!

MihaZupan commented Jul 1, 2026

Uh oh!

MihuBot commented Jul 1, 2026

Uh oh!

github-actions Bot commented Jul 19, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

github-actions Bot left a comment

Choose a reason for hiding this comment

Holistic Review

Detailed Findings

Uh oh!

github-actions Bot Jul 19, 2026

Choose a reason for hiding this comment

Uh oh!

EgorBo Jul 20, 2026

Choose a reason for hiding this comment

Uh oh!

EgorBo Jul 20, 2026

Choose a reason for hiding this comment

Uh oh!

BoyBaykiller commented Jul 21, 2026

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

9 participants

BoyBaykiller commented Apr 13, 2026 •

edited

Loading

BoyBaykiller commented Apr 15, 2026 •

edited

Loading

BoyBaykiller commented Apr 15, 2026 •

edited

Loading

BoyBaykiller Jun 4, 2026 •

edited

Loading

github-actions Bot commented Jul 19, 2026 •

edited

Loading