[X86] Recognize Clang's `<=>` code pattern

[scottmcm]

Today, this code https://cpp.godbolt.org/z/e8q15zzK1

#include <compare>
std::strong_ordering cmp(int a, int b) {
    return a <=> b;
}

gives this select chain

define dso_local i8 @_Z3cmpii(i32 noundef %0, i32 noundef %1) local_unnamed_addr #0 {
  %3 = icmp slt i32 %0, %1
  %4 = select i1 %3, i8 -1, i8 1
  %5 = icmp eq i32 %0, %1
  %6 = select i1 %5, i8 0, i8 %4
  ret i8 %6
}

which compiles to some pretty verbose assembly:

cmp(int, int):                               # @cmp(int, int)
        cmp     edi, esi
        setl    al
        neg     al
        or      al, 1
        xor     ecx, ecx
        cmp     edi, esi
        movzx   eax, al
        cmove   eax, ecx
        ret

There are other ways of doing this that are definitely better for size, and plausibly better for speed too https://graphics.stanford.edu/~seander/bithacks.html#CopyIntegerSign

For example, it could be

cmp(int, int):                               # @cmp(int, int)
        cmp     edi, esi
        setg    al
        setl    cl
        sub     al, cl
        ret

(I've filed this as x86-specific because the selects in LLVM-IR might be better for optimizations to use, as more obvious than the subtraction. The specific pattern that Clang emits for <=> is most important, but it would be nice if it also recognized -- or canonicalized in IR -- the bunch of equivalent select chains.)

[zygoloid]

There are a few other formulations here that don't canonicalize to the same thing; maybe that should be looked at too: https://godbolt.org/z/7fcrczYeo

[dtcxzyw]

@scottmcm Is this issue addressed? llvm.ucmp/scmp support has been landed in LLVM 20.

x86-64 assembly looks good:

cmp(int, int):
        cmp     edi, esi
        setl    cl
        setg    al
        sub     al, cl
        ret

cmp_better(int, int):
        cmp     edi, esi
        setl    cl
        setg    al
        sub     al, cl
        ret

[scottmcm]

Thanks, with LLVM 20 we saw this get picked up and do good things in Rust even before we did anything, and now with rust-lang/rust#133984 rustc itself emits the new intrinsics directly. We're even using it for signum soon.

So that directly fixed this x86 issue, and we've also seen better optimization results around Ord::cmp too 🎉

[scottmcm]

(There are some follow-ups, like #129401 and #130179, but those are separate from this.)