[InstCombine] fold signed min/max intrinsics with negated operands

[spatel]

Summary

If both operands are negated, we can invert the min/max and do the negation after:
smax (neg nsw X), (neg nsw Y) --> neg nsw (smin X, Y)
smin (neg nsw X), (neg nsw Y) --> neg nsw (smax X, Y)

This is visible as a remaining regression in D98152. I don't see a way to generalize this for 'unsigned' or adapt Negator to handle it. This only appears to be safe with 'nsw':
https://alive2.llvm.org/ce/z/GUy1zJ

[lebedev.ri]

adapt Negator to handle it

Hmm, thanks for the hint, i was looking for this fold for a while :)
Indeed, negator does not track NSW-ness. What we can do for the signed variant is:
https://alive2.llvm.org/ce/z/MXZXKp aka https://alive2.llvm.org/ce/z/VJwMwD

[lebedev.ri]

LG.
I'm not sure we have similar fold for umin/umax.
There, only inversion comes to mind https://alive2.llvm.org/ce/z/4RcW8r, but apparently we already do that for all 4 variants.

llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp

if (match(I0, m_SExt(m_Value(X))) && match(I1, m_Constant(C)) &&
         I0->hasOneUse()) {
       Constant *NarrowC = ConstantExpr::getTrunc(C, X->getType());
       if (ConstantExpr::getSExt(NarrowC, II->getType()) == C) {
         Value *NarrowMaxMin = Builder.CreateBinaryIntrinsic(IID, X, NarrowC);
         return CastInst::Create(Instruction::SExt, NarrowMaxMin, II->getType());
       }
     }
 
+    if (IID == Intrinsic::smax || IID == Intrinsic::smin) {
+      // smax (neg nsw X), (neg nsw Y) --> neg nsw (smin X, Y)
+      // smin (neg nsw X), (neg nsw Y) --> neg nsw (smax X, Y)
+      if (match(I0, m_NSWNeg(m_Value(X))) && match(I1, m_NSWNeg(m_Value(Y))) &&
+          (I0->hasOneUse() || I1->hasOneUse())) {
+        Intrinsic::ID InvID = getInverseMinMaxIntrinsic(IID);
+        Value *InvMaxMin = Builder.CreateBinaryIntrinsic(InvID, X, Y);
+        return BinaryOperator::CreateNSWNeg(InvMaxMin);
+      }
+    }
+
     if (match(I0, m_Not(m_Value(X)))) {
       // max (not X), (not Y) --> not (min X, Y)
       Intrinsic::ID InvID = getInverseMinMaxIntrinsic(IID);
       if (match(I1, m_Not(m_Value(Y))) &&
           (I0->hasOneUse() || I1->hasOneUse())) {
         Value *InvMaxMin = Builder.CreateBinaryIntrinsic(InvID, X, Y);
         return BinaryOperator::CreateNot(InvMaxMin);
       }

llvm/test/Transforms/InstCombine/minmax-intrinsics.ll

 ;
   %m = call i8 @llvm.umin.i8(i8 %x, i8 -7)
   %r = and i8 %m, -8
   ret i8 %r
 }
 
 define i8 @neg_neg_nsw_smax(i8 %x, i8 %y) {
 ; CHECK-LABEL: @neg_neg_nsw_smax(
-; CHECK-NEXT:    [[NX:%.*]] = sub nsw i8 0, [[X:%.*]]
-; CHECK-NEXT:    [[NY:%.*]] = sub nsw i8 0, [[Y:%.*]]
-; CHECK-NEXT:    [[M:%.*]] = call i8 @llvm.smax.i8(i8 [[NX]], i8 [[NY]])
+; CHECK-NEXT:    [[TMP1:%.*]] = call i8 @llvm.smin.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
+; CHECK-NEXT:    [[M:%.*]] = sub nsw i8 0, [[TMP1]]
 ; CHECK-NEXT:    ret i8 [[M]]
 ;
   %nx = sub nsw i8 0, %x
   %ny = sub nsw i8 0, %y
   %m = call i8 @llvm.smax.i8(i8 %nx, i8 %ny)
   ret i8 %m
 }
 
 define <3 x i8> @neg_neg_nsw_smin(<3 x i8> %x, <3 x i8> %y) {
 ; CHECK-LABEL: @neg_neg_nsw_smin(
-; CHECK-NEXT:    [[NX:%.*]] = sub nsw <3 x i8> zeroinitializer, [[X:%.*]]
-; CHECK-NEXT:    [[NY:%.*]] = sub nsw <3 x i8> zeroinitializer, [[Y:%.*]]
-; CHECK-NEXT:    [[M:%.*]] = call <3 x i8> @llvm.smin.v3i8(<3 x i8> [[NX]], <3 x i8> [[NY]])
+; CHECK-NEXT:    [[TMP1:%.*]] = call <3 x i8> @llvm.smax.v3i8(<3 x i8> [[X:%.*]], <3 x i8> [[Y:%.*]])
+; CHECK-NEXT:    [[M:%.*]] = sub nsw <3 x i8> zeroinitializer, [[TMP1]]
 ; CHECK-NEXT:    ret <3 x i8> [[M]]
 ;
   %nx = sub nsw <3 x i8> zeroinitializer, %x
   %ny = sub nsw <3 x i8> zeroinitializer, %y
   %m = call <3 x i8> @llvm.smin.v3i8(<3 x i8> %nx, <3 x i8> %ny)
   ret <3 x i8> %m
 }
 
 define i8 @neg_neg_nsw_smax_use0(i8 %x, i8 %y) {
 ; CHECK-LABEL: @neg_neg_nsw_smax_use0(
 ; CHECK-NEXT:    [[NX:%.*]] = sub nsw i8 0, [[X:%.*]]
 ; CHECK-NEXT:    call void @use(i8 [[NX]])
-; CHECK-NEXT:    [[NY:%.*]] = sub nsw i8 0, [[Y:%.*]]
-; CHECK-NEXT:    [[M:%.*]] = call i8 @llvm.smax.i8(i8 [[NX]], i8 [[NY]])
+; CHECK-NEXT:    [[TMP1:%.*]] = call i8 @llvm.smin.i8(i8 [[X]], i8 [[Y:%.*]])
+; CHECK-NEXT:    [[M:%.*]] = sub nsw i8 0, [[TMP1]]
 ; CHECK-NEXT:    ret i8 [[M]]
 ;
   %nx = sub nsw i8 0, %x
   call void @use(i8 %nx)
   %ny = sub nsw i8 0, %y
   %m = call i8 @llvm.smax.i8(i8 %nx, i8 %ny)
   ret i8 %m
 }
 
 define i8 @neg_neg_nsw_smin_use1(i8 %x, i8 %y) {
 ; CHECK-LABEL: @neg_neg_nsw_smin_use1(
-; CHECK-NEXT:    [[NX:%.*]] = sub nsw i8 0, [[X:%.*]]
 ; CHECK-NEXT:    [[NY:%.*]] = sub nsw i8 0, [[Y:%.*]]
 ; CHECK-NEXT:    call void @use(i8 [[NY]])
-; CHECK-NEXT:    [[M:%.*]] = call i8 @llvm.smin.i8(i8 [[NX]], i8 [[NY]])
+; CHECK-NEXT:    [[TMP1:%.*]] = call i8 @llvm.smax.i8(i8 [[X:%.*]], i8 [[Y]])
+; CHECK-NEXT:    [[M:%.*]] = sub nsw i8 0, [[TMP1]]
 ; CHECK-NEXT:    ret i8 [[M]]
 ;
   %nx = sub nsw i8 0, %x
   %ny = sub nsw i8 0, %y
   call void @use(i8 %ny)
   %m = call i8 @llvm.smin.i8(i8 %nx, i8 %ny)
   ret i8 %m
 }
 
+; negative test - too many uses
+
 define i8 @neg_neg_nsw_smin_use2(i8 %x, i8 %y) {
 ; CHECK-LABEL: @neg_neg_nsw_smin_use2(
 ; CHECK-NEXT:    [[NX:%.*]] = sub nsw i8 0, [[X:%.*]]
 ; CHECK-NEXT:    call void @use(i8 [[NX]])
 ; CHECK-NEXT:    [[NY:%.*]] = sub nsw i8 0, [[Y:%.*]]
 ; CHECK-NEXT:    call void @use(i8 [[NY]])
 ; CHECK-NEXT:    [[M:%.*]] = call i8 @llvm.smin.i8(i8 [[NX]], i8 [[NY]])
 ; CHECK-NEXT:    ret i8 [[M]]
 ;
   %nx = sub nsw i8 0, %x
   call void @use(i8 %nx)
   %ny = sub nsw i8 0, %y
   call void @use(i8 %ny)
   %m = call i8 @llvm.smin.i8(i8 %nx, i8 %ny)
   ret i8 %m
 }
 
+; negative test - need nsw on both ops
+
 define i8 @neg_neg_smax(i8 %x, i8 %y) {
 ; CHECK-LABEL: @neg_neg_smax(
 ; CHECK-NEXT:    [[NX:%.*]] = sub i8 0, [[X:%.*]]
 ; CHECK-NEXT:    [[NY:%.*]] = sub nsw i8 0, [[Y:%.*]]
 ; CHECK-NEXT:    [[M:%.*]] = call i8 @llvm.smax.i8(i8 [[NX]], i8 [[NY]])
 ; CHECK-NEXT:    ret i8 [[M]]
 ;
   %nx = sub i8 0, %x
   %ny = sub nsw i8 0, %y
   %m = call i8 @llvm.smax.i8(i8 %nx, i8 %ny)
   ret i8 %m
 }
 
+; negative test - need nsw on both ops
+
 define i8 @neg_neg_smin(i8 %x, i8 %y) {
 ; CHECK-LABEL: @neg_neg_smin(
 ; CHECK-NEXT:    [[NX:%.*]] = sub i8 0, [[X:%.*]]
 ; CHECK-NEXT:    [[NY:%.*]] = sub nsw i8 0, [[Y:%.*]]
 ; CHECK-NEXT:    [[M:%.*]] = call i8 @llvm.smin.i8(i8 [[NX]], i8 [[NY]])
 ; CHECK-NEXT:    ret i8 [[M]]
 ;
   %nx = sub i8 0, %x
   %ny = sub nsw i8 0, %y
   %m = call i8 @llvm.smin.i8(i8 %nx, i8 %ny)
   ret i8 %m
 }
 
+; negative test - need signed min/max
+
 define i8 @neg_neg_nsw_umin(i8 %x, i8 %y) {
 ; CHECK-LABEL: @neg_neg_nsw_umin(
 ; CHECK-NEXT:    [[NX:%.*]] = sub nsw i8 0, [[X:%.*]]
 ; CHECK-NEXT:    [[NY:%.*]] = sub nsw i8 0, [[Y:%.*]]
 ; CHECK-NEXT:    [[M:%.*]] = call i8 @llvm.umin.i8(i8 [[NX]], i8 [[NY]])
 ; CHECK-NEXT:    ret i8 [[M]]
 ;
   %nx = sub nsw i8 0, %x
   %ny = sub nsw i8 0, %y
   %m = call i8 @llvm.umin.i8(i8 %nx, i8 %ny)
   ret i8 %m
 }