int min_neg_s32(int a)
{
return -std::min(-a, a);
}

That's a hard way to write 'std::abs':
https://rise4fun.com/Alive/Cha

%negx = sub i32 0, %x
%cmp = icmp sgt i32 %negx, %x
%min = select i1 %cmp, i32 %x, i32 %negx
%r = sub i32 0, %min
=>
%cmp2 = icmp slt i32 %x, 0
%r = select i1 %cmp2, i32 %negx, i32 %x

-min(-x, x) can be generalized to -min(-x, y) => max(x, -y) (https://rise4fun.com/Alive/FBpl) but requires nsw at least on the min negation. The opposite case only works for y = x: -max(-x, x) => max(-x, x) (https://rise4fun.com/Alive/FDjL) but works for any combination of nsw flags.

Not sure about the nsw/nuw flags, but according to Alive this is correct too:

; -min(-x, -y) => max(x, y)

%negx = sub nsw 0, %x
%negy = sub nsw 0, %y
%cmp1 = icmp slt %negx, %negy
%sel1 = select %cmp1, %negx, %negy
%r = sub nsw 0, %sel1
=>
%cmp2 = icmp sgt %x, %y
%r = select %cmp2, %x, %y

I've noticed this while looking at the codegen of functions in llvm/test/CodeGen/X86/vector-reduce-umax.ll

Specifically, the sequence:

; X64-SSE2-NEXT: movdqa {{.*#+}} xmm2 = [32768,32768,32768,32768,32768,32768,32768,32768]
; X64-SSE2-NEXT: pxor %xmm2, %xmm0
; X64-SSE2-NEXT: pxor %xmm2, %xmm1
; X64-SSE2-NEXT: pminsw %xmm0, %xmm1
; X64-SSE2-NEXT: movdqa %xmm1, %xmm0
; X64-SSE2-NEXT: pxor %xmm2, %xmm0

Which is basically doing a - MIN (-A, -B)

And could be rewritten as a simple MAX(A, B):

; X64-SSE2-NEXT: pmaxsw %xmm0, %xmm1

Acutally sorry, the original code from that test was trying to do float negations (doing a xor of the sign bit).

Anyway, this is the Alive link: https://rise4fun.com/Alive/5Y7

Note that

-min(-x, y) => max(x, -y)

is more general than

-min(-x, -y) => max(x, y)

it just requires an extra -(-y) => y step.

Nowadays with the help of Negator we get:

define dso_local i32 @​_Z11min_neg_s32i(i32 %0) local_unnamed_addr #​0 {
%2 = sub nsw i32 0, %0
%3 = icmp sgt i32 %2, %0
%4 = select i1 %3, i32 %2, i32 %0
ret i32 %4
}

So i think the transform we are missing is

Name: (-x) s> x --> x s< 0
%neg_x = sub nsw i8 0, %x ; %x must not be INT_MIN
%r = icmp sgt i8 %neg_x, %x
=>
%r = icmp slt i8 %x, 0

Name: (-x) s>= x --> x s< 1
%neg_x = sub nsw i8 0, %x ; %x must not be INT_MIN
%r = icmp sge i8 %neg_x, %x
=>
%r = icmp slt i8 %x, 1

• commutative variants. I'm not seeing a generalization for (-x) s?? y case.

https://rise4fun.com/Alive/moSi

Ignoring the question of intrinsics, i can take a look

Added folds for (-NSW x) pred x --> x pred' 0 folds.
We now seem to handle the original (integer!) case well:
https://godbolt.org/z/qPPn97

Added folds for (-NSW x) pred x --> x pred' 0 folds.
We now seem to handle the original (integer!) case well:
https://godbolt.org/z/qPPn97

... but don't handle the vector case, since it lacks NSW.
I think it should be done after canonicalization to the new intrinsics.

Hm, i lost track here. Let me revisit this...

Hm, i lost track here. Let me revisit this...

There are multiple examples here, so I'm not sure what's left either.

On the FP side, we probably just need to hoist an fneg through a select (fneg is a unary op, so it misses the binop transforms we would try with a select operand):
https://alive2.llvm.org/ce/z/7FKWLP

We want to make sure that FMF get propagated through those transforms, so it needs a pile of tests. Let me know if I should work on that part.

Note that

-min(-x, y) => max(x, -y)

is more general than

-min(-x, -y) => max(x, y)

it just requires an extra -(-y) => y step.

And once again, i'm not sure what specific transform we are missing?

-min(-x, y) => max(x, -y)
... seems to not be valid:
https://alive2.llvm.org/ce/z/5grsyy

Hm, i lost track here. Let me revisit this...

There are multiple examples here, so I'm not sure what's left either.

On the FP side, we probably just need to hoist an fneg through a select
(fneg is a unary op, so it misses the binop transforms we would try with a
select operand):
https://alive2.llvm.org/ce/z/7FKWLP

We want to make sure that FMF get propagated through those transforms, so it
needs a pile of tests. Let me know if I should work on that part.

Posted too soon.

@​Sanjay yes, i don't intend to touch FP side of things, feel free to.

Ok, i'm seeing one missed Negator pattern:
-({u,s}{min,max}(-x, x)) -> -({u,s}{max,min}(-x, x))
https://alive2.llvm.org/ce/z/xyP9U2
https://alive2.llvm.org/ce/z/uDVZGV
https://alive2.llvm.org/ce/z/wfMJ4-
https://alive2.llvm.org/ce/z/vrrc-5

FP neg fold:
https://reviews.llvm.org/rG3cdd05e519dd

I think that gives us the optimal code for the example in the original description:

float min_neg_f32(float a)
{
return -std::min(-a, a);
}

-->
vxorps LCPI2_0(%rip), %xmm0, %xmm1
vmaxss %xmm0, %xmm1, %xmm0

This isn't fabs because of -0.0, but we miss that too even with -ffast-math, so that's another bug...

Filled in another missing FP min/max transform:
https://reviews.llvm.org/rG1e9b6b89a7b5

AFAICT the integer min/max -> abs folds are now complete - @rotateright are there any more fabs patterns that you think should be handled on this ticket or can we close it?

Let's close this one since it was mostly about the integer patterns. I have some notes about the missing FP transforms. I'll open new issues for those or just post patches.