JIT: missing opportunities in constant folding around bitwise ops

[EgorBo]

int Test(int x, int y) => (x | 5) | (y | 3); // E.g. Enums

Current asm:

; Method Program:Test(int,int):int:this (FullOpts)
       or       edx, 5
       mov      eax, edx
       or       eax, r8d
       or       eax, 3
       ret      
; Total bytes of code: 12

Expected asm:

       mov      eax, edx
       or       eax, r8d
       or       eax, 7
       ret      
; Total bytes of code: 9

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

Issue Details

---

int Test(int x, int y) => (x | 5) | (y | 3); // E.g. Enums

Current asm:

; Method Program:Test(int,int):int:this (FullOpts)
       or       edx, 5
       mov      eax, edx
       or       eax, r8d
       or       eax, 3
       ret      
; Total bytes of code: 12

Expected asm:

       mov      eax, edx
       or       eax, r8d
       or       eax, 7
       ret      
; Total bytes of code: 9

Author:	EgorBo
Assignees:	-
Labels:	area-CodeGen-coreclr, untriaged
Milestone:	-

[AndyAyersMS]

@EgorBo was this just something you noticed?

#99136 shows no diffs, I am trying to figure out if these are just rare, or that PR is not catching some known cases.

[tannergooding]

We tend to manually optimize a lot of the patterns in the libraries code and the tests tend to be simple enough that we don't end up with patterns like this.

So I think there's likely a broad range of "simple" optimizations like this where we'll get next to zero diffs ourselves, but where they may have broader impact to more general .NET code. I expect it still won't be massive number, just wanting to ensure we account for the fact that our own code not having hits isn't necessarily representative of how impactful a change might be.