[ARM] [Clang] Missed optimization for bool return val arithmetic operations

[xieyuanbin1-huawei]

bool xxxx();
int kkk()
{
    return xxxx() + 1;
}

https://godbolt.org/z/YoM1PYE1n

llvm:

kkk:
        push    {r11, lr}
        bl      xxxx
        mov     r1, #1
        cmp     r0, #0
        movwne  r1, #2
        mov     r0, r1
        pop     {r11, pc}

gcc:

kkk:
        push    {r4, lr}
        bl      xxxx
        add     r0, r0, #1
        pop     {r4, pc}

According to ARM's ABI (I'm not sure if there is documentation to support this, but both GCC and LLVM compilers behave this way), in the aforementioned use case, the return value of the bool type is stored in the r0 register, and the value of r0 is 0 (false) or 1 (true). This can be observed from the following use case: https://godbolt.org/z/Wj1Goq1Y4

However, the LLVM compiler seems to have missed some optimizations when performing arithmetic operations on return values.
No similar issues have been identified on other architectures at this time.

[hstk30-hw]

In InstCombinePass, we generate select instruction, but in ARM, the condition selection instruction is inefficient.
https://godbolt.org/z/3399ezanf

[dtcxzyw]

https://godbolt.org/z/15Y77f47M Looks like this pattern has been reverted by other backends.
https://github.com/llvm/llvm-project/blob/a9c8e94b43e2c1777247e3b99769b948b1a38c66/llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp#L12117-L12158
Can we also set convertSelectOfConstantsToMath = true for ARM and AArch64 targets?

[hstk30-hw]

CC @davemgreen

[llvmbot]

@llvm/issue-subscribers-backend-arm

Author: None (xieyuanbin1-huawei)

```c bool xxxx(); int kkk() { return xxxx() + 1; } ``` https://godbolt.org/z/YoM1PYE1n

llvm:

kkk:
        push    {r11, lr}
        bl      xxxx
        mov     r1, #<!-- -->1
        cmp     r0, #<!-- -->0
        movwne  r1, #<!-- -->2
        mov     r0, r1
        pop     {r11, pc}

gcc:

kkk:
        push    {r4, lr}
        bl      xxxx
        add     r0, r0, #<!-- -->1
        pop     {r4, pc}

According to ARM's ABI (I'm not sure if there is documentation to support this, but both GCC and LLVM compilers behave this way), in the aforementioned use case, the return value of the bool type is stored in the r0 register, and the value of r0 is 0 (false) or 1 (true). This can be observed from the following use case: https://godbolt.org/z/Wj1Goq1Y4

However, the LLVM compiler seems to have missed some optimizations when performing arithmetic operations on return values.
No similar issues have been identified on other architectures at this time.

[davemgreen]

convertSelectOfConstantsToMath will help in some cases, hurt in others, get stuck in a loop for some. There are parts of it that would be beneficial, we might need to pick the parts that are.