[PatternMatch] allow intrinsic form of min/max with existing matchers

[spatel]

Summary

I skimmed the existing users of these matchers and don't see any problems (eg, the caller assumes the matched value was a select instruction without checking).

So I think we can generalize the matching to allow the new intrinsics or the cmp+select idioms.

I did not find any unit tests for the matchers, so added some basics there. The instsimplify tests are adapted from existing tests for the cmp+select pattern and cover the folds in simplifyICmpWithMinMax().

[RKSimon]

Maybe make it clear at the start of InstCombinerImpl::foldSelectOpOp where we use the matchers that we can safely use the matchers for the select(icmp) pattern OR the intrinsics?

[spatel]

In D85230#2194521, @RKSimon wrote:

Maybe make it clear at the start of InstCombinerImpl::foldSelectOpOp where we use the matchers that we can safely use the matchers for the select(icmp) pattern OR the intrinsics?

In that code, we already know that the value that we are matching is a select, so there's no chance of matching an intrinsic there:

Instruction *InstCombinerImpl::foldSelectOpOp(SelectInst &SI, Instruction *TI,
                                              Instruction *FI) {
  if ((match(&SI, m_SMin(m_Value(), m_Value())) ||

We should eventually remove that code. Ie, once we canonicalize to the intrinsics, we will get to remove min/max crippling checks like that one because we won't have the cmp+sel patterns that correspond to min/max.

[RKSimon]

Thanks for checking! LGTM

llvm/include/llvm/IR/PatternMatch.h

struct MaxMin_match {
   LHS_t L;
   RHS_t R;
 
   // The evaluation order is always stable, regardless of Commutability.
   // The LHS is always matched first.
   MaxMin_match(const LHS_t &LHS, const RHS_t &RHS) : L(LHS), R(RHS) {}
 
   template <typename OpTy> bool match(OpTy *V) {
+    if (auto *II = dyn_cast<IntrinsicInst>(V)) {
+      Intrinsic::ID IID = II->getIntrinsicID();
+      if ((IID == Intrinsic::smax && Pred_t::match(ICmpInst::ICMP_SGT)) ||
+          (IID == Intrinsic::smin && Pred_t::match(ICmpInst::ICMP_SLT)) ||
+          (IID == Intrinsic::umax && Pred_t::match(ICmpInst::ICMP_UGT)) ||
+          (IID == Intrinsic::umin && Pred_t::match(ICmpInst::ICMP_ULT))) {
+        Value *LHS = II->getOperand(0), *RHS = II->getOperand(1);
+        return (L.match(LHS) && R.match(RHS)) ||
+               (Commutable && L.match(RHS) && R.match(LHS));
+      }
+    }
     // Look for "(x pred y) ? x : y" or "(x pred y) ? y : x".
     auto *SI = dyn_cast<SelectInst>(V);
     if (!SI)
       return false;
     auto *Cmp = dyn_cast<CmpInst_t>(SI->getCondition());
     if (!Cmp)
       return false;
     // At this point we have a select conditioned on a comparison.  Check that

llvm/test/Transforms/InstSimplify/maxmin_intrinsics.ll

 ;
   %m = call <2 x i8> @llvm.smax.v2i8(<2 x i8> %x, <2 x i8> <i8 undef, i8 10> )
   %m2 = call <2 x i8> @llvm.smax.v2i8(<2 x i8> <i8 9, i8 9>, <2 x i8> %m)
   ret <2 x i8> %m2
 }
 
 define i1 @smax_slt(i8 %x, i8 %y) {
 ; CHECK-LABEL: @smax_slt(
-; CHECK-NEXT:    [[M:%.*]] = call i8 @llvm.smax.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT:    [[R:%.*]] = icmp slt i8 [[M]], [[X]]
-; CHECK-NEXT:    ret i1 [[R]]
+; CHECK-NEXT:    ret i1 false
 ;
   %m = call i8 @llvm.smax.i8(i8 %x, i8 %y)
   %r = icmp slt i8 %m, %x
   ret i1 %r
 }
 
 define i1 @smax_sge(i8 %x, i8 %y) {
 ; CHECK-LABEL: @smax_sge(
-; CHECK-NEXT:    [[M:%.*]] = call i8 @llvm.smax.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT:    [[R:%.*]] = icmp sge i8 [[M]], [[X]]
-; CHECK-NEXT:    ret i1 [[R]]
+; CHECK-NEXT:    ret i1 true
 ;
   %m = call i8 @llvm.smax.i8(i8 %x, i8 %y)
   %r = icmp sge i8 %m, %x
   ret i1 %r
 }
 
 define i1 @umax_ult(i8 %x, i8 %y) {
 ; CHECK-LABEL: @umax_ult(
-; CHECK-NEXT:    [[M:%.*]] = call i8 @llvm.umax.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT:    [[R:%.*]] = icmp ult i8 [[M]], [[X]]
-; CHECK-NEXT:    ret i1 [[R]]
+; CHECK-NEXT:    ret i1 false
 ;
   %m = call i8 @llvm.umax.i8(i8 %x, i8 %y)
   %r = icmp ult i8 %m, %x
   ret i1 %r
 }
 
 define i1 @umax_uge(i8 %x, i8 %y) {
 ; CHECK-LABEL: @umax_uge(
-; CHECK-NEXT:    [[M:%.*]] = call i8 @llvm.umax.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT:    [[R:%.*]] = icmp uge i8 [[M]], [[X]]
-; CHECK-NEXT:    ret i1 [[R]]
+; CHECK-NEXT:    ret i1 true
 ;
   %m = call i8 @llvm.umax.i8(i8 %x, i8 %y)
   %r = icmp uge i8 %m, %x
   ret i1 %r
 }
 
 define i1 @smax_sgt(i8 %x, i8 %y) {
 ; CHECK-LABEL: @smax_sgt(
-; CHECK-NEXT:    [[M:%.*]] = call i8 @llvm.smax.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT:    [[R:%.*]] = icmp sgt i8 [[X]], [[M]]
-; CHECK-NEXT:    ret i1 [[R]]
+; CHECK-NEXT:    ret i1 false
 ;
   %m = call i8 @llvm.smax.i8(i8 %x, i8 %y)
   %r = icmp sgt i8 %x, %m
   ret i1 %r
 }
 
 define i1 @smax_sle(i8 %x, i8 %y) {
 ; CHECK-LABEL: @smax_sle(
-; CHECK-NEXT:    [[M:%.*]] = call i8 @llvm.smax.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT:    [[R:%.*]] = icmp sle i8 [[X]], [[M]]
-; CHECK-NEXT:    ret i1 [[R]]
+; CHECK-NEXT:    ret i1 true
 ;
   %m = call i8 @llvm.smax.i8(i8 %x, i8 %y)
   %r = icmp sle i8 %x, %m
   ret i1 %r
 }
 
 define i1 @umax_ugt(i8 %x, i8 %y) {
 ; CHECK-LABEL: @umax_ugt(
-; CHECK-NEXT:    [[M:%.*]] = call i8 @llvm.umax.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT:    [[R:%.*]] = icmp ugt i8 [[X]], [[M]]
-; CHECK-NEXT:    ret i1 [[R]]
+; CHECK-NEXT:    ret i1 false
 ;
   %m = call i8 @llvm.umax.i8(i8 %x, i8 %y)
   %r = icmp ugt i8 %x, %m
   ret i1 %r
 }
 
 define i1 @umax_ule(i8 %x, i8 %y) {
 ; CHECK-LABEL: @umax_ule(
-; CHECK-NEXT:    [[M:%.*]] = call i8 @llvm.umax.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT:    [[R:%.*]] = icmp ule i8 [[X]], [[M]]
-; CHECK-NEXT:    ret i1 [[R]]
+; CHECK-NEXT:    ret i1 true
 ;
   %m = call i8 @llvm.umax.i8(i8 %x, i8 %y)
   %r = icmp ule i8 %x, %m
   ret i1 %r
 }
 
 define i1 @smin_sgt(i8 %x, i8 %y) {
 ; CHECK-LABEL: @smin_sgt(
-; CHECK-NEXT:    [[M:%.*]] = call i8 @llvm.smin.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT:    [[R:%.*]] = icmp sgt i8 [[M]], [[X]]
-; CHECK-NEXT:    ret i1 [[R]]
+; CHECK-NEXT:    ret i1 false
 ;
   %m = call i8 @llvm.smin.i8(i8 %x, i8 %y)
   %r = icmp sgt i8 %m, %x
   ret i1 %r
 }
 
 define i1 @smin_sle(i8 %x, i8 %y) {
 ; CHECK-LABEL: @smin_sle(
-; CHECK-NEXT:    [[M:%.*]] = call i8 @llvm.smin.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT:    [[R:%.*]] = icmp sle i8 [[M]], [[X]]
-; CHECK-NEXT:    ret i1 [[R]]
+; CHECK-NEXT:    ret i1 true
 ;
   %m = call i8 @llvm.smin.i8(i8 %x, i8 %y)
   %r = icmp sle i8 %m, %x
   ret i1 %r
 }
 
 define i1 @umin_ugt(i8 %x, i8 %y) {
 ; CHECK-LABEL: @umin_ugt(
-; CHECK-NEXT:    [[M:%.*]] = call i8 @llvm.umin.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT:    [[R:%.*]] = icmp ugt i8 [[M]], [[X]]
-; CHECK-NEXT:    ret i1 [[R]]
+; CHECK-NEXT:    ret i1 false
 ;
   %m = call i8 @llvm.umin.i8(i8 %x, i8 %y)
   %r = icmp ugt i8 %m, %x
   ret i1 %r
 }
 
 define i1 @umin_ule(i8 %x, i8 %y) {
 ; CHECK-LABEL: @umin_ule(
-; CHECK-NEXT:    [[M:%.*]] = call i8 @llvm.umin.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT:    [[R:%.*]] = icmp ule i8 [[M]], [[X]]
-; CHECK-NEXT:    ret i1 [[R]]
+; CHECK-NEXT:    ret i1 true
 ;
   %m = call i8 @llvm.umin.i8(i8 %x, i8 %y)
   %r = icmp ule i8 %m, %x
   ret i1 %r
 }
 
 define i1 @smin_slt(i8 %x, i8 %y) {
 ; CHECK-LABEL: @smin_slt(
-; CHECK-NEXT:    [[M:%.*]] = call i8 @llvm.smin.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT:    [[R:%.*]] = icmp slt i8 [[X]], [[M]]
-; CHECK-NEXT:    ret i1 [[R]]
+; CHECK-NEXT:    ret i1 false
 ;
   %m = call i8 @llvm.smin.i8(i8 %x, i8 %y)
   %r = icmp slt i8 %x, %m
   ret i1 %r
 }
 
 define i1 @smin_sge(i8 %x, i8 %y) {
 ; CHECK-LABEL: @smin_sge(
-; CHECK-NEXT:    [[M:%.*]] = call i8 @llvm.smin.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT:    [[R:%.*]] = icmp sge i8 [[X]], [[M]]
-; CHECK-NEXT:    ret i1 [[R]]
+; CHECK-NEXT:    ret i1 true
 ;
   %m = call i8 @llvm.smin.i8(i8 %x, i8 %y)
   %r = icmp sge i8 %x, %m
   ret i1 %r
 }
 
 define i1 @umin_ult(i8 %x, i8 %y) {
 ; CHECK-LABEL: @umin_ult(
-; CHECK-NEXT:    [[M:%.*]] = call i8 @llvm.umin.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT:    [[R:%.*]] = icmp ult i8 [[X]], [[M]]
-; CHECK-NEXT:    ret i1 [[R]]
+; CHECK-NEXT:    ret i1 false
 ;
   %m = call i8 @llvm.umin.i8(i8 %x, i8 %y)
   %r = icmp ult i8 %x, %m
   ret i1 %r
 }
 
 define i1 @umin_uge(i8 %x, i8 %y) {
 ; CHECK-LABEL: @umin_uge(
-; CHECK-NEXT:    [[M:%.*]] = call i8 @llvm.umin.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT:    [[R:%.*]] = icmp uge i8 [[X]], [[M]]
-; CHECK-NEXT:    ret i1 [[R]]
+; CHECK-NEXT:    ret i1 true
 ;
   %m = call i8 @llvm.umin.i8(i8 %x, i8 %y)
   %r = icmp uge i8 %x, %m
   ret i1 %r
 }
 
 define i1 @smaxmin_sge(i8 %x, i8 %y, i8 %z) {
 ; CHECK-LABEL: @smaxmin_sge(
-; CHECK-NEXT:    [[MAX:%.*]] = call i8 @llvm.smax.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT:    [[MIN:%.*]] = call i8 @llvm.smin.i8(i8 [[Z:%.*]], i8 [[X]])
-; CHECK-NEXT:    [[C:%.*]] = icmp sge i8 [[MAX]], [[MIN]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 true
 ;
   %max = call i8 @llvm.smax.i8(i8 %x, i8 %y)
   %min = call i8 @llvm.smin.i8(i8 %z, i8 %x)
   %c = icmp sge i8 %max, %min
   ret i1 %c
 }
 
 define i1 @smaxmin_sgt(i8 %x, i8 %y, i8 %z) {
 ; CHECK-LABEL: @smaxmin_sgt(
-; CHECK-NEXT:    [[MAX:%.*]] = call i8 @llvm.smax.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT:    [[MIN:%.*]] = call i8 @llvm.smin.i8(i8 [[Z:%.*]], i8 [[X]])
-; CHECK-NEXT:    [[C:%.*]] = icmp sgt i8 [[MIN]], [[MAX]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 false
 ;
   %max = call i8 @llvm.smax.i8(i8 %x, i8 %y)
   %min = call i8 @llvm.smin.i8(i8 %z, i8 %x)
   %c = icmp sgt i8 %min, %max
   ret i1 %c
 }
 
 define i1 @smaxmin_sle(i8 %x, i8 %y, i8 %z) {
 ; CHECK-LABEL: @smaxmin_sle(
-; CHECK-NEXT:    [[MAX:%.*]] = call i8 @llvm.smax.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT:    [[MIN:%.*]] = call i8 @llvm.smin.i8(i8 [[Z:%.*]], i8 [[X]])
-; CHECK-NEXT:    [[C:%.*]] = icmp sle i8 [[MIN]], [[MAX]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 true
 ;
   %max = call i8 @llvm.smax.i8(i8 %x, i8 %y)
   %min = call i8 @llvm.smin.i8(i8 %z, i8 %x)
   %c = icmp sle i8 %min, %max
   ret i1 %c
 }
 
 define i1 @smaxmin_slt(i8 %x, i8 %y, i8 %z) {
 ; CHECK-LABEL: @smaxmin_slt(
-; CHECK-NEXT:    [[MAX:%.*]] = call i8 @llvm.smax.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT:    [[MIN:%.*]] = call i8 @llvm.smin.i8(i8 [[Z:%.*]], i8 [[X]])
-; CHECK-NEXT:    [[C:%.*]] = icmp slt i8 [[MAX]], [[MIN]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 false
 ;
   %max = call i8 @llvm.smax.i8(i8 %x, i8 %y)
   %min = call i8 @llvm.smin.i8(i8 %z, i8 %x)
   %c = icmp slt i8 %max, %min
   ret i1 %c
 }
 
 define i1 @umaxmin_uge(i8 %x, i8 %y, i8 %z) {
 ; CHECK-LABEL: @umaxmin_uge(
-; CHECK-NEXT:    [[MAX:%.*]] = call i8 @llvm.umax.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT:    [[MIN:%.*]] = call i8 @llvm.umin.i8(i8 [[Z:%.*]], i8 [[X]])
-; CHECK-NEXT:    [[C:%.*]] = icmp uge i8 [[MAX]], [[MIN]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 true
 ;
   %max = call i8 @llvm.umax.i8(i8 %x, i8 %y)
   %min = call i8 @llvm.umin.i8(i8 %z, i8 %x)
   %c = icmp uge i8 %max, %min
   ret i1 %c
 }
 
 define i1 @umaxmin_ugt(i8 %x, i8 %y, i8 %z) {
 ; CHECK-LABEL: @umaxmin_ugt(
-; CHECK-NEXT:    [[MAX:%.*]] = call i8 @llvm.umax.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT:    [[MIN:%.*]] = call i8 @llvm.umin.i8(i8 [[Z:%.*]], i8 [[X]])
-; CHECK-NEXT:    [[C:%.*]] = icmp ugt i8 [[MIN]], [[MAX]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 false
 ;
   %max = call i8 @llvm.umax.i8(i8 %x, i8 %y)
   %min = call i8 @llvm.umin.i8(i8 %z, i8 %x)
   %c = icmp ugt i8 %min, %max
   ret i1 %c
 }
 
 define i1 @umaxmin_ule(i8 %x, i8 %y, i8 %z) {
 ; CHECK-LABEL: @umaxmin_ule(
-; CHECK-NEXT:    [[MAX:%.*]] = call i8 @llvm.umax.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT:    [[MIN:%.*]] = call i8 @llvm.umin.i8(i8 [[Z:%.*]], i8 [[X]])
-; CHECK-NEXT:    [[C:%.*]] = icmp ule i8 [[MIN]], [[MAX]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 true
 ;
   %max = call i8 @llvm.umax.i8(i8 %x, i8 %y)
   %min = call i8 @llvm.umin.i8(i8 %z, i8 %x)
   %c = icmp ule i8 %min, %max
   ret i1 %c
 }
 
 define i1 @umaxmin_ult(i8 %x, i8 %y, i8 %z) {
 ; CHECK-LABEL: @umaxmin_ult(
-; CHECK-NEXT:    [[MAX:%.*]] = call i8 @llvm.umax.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT:    [[MIN:%.*]] = call i8 @llvm.umin.i8(i8 [[Z:%.*]], i8 [[X]])
-; CHECK-NEXT:    [[C:%.*]] = icmp ult i8 [[MAX]], [[MIN]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 false
 ;
   %max = call i8 @llvm.umax.i8(i8 %x, i8 %y)
   %min = call i8 @llvm.umin.i8(i8 %z, i8 %x)
   %c = icmp ult i8 %max, %min
   ret i1 %c
 }
 
+; Negative test - should reduce via instcombine, but not here.
+
 define i1 @smax_eq(i8 %x, i8 %y) {
 ; CHECK-LABEL: @smax_eq(
 ; CHECK-NEXT:    [[MAX:%.*]] = call i8 @llvm.smax.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
 ; CHECK-NEXT:    [[R:%.*]] = icmp eq i8 [[MAX]], [[X]]
 ; CHECK-NEXT:    ret i1 [[R]]
 ;
   %max = call i8 @llvm.smax.i8(i8 %x, i8 %y)
   %r = icmp eq i8 %max, %x
   ret i1 %r
 }
 
+; Negative test - should reduce via instcombine, but not here.
+
 define i1 @smax_eq_commute(i8 %x, i8 %y) {
 ; CHECK-LABEL: @smax_eq_commute(
 ; CHECK-NEXT:    [[MAX:%.*]] = call i8 @llvm.smax.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
 ; CHECK-NEXT:    [[R:%.*]] = icmp eq i8 [[X]], [[MAX]]
 ; CHECK-NEXT:    ret i1 [[R]]
 ;
   %max = call i8 @llvm.smax.i8(i8 %x, i8 %y)
   %r = icmp eq i8 %x, %max
   ret i1 %r
 }
 
+; Negative test - should reduce via instcombine, but not here.
+
 define i1 @umax_eq(i8 %x, i8 %y) {
 ; CHECK-LABEL: @umax_eq(
 ; CHECK-NEXT:    [[MAX:%.*]] = call i8 @llvm.umax.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
 ; CHECK-NEXT:    [[R:%.*]] = icmp eq i8 [[MAX]], [[X]]
 ; CHECK-NEXT:    ret i1 [[R]]
 ;
   %max = call i8 @llvm.umax.i8(i8 %x, i8 %y)
   %r = icmp eq i8 %max, %x
   ret i1 %r
 }
 
+; Negative test - should reduce via instcombine, but not here.
+
 define i1 @umax_eq_commute(i8 %x, i8 %y) {
 ; CHECK-LABEL: @umax_eq_commute(
 ; CHECK-NEXT:    [[MAX:%.*]] = call i8 @llvm.umax.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
 ; CHECK-NEXT:    [[R:%.*]] = icmp eq i8 [[X]], [[MAX]]
 ; CHECK-NEXT:    ret i1 [[R]]
 ;
   %max = call i8 @llvm.umax.i8(i8 %x, i8 %y)
   %r = icmp eq i8 %x, %max
   ret i1 %r
 }

llvm/unittests/IR/PatternMatch.cpp

TEST_F(PatternMatchTest, WithOverflowInst) {
   EXPECT_TRUE(match(Add, m_WithOverflowInst(WOI)));
 
   EXPECT_TRUE(match(Add0, m_ExtractValue<0>(m_WithOverflowInst(WOI))));
   EXPECT_EQ(Add, WOI);
   EXPECT_TRUE(match(Add1, m_ExtractValue<1>(m_WithOverflowInst(WOI))));
   EXPECT_EQ(Add, WOI);
 }
 
+TEST_F(PatternMatchTest, MinMaxIntrinsics) {
+  Type *Ty = IRB.getInt32Ty();
+  Value *L = ConstantInt::get(Ty, 1);
+  Value *R = ConstantInt::get(Ty, 2);
+  Value *MatchL, *MatchR;
+
+  // Check for intrinsic ID match and capture of operands.
+  EXPECT_TRUE(m_SMax(m_Value(MatchL), m_Value(MatchR))
+                  .match(IRB.CreateBinaryIntrinsic(Intrinsic::smax, L, R)));
+  EXPECT_EQ(L, MatchL);
+  EXPECT_EQ(R, MatchR);
+
+  EXPECT_TRUE(m_SMin(m_Value(MatchL), m_Value(MatchR))
+                  .match(IRB.CreateBinaryIntrinsic(Intrinsic::smin, L, R)));
+  EXPECT_EQ(L, MatchL);
+  EXPECT_EQ(R, MatchR);
+
+  EXPECT_TRUE(m_UMax(m_Value(MatchL), m_Value(MatchR))
+                  .match(IRB.CreateBinaryIntrinsic(Intrinsic::umax, L, R)));
+  EXPECT_EQ(L, MatchL);
+  EXPECT_EQ(R, MatchR);
+
+  EXPECT_TRUE(m_UMin(m_Value(MatchL), m_Value(MatchR))
+                  .match(IRB.CreateBinaryIntrinsic(Intrinsic::umin, L, R)));
+  EXPECT_EQ(L, MatchL);
+  EXPECT_EQ(R, MatchR);
+
+  // Check for intrinsic ID mismatch.
+  EXPECT_FALSE(m_SMax(m_Value(MatchL), m_Value(MatchR))
+                  .match(IRB.CreateBinaryIntrinsic(Intrinsic::smin, L, R)));
+  EXPECT_FALSE(m_SMin(m_Value(MatchL), m_Value(MatchR))
+                  .match(IRB.CreateBinaryIntrinsic(Intrinsic::umax, L, R)));
+  EXPECT_FALSE(m_UMax(m_Value(MatchL), m_Value(MatchR))
+                  .match(IRB.CreateBinaryIntrinsic(Intrinsic::umin, L, R)));
+  EXPECT_FALSE(m_UMin(m_Value(MatchL), m_Value(MatchR))
+                  .match(IRB.CreateBinaryIntrinsic(Intrinsic::smax, L, R)));
+}
+
 TEST_F(PatternMatchTest, IntrinsicMatcher) {
   Value *Name = IRB.CreateAlloca(IRB.getInt8Ty());
   Value *Hash = IRB.getInt64(0);
   Value *Num = IRB.getInt32(1);
   Value *Index = IRB.getInt32(2);
   Value *Step = IRB.getInt64(3);
 
   Value *Ops[] = {Name, Hash, Num, Index, Step};