JIT: Transform '(cmp & x) | (cmp & y)' to 'cmp & (x | y)'

[BoyBaykiller]

No description provided.

[dotnet-policy-service]

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

[BoyBaykiller]

I am having a problem identifying certain cases.
Currently I detect such IR:

[000007] -----------                            \--*  OR        int   
[000003] -----------                               +--*  AND       int   
[000001] -----------                               |  +--*  LCL_VAR   int    V02 arg2         
[000002] -----------                               |  \--*  CNS_INT   int    256
[000006] -----------                               \--*  AND       int   
[000004] -----------                                  +--*  LCL_VAR   int    V02 arg2          (last use)
[000005] -----------                                  \--*  CNS_INT   int    512

Which works fine for (flags & 256) | (flags & 512),
but breaks down if I add a operation in front like 1 + (flags & 256) | (flags & 512). Then the IR is:

[000008] -----------                         \--*  OR        int   
[000004] -----------                            +--*  ADD       int   
[000000] -----------                            |  +--*  CNS_INT   int    1
[000003] -----------                            |  \--*  AND       int   
[000001] -----------                            |     +--*  LCL_VAR   int    V01 arg1         
[000002] -----------                            |     \--*  CNS_INT   int    256
[000007] -----------                            \--*  AND       int   
[000005] -----------                               +--*  LCL_VAR   int    V01 arg1         
[000006] -----------                               \--*  CNS_INT   int    512

When adding explicit parentheses like 1 + ((flags & 256) | (flags & 512)) it works again:

[000008] -----------                         \--*  ADD       int   
[000000] -----------                            +--*  CNS_INT   int    1
[000007] -----------                            \--*  OR        int   
[000003] -----------                               +--*  AND       int   
[000001] -----------                               |  +--*  LCL_VAR   int    V01 arg1         
[000002] -----------                               |  \--*  CNS_INT   int    256
[000006] -----------                               \--*  AND       int   
[000004] -----------                                  +--*  LCL_VAR   int    V01 arg1         
[000005] -----------                                  \--*  CNS_INT   int    512

But this shouldn't be needed. It shouldnt get confused by some extra commutative arithmetic like the ADD(1) here. What is the general way to fix this?

[huoyaoyuan]

but breaks down if I add a operation in front like 1 + (flags & 256) | (flags & 512). Then the IR is:

The operator priority of | is lower than +. 1 + (flags & 256) | (flags & 512) means (1 + (flags & 256)) | (flags & 512). Check sharplab.

[EgorBo]

I don't think this is legal - cmp may have side-effect or be a local whose value is changed via x or y