Missed optimizations in conditionally selected constants

[uncleasm]

Compared to gcc, clang produces slightly more verbose code for a sequence

int test1(int a) { return a ? -1 : 1; }
        xor     eax, eax
        test    edi, edi
        sete    al
        add     eax, eax
        add     eax, -1
        ret

AFAIK, the optimal sequence is

neg edi
sbb eax, eax
or eax, 1

which could be encoded from

int test0(int a) { return a ? -1 : 0; }
        neg     edi
        sbb     eax, eax
        ret

int test1b(int a) { return test0(a) | 1; }

As a side note, gcc can produce the expected output from test1b but not from test1.

[RKSimon]

Godbolt: https://godbolt.org/z/hd9W3hWr5

CC @rotateright @LebedevRI

[rotateright]

We have combining/lowering to create the neg+sbb already. It could be enhanced to match a new pattern and tack on the 'or' as the final op.

[rotateright]

This won't do anything for this exact example, but here's a proposal to improve the existing x86 lowering for select via SBB:
https://reviews.llvm.org/D116765

[rotateright]

We should be using the sbb hack on this example and more often in general now. Whether that translates to better real-world performance is an open question though.

There's a false dependency hazard with sbb that might exist on some (intel) uarch, and it might be better to use cmov as seen in the example from #53071.