Suboptimal codegen for abs-diff style functions

[Kmeakin]

https://godbolt.org/z/doWPnqfs6

#include <stdint.h>

typedef uint32_t u32;
typedef int32_t i32;

inline u32 umax(u32 x, u32 y) { return x > y ? x : y; }
inline u32 umin(u32 x, u32 y) { return x < y ? x : y; }

inline u32 smax(i32 x, i32 y) { return x > y ? x : y; }
inline u32 smin(i32 x, i32 y) { return x < y ? x : y; }

u32 src1(u32 x, u32 y) { return umax(x, y) - umin(x, y); }
u32 tgt1(u32 x, u32 y) { return x > y ? x - y : y - x; }

u32 src2(u32 x, u32 y) { return umin(x, y) - umax(x, y); }
u32 tgt2(u32 x, u32 y) { return x < y ? x - y : y - x; }

u32 src3(i32 x, i32 y) { return smax(x, y) - smin(x, y); }
u32 tgt3(i32 x, i32 y) { return x > y ? x - y : y - x; }

u32 src4(i32 x, i32 y) { return smin(x, y) - smax(x, y); }
u32 tgt4(i32 x, i32 y) { return x < y ? x - y : y - x; }

The tgt form saves 1 instruction in the u32 case:

src1:
        cmp     w0, w1
        csel    w8, w0, w1, hi
        csel    w9, w0, w1, lo
        sub     w0, w8, w9
        ret

tgt1:
        sub     w8, w1, w0
        subs    w9, w0, w1
        csel    w0, w9, w8, hi
        ret

The difference is even more pronounced in the u128 case:

src1:
        cmp     x2, x0
        sbcs    xzr, x3, x1
        csel    x8, x1, x3, lo
        csel    x9, x0, x2, lo
        cmp     x0, x2
        sbcs    xzr, x1, x3
        csel    x10, x0, x2, lo
        csel    x11, x1, x3, lo
        subs    x0, x9, x10
        sbc     x1, x8, x11
        ret

tgt1:
        subs    x8, x0, x2
        sbc     x9, x1, x3
        subs    x10, x2, x0
        sbc     x11, x3, x1
        sbcs    xzr, x3, x1
        csel    x0, x8, x10, lo
        csel    x1, x9, x11, lo
        ret

[RKSimon]

#92576 should help here