[InstSimplify] Add simplifications for `umin/umax(uadd/usub.sat(X, Y), X)`

[goldstein.w.n]

Summary

umax(uadd.sat(X, Y), X) --> uadd.sat(X, Y)

• https://alive2.llvm.org/ce/z/mEJk_t

umin(uadd.sat(X, Y), X) --> X

• https://alive2.llvm.org/ce/z/ZfVrjD

umax(usub.sat(X, Y), X) --> X

• https://alive2.llvm.org/ce/z/ec8xDQ

umin(usub.sat(X, Y), X) --> usub.sat(X, Y)

• https://alive2.llvm.org/ce/z/FLkAcA

[nikic]

I believe this is taking the wrong approach to these folds. What you want to implement is simplification for something like this: https://alive2.llvm.org/ce/z/f_Eg7U And then min/max simplification should fall out of that for free.

llvm/lib/Analysis/InstructionSimplify.cpp

if (IID0 == IID)
       return MM0;
     // max (min X, Y), X --> X
     if (IID0 == getInverseMinMaxIntrinsic(IID))
       return Op1;
   }
   return nullptr;
 }
 
+static Value *foldMinMaxOfIntrin(Intrinsic::ID IID, Value *Op0, Value *Op1) {
+  if (IID == Intrinsic::umax || IID == Intrinsic::umin) {
+    // umax(uadd.sat(X, Y), X) --> uadd.sat(X, Y)
+    // umin(uadd.sat(X, Y), X) --> X
+    if (match(Op0,
+              m_Intrinsic<Intrinsic::uadd_sat>(m_Specific(Op1), m_Value())) ||
+        match(Op0,
+              m_Intrinsic<Intrinsic::uadd_sat>(m_Value(), m_Specific(Op1))))
+      return IID == Intrinsic::umax ? Op0 : Op1;
+    // 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;
+  }
+
+  return nullptr;
+}
+
 static Value *simplifyBinaryIntrinsic(Function *F, Value *Op0, Value *Op1,
                                       const SimplifyQuery &Q) {
   Intrinsic::ID IID = F->getIntrinsicID();
   Type *ReturnType = F->getReturnType();
   unsigned BitWidth = ReturnType->getScalarSizeInBits();
   switch (IID) {
   case Intrinsic::abs:
     // abs(abs(x)) -> abs(x). We don't need to worry about the nsw arg here.
if (match(Op1, m_APIntAllowUndef(C))) {
       }
     }
 
     if (Value *V = foldMinMaxSharedOp(IID, Op0, Op1))
       return V;
     if (Value *V = foldMinMaxSharedOp(IID, Op1, Op0))
       return V;
 
+    if (Value *V = foldMinMaxOfIntrin(IID, Op0, Op1))
+      return V;
+    if (Value *V = foldMinMaxOfIntrin(IID, Op1, Op0))
+      return V;
+
     ICmpInst::Predicate Pred =
         ICmpInst::getNonStrictPredicate(MinMaxIntrinsic::getPredicate(IID));
     if (isICmpTrue(Pred, Op0, Op1, Q.getWithoutUndef(), RecursionLimit))
       return Op0;
     if (isICmpTrue(Pred, Op1, Op0, Q.getWithoutUndef(), RecursionLimit))
       return Op1;
 
     break;

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

 declare <2 x i8> @llvm.uadd.sat.v2i8(<2 x i8>, <2 x i8>)
 declare <2 x i8> @llvm.usub.sat.v2i8(<2 x i8>, <2 x i8>)
 declare <2 x i8> @llvm.umax.v2i8(<2 x i8>, <2 x i8>)
 declare <2 x i8> @llvm.umin.v2i8(<2 x i8>, <2 x i8>)
 
 define <2 x i8> @umax_uadd_sat(<2 x i8> %x, <2 x i8> %y) {
 ; CHECK-LABEL: @umax_uadd_sat(
 ; CHECK-NEXT:    [[XX:%.*]] = call <2 x i8> @llvm.uadd.sat.v2i8(<2 x i8> [[X:%.*]], <2 x i8> [[Y:%.*]])
-; CHECK-NEXT:    [[RET:%.*]] = call <2 x i8> @llvm.umax.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.uadd.sat.v2i8(<2 x i8> %x, <2 x i8> %y)
   %ret = call <2 x i8> @llvm.umax.v2i8(<2 x i8> %x, <2 x i8> %xx)
   ret <2 x i8> %ret
 }
 
 define i8 @umin_uadd_sat(i8 %x, i8 %y) {
 ; CHECK-LABEL: @umin_uadd_sat(
-; CHECK-NEXT:    [[XX:%.*]] = call i8 @llvm.uadd.sat.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT:    [[RET:%.*]] = call i8 @llvm.umin.i8(i8 [[XX]], i8 [[X]])
-; CHECK-NEXT:    ret i8 [[RET]]
+; CHECK-NEXT:    ret i8 [[X:%.*]]
 ;
   %xx = call i8 @llvm.uadd.sat.i8(i8 %x, i8 %y)
   %ret = call i8 @llvm.umin.i8(i8 %xx, i8 %x)
   ret i8 %ret
 }
 
 define i8 @umax_usub_sat(i8 %x, i8 %y) {
 ; CHECK-LABEL: @umax_usub_sat(
-; CHECK-NEXT:    [[XX:%.*]] = call i8 @llvm.usub.sat.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT:    [[RET:%.*]] = call i8 @llvm.umax.i8(i8 [[X]], i8 [[XX]])
-; CHECK-NEXT:    ret i8 [[RET]]
+; CHECK-NEXT:    ret i8 [[X:%.*]]
 ;
   %xx = call i8 @llvm.usub.sat.i8(i8 %x, i8 %y)
   %ret = call i8 @llvm.umax.i8(i8 %x, i8 %xx)
   ret i8 %ret
 }
 
 define <2 x i8> @umin_usub_sat(<2 x i8> %x, <2 x i8> %y) {
 ; CHECK-LABEL: @umin_usub_sat(
 ; CHECK-NEXT:    [[XX:%.*]] = call <2 x i8> @llvm.usub.sat.v2i8(<2 x i8> [[X:%.*]], <2 x i8> [[Y:%.*]])
-; 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.usub.sat.v2i8(<2 x i8> %x, <2 x i8> %y)
   %ret = call <2 x i8> @llvm.umin.v2i8(<2 x i8> %x, <2 x i8> %xx)
   ret <2 x i8> %ret
 }
 
 define <2 x i8> @umax_usub_sat_fail_mismatch(<2 x i8> %x, <2 x i8> %y, <2 x i8> %z) {
 ; CHECK-LABEL: @umax_usub_sat_fail_mismatch(