JIT Optimization: Merge multiple inc into one add

[deeprobin]

https://sharplab.io/#v2:EYLgxg9gTgpgtADwGwBYA0AXEBLANgHwAEAmARgFgAoQgZgAIS6BhOgbyrs4fuwDsM6AQQAUfAQEMAlGw5c54gNQKA3LLmdFKtesIB2OuNWU5AX23badMXQBCo/gentj6jXQUBeOsSOvOeg18uM0oTIA

The codegen of B is better (less cpu cycles).

    public int A(int a) {
        a++; // inc edx
        a++; // inc edx
        return a;
    }
    
    public int B(int a) {
        a += 2; // add edx, 2
        return a;
    }

Expected result

- inc edx
- inc edx
+ add edx, 2
  mov eax, edx
  ret

[ghost]

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

Issue Details

---

https://sharplab.io/#v2:EYLgxg9gTgpgtADwGwBYA0AXEBLANgHwAEAmARgFgAoQgZgAIS6BhOgbyrs4fuwDsM6AQQAUfAQEMAlGw5c54gNQKA3LLmdFKtesIB2OuNWU5AX23badMXQBCo/gentj6jXQUBeOsSOvOeg18uM0oTIA

The codegen of B is better (less cpu cycles).

    public int A(int a) {
        a++; // inc edx
        a++; // inc edx
        return a;
    }
    
    public int B(int a) {
        a += 2; // add edx, 2
        return a;
    }

Expected result

- inc edx
- inc edx
+ add edx, 2
  mov eax, edx
  ret

<table>
  <tr>
    <th align="left">Author:</th>
    <td>deeprobin</td>
  </tr>
  <tr>
    <th align="left">Assignees:</th>
    <td>-</td>
  </tr>
  <tr>
    <th align="left">Labels:</th>
    <td>

`area-CodeGen-coreclr`, `untriaged`

</td>
  </tr>
  <tr>
    <th align="left">Milestone:</th>
    <td>-</td>
  </tr>
</table>
</details>

[danmoseley]

This does not seem to be what C++ compilers do: https://godbolt.org/z/r1f7Pxdfa
Curious to know why.

[omariom]

@danmoseley
With optimization flags https://godbolt.org/z/MPcor1xEP

[danmoseley]

@omariom thanks, I thought that was default.

[deeprobin]

Same for dec

https://sharplab.io/#v2:EYLgxg9gTgpgtADwGwBYA0AXEBDAzgWwB8ABAJgEYBYAKGIGYACMhgYQYG8aHunGBLAHYYGAQQAUg4dgCUHLjwXY4cANzyF3JavUbiAdgbY11BQF8dO+g0kMAQhKGHZnExs0M4AXgaljb7vqGfjzm1KZAA==

Expected result

- dec edx
- dec edx
+ add edx, 0xfffffffe
  mov eax, edx
  ret

And inc+dec elimination would be nice

https://sharplab.io/#v2:EYLgxg9gTgpgtADwGwBYA0AXEBDAzgWwB8ABAJgEYBYAKGIGYACMhgYQYG8aHunGBLAHYYGAQQAUg4dgCUHLjwXYA1EoDc8hd2xw466pp7K1GzcQDsDbHoUBfEyfoNJDAEIShl2Z30HLK677mlgHcdtQ2QA=

Expected result

- inc edx
- dec edx
  inc edx
  mov eax, edx
  ret

[dubiousconst282]

IMO this should be generalized to all operators.

Interestingly, copying to temporary variables will result in optimal code, so maybe this is related to SSA/constant propagation:

public int M(int x) {
    x *= 7;
    x *= 7;
    return x;
}
public int M2(int x) {
    int t1 = x * 7;
    int t2 = t1 * 7;
    return t2;
}

C.M(Int32)
    L0000: imul edx, 7
    L0003: imul edx, 7
    L0006: mov eax, edx
    L0008: ret

C.M2(Int32)
    L0000: imul eax, edx, 0x31
    L0003: ret

Sharplab

[JulieLeeMSFT]

cc @dotnet/jit-contrib

[AndyAyersMS]

Note forward sub (#63720) does not handle cases where a local has multiple definitions and uses, even if each definition has just one use. It might not be too hard to extend it to cover these cases.

Eg if we run it again once SSA is built and track the number of uses of each SSA def.