[InstSimplify] Add simplifications for `min/max(Abs(X), X)`

[goldstein.w.n]

Summary

smax(Abs(X, t/f), X) --> Abs(X)

• https://alive2.llvm.org/ce/z/FJf3pM
• https://alive2.llvm.org/ce/z/Lem-WV

umin(Abs(X, t/f), X) --> Abs(X)

• https://alive2.llvm.org/ce/z/4LG-33
• https://alive2.llvm.org/ce/z/_LVNYi

smin(Abs(X, t/f), X) --> X

• https://alive2.llvm.org/ce/z/bNMkWz
• https://alive2.llvm.org/ce/z/VkMrcp

umax(Abs(X, t/f), X) --> X

• https://alive2.llvm.org/ce/z/ewXWfe
• https://alive2.llvm.org/ce/z/JHy-LC

[nikic]

Same here, you want folds along the lines of https://alive2.llvm.org/ce/z/4fWUpA.

llvm/lib/Analysis/InstructionSimplify.cpp

if (IID == Intrinsic::umax || IID == Intrinsic::umin) {
     // umax(usub.sat(X, Y), X) --> X
     // umin(usub.sat(X, Y), X) --> usub.sat(X, Y)
     if (match(Op0,
               m_Intrinsic<Intrinsic::usub_sat>(m_Specific(Op1), m_Value())) ||
         match(Op0,
               m_Intrinsic<Intrinsic::usub_sat>(m_Value(), m_Specific(Op1))))
       return IID == Intrinsic::umin ? Op0 : Op1;
   }
+  // smax(Abs(X, t/f), X) --> Abs(X, t/f)
+  // umin(Abs(X, t/f), X) --> Abs(X, t/f)
+  // smin(Abs(X, t/f), X) --> X
+  // umax(Abs(X, t/f), X) --> X
+  if (match(Op0, m_Intrinsic<Intrinsic::abs>(m_Specific(Op1), m_Value())))
+    return (IID == Intrinsic::smax || IID == Intrinsic::umin) ? Op0 : Op1;
 
   return nullptr;
 }
 
 static Value *simplifyBinaryIntrinsic(Function *F, Value *Op0, Value *Op1,
                                       const SimplifyQuery &Q) {
   Intrinsic::ID IID = F->getIntrinsicID();
   Type *ReturnType = F->getReturnType();

llvm/test/Transforms/InstSimplify/minmax-intrin.ll

 ;
   %xx = call i8 @llvm.uadd.sat.i8(i8 %x, i8 %y)
   %ret = call i8 @llvm.smin.i8(i8 %x, i8 %xx)
   ret i8 %ret
 }
 
 define i8 @umax_absT(i8 %x) {
 ; CHECK-LABEL: @umax_absT(
-; CHECK-NEXT:    [[XX:%.*]] = call i8 @llvm.abs.i8(i8 [[X:%.*]], i1 true)
-; CHECK-NEXT:    [[RET:%.*]] = call i8 @llvm.umax.i8(i8 [[XX]], i8 [[X]])
-; CHECK-NEXT:    ret i8 [[RET]]
+; CHECK-NEXT:    ret i8 [[X:%.*]]
 ;
   %xx = call i8 @llvm.abs.i8(i8 %x, i1 true)
   %ret = call i8 @llvm.umax.i8(i8 %xx, i8 %x)
   ret i8 %ret
 }
 
 define i8 @umax_absT_fail_mismatch(i8 %x, i8 %y) {
 ; CHECK-LABEL: @umax_absT_fail_mismatch(
 ; CHECK-NEXT:    [[XX:%.*]] = call i8 @llvm.abs.i8(i8 [[X:%.*]], i1 true)
 ; CHECK-NEXT:    [[RET:%.*]] = call i8 @llvm.umax.i8(i8 [[Y:%.*]], i8 [[XX]])
 ; CHECK-NEXT:    ret i8 [[RET]]
 ;
   %xx = call i8 @llvm.abs.i8(i8 %x, i1 true)
   %ret = call i8 @llvm.umax.i8(i8 %y, i8 %xx)
   ret i8 %ret
 }
 
 define <2 x i8> @umin_absF(<2 x i8> %x) {
 ; CHECK-LABEL: @umin_absF(
 ; CHECK-NEXT:    [[XX:%.*]] = call <2 x i8> @llvm.abs.v2i8(<2 x i8> [[X:%.*]], i1 false)
-; CHECK-NEXT:    [[RET:%.*]] = call <2 x i8> @llvm.umin.v2i8(<2 x i8> [[X]], <2 x i8> [[XX]])
-; CHECK-NEXT:    ret <2 x i8> [[RET]]
+; CHECK-NEXT:    ret <2 x i8> [[XX]]
 ;
   %xx = call <2 x i8> @llvm.abs.v2i8(<2 x i8> %x, i1 false)
   %ret = call <2 x i8> @llvm.umin.v2i8(<2 x i8> %x, <2 x i8> %xx)
   ret <2 x i8> %ret
 }
 
 define i8 @smax_absT(i8 %x) {
 ; CHECK-LABEL: @smax_absT(
 ; CHECK-NEXT:    [[XX:%.*]] = call i8 @llvm.abs.i8(i8 [[X:%.*]], i1 true)
-; CHECK-NEXT:    [[RET:%.*]] = call i8 @llvm.smax.i8(i8 [[X]], i8 [[XX]])
-; CHECK-NEXT:    ret i8 [[RET]]
+; CHECK-NEXT:    ret i8 [[XX]]
 ;
   %xx = call i8 @llvm.abs.i8(i8 %x, i1 true)
   %ret = call i8 @llvm.smax.i8(i8 %x, i8 %xx)
   ret i8 %ret
 }
 
 define i8 @smin_absF(i8 %x) {
 ; CHECK-LABEL: @smin_absF(
-; CHECK-NEXT:    [[XX:%.*]] = call i8 @llvm.abs.i8(i8 [[X:%.*]], i1 false)
-; CHECK-NEXT:    [[RET:%.*]] = call i8 @llvm.smin.i8(i8 [[XX]], i8 [[X]])
-; CHECK-NEXT:    ret i8 [[RET]]
+; CHECK-NEXT:    ret i8 [[X:%.*]]
 ;
   %xx = call i8 @llvm.abs.i8(i8 %x, i1 false)
   %ret = call i8 @llvm.smin.i8(i8 %xx, i8 %x)
   ret i8 %ret
 }