[InstSimplify] fold min/max intrinsics using icmp simplification

[spatel]

Summary

As discussed in rG0481e1ae3c17, we can use icmp simplification to reduce min/max intrinsics, so we don't have to re-implement a long list of possible transforms.

But (if my undef reasoning is correct), this is not as easy as always returning the existing operand. In the case of undefs, we need to clamp to the limit constant. This is similar to what we do with the saturating math intrinsics.

[nikic]

But (if my undef reasoning is correct), this is not as easy as always returning the existing operand. In the case of undefs, we need to clamp to the limit constant. This is similar to what we do with the saturating math intrinsics.

Gah, undef strikes again. I don't think what you did here is sufficient, because the SimplifyICmpInst() may depend on undef in a more roundabout manner than a direct undef element in one of the min/max operands. I think in the short term this needs to be guarded by guaranteed-not-undef, at least for the operand that we simplify to.

In the longer term, I think we really need to introduce an InstSimplify query flag that disables undef-based folds. I think at this point we have multiple places where we need this. This is one, it is also the imho more proper solution to D84250, and @fhahn mentioned that this may be needed for NewGVN correctness as well.

[spatel]

Patch updated:
Bail out if the would-be constant result is not safe. Not sure if this goes far enough. We still manage to fold 1 of the partial undef tests because the icmp analysis allows it and we are returning a non-constant value in that case.

[aqjune]

Hi,
Is there a case where depending on SimplifyICmpInst may be problematic? I'm not very familiar with the history of miscompilation related with InstSimplify (except the distribution of undef), so it is possible that I'm missing something.

v = smax(x, y)
use(v)
  => // isICmpTrue(sgt, x, y) is true
v = smax(x, y)
use(x) // Is this valid?

For the D84250, the fix had to be conservative because distribution is incorrect under presence of undef. If InstSimplify can be arbitrarily smart so e.g. it iterates over the basic block and find the equivalent expression (as GVN does), this can cause miscompliation:

tmp = x + x
v = x * (1 + 1) // InstSimplify reaches to the conclusion that this is equivalent to x + x, finds tmp, so it uses tmp instead.
->
tmp = x + x
v = tmp // This is wrong, because previously v is always an even, but not it can be anything if x is undef.

[spatel]

In D84655#2178334, @aqjune wrote:

Hi,
Is there a case where depending on SimplifyICmpInst may be problematic? I'm not very familiar with the history of miscompilation related with InstSimplify (except the distribution of undef), so it is possible that I'm missing something.

v = smax(x, y)
use(v)
  => // isICmpTrue(sgt, x, y) is true
v = smax(x, y)
use(x) // Is this valid?

For the D84250, the fix had to be conservative because distribution is incorrect under presence of undef. If InstSimplify can be arbitrarily smart so e.g. it iterates over the basic block and find the equivalent expression (as GVN does), this can cause miscompliation:

tmp = x + x
v = x * (1 + 1) // InstSimplify reaches to the conclusion that this is equivalent to x + x, finds tmp, so it uses tmp instead.
->
tmp = x + x
v = tmp // This is wrong, because previously v is always an even, but not it can be anything if x is undef.

Yes, this reminds me of D77868, so I'm worried that we can't trust SimplifyICmpInst without a stronger undef check. Given that, I'd rather abandon this approach. I think we can put in a handful of direct min/max simplifications and be confident that we have good optimization and safety. Ie, back to the approach started with rG0481e1a.

[aqjune]

In D84655#2178544, @spatel wrote:

Yes, this reminds me of D77868, so I'm worried that we can't trust SimplifyICmpInst without a stronger undef check. Given that, I'd rather abandon this approach. I think we can put in a handful of direct min/max simplifications and be confident that we have good optimization and safety. Ie, back to the approach started with rG0481e1a.

I think this case is a bit different from D77868: min/max can be expressed as a composition of icmp with select.

v = smax(a, b)
<=>
c = icmp sgt a, b
v = select c, a, b

It seems legal to use SimplifyICmpInst to get the simplified value of c.
If these two expressions are different (which can happen when e.g. smax/smin are defined to block poison), using SimplifyICmpInst may be illegal.
(BTW, this equivalence seems to be the most important thing to prove first once the min/max intrinsic functions are added into Alive2.)

In case of D77868, using SimplifyAndInst/SimplifyOrInst to get the value of select was illegal, because select is not equivalent to and/or.

[fhahn]

In D84655#2176704, @nikic wrote:

But (if my undef reasoning is correct), this is not as easy as always returning the existing operand. In the case of undefs, we need to clamp to the limit constant. This is similar to what we do with the saturating math intrinsics.

In the longer term, I think we really need to introduce an InstSimplify query flag that disables undef-based folds. I think at this point we have multiple places where we need this. This is one, it is also the imho more proper solution to D84250, and @fhahn mentioned that this may be needed for NewGVN correctness as well.

For NewGVN we could also work around the problem by providing a way for InstSimplify to query the 'virtual' operands instead of the actual IR operands. I have some rough patches for that, but it gets quite hairy when it comes to threading that through to the various match() uses.

So for now, I put up a patch to control the use of undef through SimplifyQuery D84792. If it is useful in other cases too, it might make sense to get this in first.

[nikic]

In D84655#2179046, @aqjune wrote:

In D84655#2178544, @spatel wrote:

Yes, this reminds me of D77868, so I'm worried that we can't trust SimplifyICmpInst without a stronger undef check. Given that, I'd rather abandon this approach. I think we can put in a handful of direct min/max simplifications and be confident that we have good optimization and safety. Ie, back to the approach started with rG0481e1a.

I think this case is a bit different from D77868: min/max can be expressed as a composition of icmp with select.

v = smax(a, b)
<=>
c = icmp sgt a, b
v = select c, a, b

The problem is that this does not hold. It's okay to go from icmp+select to max, but not the other way around. The difference is exactly that max requires a unique value for a and b, while the icmp+select sequence allows a and b to be chosen independently for the icmp and the select, if they are undef. This is also the reason why many of our existing min/max transforms are not actually legal when undef is taken into consideration.

[aqjune]

In D84655#2179906, @nikic wrote:

The problem is that this does not hold. It's okay to go from icmp+select to max, but not the other way around. The difference is exactly that max requires a unique value for a and b, while the icmp+select sequence allows a and b to be chosen independently for the icmp and the select, if they are undef. This is also the reason why many of our existing min/max transforms are not actually legal when undef is taken into consideration.

I see your point. You're right, they are not equivalent. max(undef, 3) -> undef is invalid, which is ok if it was represented with icmp + select.
It is sad that the decomposition of max to icmp + select is invalid. It could have made this kind of reasoning simpler.

I think either allowing handful transformations for max/min only or using InstSimplify after a flag for unusing undef is added is fine.

[spatel]

I added code to simplify these intrinsics without using SimplifyICmpInst, so we can make progress. If we find a way to avoid undef-related logic holes, we can revisit this approach.
rG3fb13b8484dc
rG9ee7d7122c06
rG3c20ede18b85
rG3e8534fbc62c
rGee9617e96b05
rG5cd695dd7fbd
rGfef513f5ccb7

llvm/lib/Analysis/InstructionSimplify.cpp

static Value *simplifyUnaryIntrinsic(Function *F, Value *Op0,
   }
   default:
     break;
   }
 
   return nullptr;
 }
 
+/// Simplify integer min/max intrinsics. The caller is expected to swap the
+/// input values to handle commutation.
+static Value *simplifyMinMax(Intrinsic::ID IID, Value *Op0, Value *Op1,
+                             const SimplifyQuery &Q, unsigned MaxRecurse) {
+  // Map intrinsic to comparison predicate.
+  assert(Op0->getType() == Op1->getType() && "Unexpected types for min/max");
+  Type *Ty = Op0->getType();
+  ICmpInst::Predicate Pred;
+  APInt LimitC;
+  switch (IID) {
+  case Intrinsic::smax:
+    Pred = ICmpInst::ICMP_SGE;
+    LimitC = APInt::getSignedMaxValue(Ty->getScalarSizeInBits());
+    break;
+  case Intrinsic::smin:
+    Pred = ICmpInst::ICMP_SLE;
+    LimitC = APInt::getSignedMinValue(Ty->getScalarSizeInBits());
+    break;
+  case Intrinsic::umax:
+    Pred = ICmpInst::ICMP_UGE;
+    LimitC = APInt::getMaxValue(Ty->getScalarSizeInBits());
+    break;
+  case Intrinsic::umin:
+    Pred = ICmpInst::ICMP_ULE;
+    LimitC = APInt::getMinValue(Ty->getScalarSizeInBits());
+    break;
+  default:
+    llvm_unreachable("Unexpected intrinsic");
+  }
+
+  // Assume that undef equals the constant limit value for the intrinsic.
+  if (isa<UndefValue>(Op0) || isa<UndefValue>(Op1))
+    return ConstantInt::get(Ty, LimitC);
+
+  if (!isICmpTrue(Pred, Op0, Op1, Q, MaxRecurse))
+    return nullptr;
+
+  // Don't try folding if the result would contain undef because the icmp
+  // simplification may not hold for this op. {max/min}(x, undef) != undef.
+  Constant *C;
+  if (match(Op0, m_Constant(C)) && !isGuaranteedNotToBeUndefOrPoison(C))
+    return nullptr;
+  return Op0;
+}
+
 static Value *simplifyBinaryIntrinsic(Function *F, Value *Op0, Value *Op1,
-                                      const SimplifyQuery &Q) {
+                                      const SimplifyQuery &Q,
+                                      unsigned MaxRecurse) {
   Intrinsic::ID IID = F->getIntrinsicID();
   Type *ReturnType = F->getReturnType();
   switch (IID) {
   case Intrinsic::smax:
   case Intrinsic::smin:
   case Intrinsic::umax:
-  case Intrinsic::umin: {
-    // Canonicalize constant operand as Op1.
-    if (isa<Constant>(Op0))
-      std::swap(Op0, Op1);
-
-    // TODO: Allow partial undef vector constants.
-    const APInt *C;
-    if (!match(Op1, m_APInt(C)))
-      break;
+  case Intrinsic::umin:
+    if (Value *V = simplifyMinMax(IID, Op0, Op1, Q, MaxRecurse))
+      return V;
+    if (Value *V = simplifyMinMax(IID, Op1, Op0, Q, MaxRecurse))
+      return V;
 
-    if ((IID == Intrinsic::smax && C->isMaxSignedValue()) ||
-        (IID == Intrinsic::smin && C->isMinSignedValue()) ||
-        (IID == Intrinsic::umax && C->isMaxValue()) ||
-        (IID == Intrinsic::umin && C->isMinValue()))
-      return Op1;
-
-    break;
-  }
   case Intrinsic::usub_with_overflow:
   case Intrinsic::ssub_with_overflow:
     // X - X -> { 0, false }
     if (Op0 == Op1)
       return Constant::getNullValue(ReturnType);
     LLVM_FALLTHROUGH;
   case Intrinsic::uadd_with_overflow:
   case Intrinsic::sadd_with_overflow:
static Value *simplifyBinaryIntrinsic(Function *F, Value *Op0, Value *Op1,
   }
   default:
     break;
   }
 
   return nullptr;
 }
 
-static Value *simplifyIntrinsic(CallBase *Call, const SimplifyQuery &Q) {
+static Value *simplifyIntrinsic(CallBase *Call, const SimplifyQuery &Q,
+                                unsigned MaxRecurse) {
 
   // Intrinsics with no operands have some kind of side effect. Don't simplify.
   unsigned NumOperands = Call->getNumArgOperands();
   if (!NumOperands)
     return nullptr;
 
   Function *F = cast<Function>(Call->getCalledFunction());
   Intrinsic::ID IID = F->getIntrinsicID();
   if (NumOperands == 1)
     return simplifyUnaryIntrinsic(F, Call->getArgOperand(0), Q);
 
   if (NumOperands == 2)
     return simplifyBinaryIntrinsic(F, Call->getArgOperand(0),
-                                   Call->getArgOperand(1), Q);
+                                   Call->getArgOperand(1), Q, MaxRecurse);
 
   // Handle intrinsics with 3 or more arguments.
   switch (IID) {
   case Intrinsic::masked_load:
   case Intrinsic::masked_gather: {
     Value *MaskArg = Call->getArgOperand(2);
     Value *PassthruArg = Call->getArgOperand(3);
     // If the mask is all zeros or undef, the "passthru" argument is the result.
if (Value *V = simplifyFPOp({ Op0, Op1, Op2 }))
       return V;
     return nullptr;
   }
   default:
     return nullptr;
   }
 }
 
-Value *llvm::SimplifyCall(CallBase *Call, const SimplifyQuery &Q) {
+static Value *SimplifyCall(CallBase *Call, const SimplifyQuery &Q,
+                           unsigned MaxRecurse) {
   Value *Callee = Call->getCalledOperand();
 
   // musttail calls can only be simplified if they are also DCEd.
   // As we can't guarantee this here, don't simplify them.
   if (Call->isMustTailCall())
     return nullptr;
 
   // call undef -> undef
   // call null -> undef
   if (isa<UndefValue>(Callee) || isa<ConstantPointerNull>(Callee))
     return UndefValue::get(Call->getType());
 
   Function *F = dyn_cast<Function>(Callee);
   if (!F)
     return nullptr;
 
   if (F->isIntrinsic())
-    if (Value *Ret = simplifyIntrinsic(Call, Q))
+    if (Value *Ret = simplifyIntrinsic(Call, Q, MaxRecurse))
       return Ret;
 
   if (!canConstantFoldCallTo(Call, F))
     return nullptr;
 
   SmallVector<Constant *, 4> ConstantArgs;
   unsigned NumArgs = Call->getNumArgOperands();
   ConstantArgs.reserve(NumArgs);
   for (auto &Arg : Call->args()) {
     Constant *C = dyn_cast<Constant>(&Arg);
     if (!C) {
       if (isa<MetadataAsValue>(Arg.get()))
         continue;
       return nullptr;
     }
     ConstantArgs.push_back(C);
   }
 
   return ConstantFoldCall(Call, F, ConstantArgs, Q.TLI);
 }
 
+Value *llvm::SimplifyCall(CallBase *Call, const SimplifyQuery &Q) {
+  return ::SimplifyCall(Call, Q, RecursionLimit);
+}
+
 /// Given operands for a Freeze, see if we can fold the result.
 static Value *SimplifyFreezeInst(Value *Op0, const SimplifyQuery &Q) {
   // Use a utility function defined in ValueTracking.
   if (llvm::isGuaranteedNotToBeUndefOrPoison(Op0, Q.CxtI, Q.DT))
     return Op0;
   // We have room for improvement.
   return nullptr;
 }

llvm/test/Transforms/InstSimplify/maxmin_intrinsics.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -instsimplify -S | FileCheck %s
 
 declare i81 @llvm.smax.i81(i81, i81)
 declare i8 @llvm.smax.i8(i8, i8)
 declare <2 x i8> @llvm.smax.v2i8(<2 x i8>, <2 x i8>)
 declare i3 @llvm.smin.i3(i3, i3)
 declare i8 @llvm.smin.i8(i8, i8)
 declare <2 x i8> @llvm.smin.v2i8(<2 x i8>, <2 x i8>)
 declare i8 @llvm.umax.i8(i8, i8)
 declare <2 x i8> @llvm.umax.v2i8(<2 x i8>, <2 x i8>)
 declare i8 @llvm.umin.i8(i8, i8)
 declare <2 x i8> @llvm.umin.v2i8(<2 x i8>, <2 x i8>)
 
 define i81 @smax_sameval(i81 %x) {
 ; CHECK-LABEL: @smax_sameval(
-; CHECK-NEXT:    [[R:%.*]] = call i81 @llvm.smax.i81(i81 [[X:%.*]], i81 [[X]])
-; CHECK-NEXT:    ret i81 [[R]]
+; CHECK-NEXT:    ret i81 [[X:%.*]]
 ;
   %r = call i81 @llvm.smax.i81(i81 %x, i81 %x)
   ret i81 %r
 }
 
 define i3 @smin_sameval(i3 %x) {
 ; CHECK-LABEL: @smin_sameval(
-; CHECK-NEXT:    [[R:%.*]] = call i3 @llvm.smin.i3(i3 [[X:%.*]], i3 [[X]])
-; CHECK-NEXT:    ret i3 [[R]]
+; CHECK-NEXT:    ret i3 [[X:%.*]]
 ;
   %r = call i3 @llvm.smin.i3(i3 %x, i3 %x)
   ret i3 %r
 }
 
 define <2 x i8> @umax_sameval(<2 x i8> %x) {
 ; CHECK-LABEL: @umax_sameval(
-; CHECK-NEXT:    [[R:%.*]] = call <2 x i8> @llvm.umax.v2i8(<2 x i8> [[X:%.*]], <2 x i8> [[X]])
-; CHECK-NEXT:    ret <2 x i8> [[R]]
+; CHECK-NEXT:    ret <2 x i8> [[X:%.*]]
 ;
   %r = call <2 x i8> @llvm.umax.v2i8(<2 x i8> %x, <2 x i8> %x)
   ret <2 x i8> %r
 }
 
 define <2 x i8> @umin_sameval(<2 x i8> %x) {
 ; CHECK-LABEL: @umin_sameval(
-; CHECK-NEXT:    [[R:%.*]] = call <2 x i8> @llvm.umin.v2i8(<2 x i8> [[X:%.*]], <2 x i8> [[X]])
-; CHECK-NEXT:    ret <2 x i8> [[R]]
+; CHECK-NEXT:    ret <2 x i8> [[X:%.*]]
 ;
   %r = call <2 x i8> @llvm.umin.v2i8(<2 x i8> %x, <2 x i8> %x)
   ret <2 x i8> %r
 }
 
 define i81 @smax_undef(i81 %x) {
 ; CHECK-LABEL: @smax_undef(
-; CHECK-NEXT:    [[R:%.*]] = call i81 @llvm.smax.i81(i81 undef, i81 [[X:%.*]])
-; CHECK-NEXT:    ret i81 [[R]]
+; CHECK-NEXT:    ret i81 1208925819614629174706175
 ;
   %r = call i81 @llvm.smax.i81(i81 undef, i81 %x)
   ret i81 %r
 }
 
 define i3 @smin_undef(i3 %x) {
 ; CHECK-LABEL: @smin_undef(
-; CHECK-NEXT:    [[R:%.*]] = call i3 @llvm.smin.i3(i3 [[X:%.*]], i3 undef)
-; CHECK-NEXT:    ret i3 [[R]]
+; CHECK-NEXT:    ret i3 -4
 ;
   %r = call i3 @llvm.smin.i3(i3 %x, i3 undef)
   ret i3 %r
 }
 
 define <2 x i8> @umax_undef(<2 x i8> %x) {
 ; CHECK-LABEL: @umax_undef(
-; CHECK-NEXT:    [[R:%.*]] = call <2 x i8> @llvm.umax.v2i8(<2 x i8> undef, <2 x i8> [[X:%.*]])
-; CHECK-NEXT:    ret <2 x i8> [[R]]
+; CHECK-NEXT:    ret <2 x i8> <i8 -1, i8 -1>
 ;
   %r = call <2 x i8> @llvm.umax.v2i8(<2 x i8> undef, <2 x i8> %x)
   ret <2 x i8> %r
 }
 
 define <2 x i8> @umin_undef(<2 x i8> %x) {
 ; CHECK-LABEL: @umin_undef(
-; CHECK-NEXT:    [[R:%.*]] = call <2 x i8> @llvm.umin.v2i8(<2 x i8> [[X:%.*]], <2 x i8> undef)
-; CHECK-NEXT:    ret <2 x i8> [[R]]
+; CHECK-NEXT:    ret <2 x i8> zeroinitializer
 ;
   %r = call <2 x i8> @llvm.umin.v2i8(<2 x i8> %x, <2 x i8> undef)
   ret <2 x i8> %r
 }
 
 define i8 @smax_maxval(i8 %x) {
 ; CHECK-LABEL: @smax_maxval(
 ; CHECK-NEXT:    ret i8 127

 ; CHECK-NEXT:    ret <2 x i8> zeroinitializer
 ;
   %r = call <2 x i8> @llvm.umin.v2i8(<2 x i8> %x, <2 x i8> zeroinitializer)
   ret <2 x i8> %r
 }
 
 define i8 @smax_minval(i8 %x) {
 ; CHECK-LABEL: @smax_minval(
-; CHECK-NEXT:    [[R:%.*]] = call i8 @llvm.smax.i8(i8 [[X:%.*]], i8 -128)
-; CHECK-NEXT:    ret i8 [[R]]
+; CHECK-NEXT:    ret i8 [[X:%.*]]
 ;
   %r = call i8 @llvm.smax.i8(i8 %x, i8 -128)
   ret i8 %r
 }
 
 define <2 x i8> @smax_minval_commute(<2 x i8> %x) {
 ; CHECK-LABEL: @smax_minval_commute(
-; CHECK-NEXT:    [[R:%.*]] = call <2 x i8> @llvm.smax.v2i8(<2 x i8> <i8 -128, i8 -128>, <2 x i8> [[X:%.*]])
-; CHECK-NEXT:    ret <2 x i8> [[R]]
+; CHECK-NEXT:    ret <2 x i8> [[X:%.*]]
 ;
   %r = call <2 x i8> @llvm.smax.v2i8(<2 x i8> <i8 -128, i8 -128>, <2 x i8> %x)
   ret <2 x i8> %r
 }
 
 define i8 @smin_maxval(i8 %x) {
 ; CHECK-LABEL: @smin_maxval(
-; CHECK-NEXT:    [[R:%.*]] = call i8 @llvm.smin.i8(i8 127, i8 [[X:%.*]])
-; CHECK-NEXT:    ret i8 [[R]]
+; CHECK-NEXT:    ret i8 [[X:%.*]]
 ;
   %r = call i8 @llvm.smin.i8(i8 127, i8 %x)
   ret i8 %r
 }
 
 define <2 x i8> @smin_maxval_commute(<2 x i8> %x) {
 ; CHECK-LABEL: @smin_maxval_commute(
-; CHECK-NEXT:    [[R:%.*]] = call <2 x i8> @llvm.smin.v2i8(<2 x i8> [[X:%.*]], <2 x i8> <i8 127, i8 127>)
-; CHECK-NEXT:    ret <2 x i8> [[R]]
+; CHECK-NEXT:    ret <2 x i8> [[X:%.*]]
 ;
   %r = call <2 x i8> @llvm.smin.v2i8(<2 x i8> %x, <2 x i8> <i8 127, i8 127>)
   ret <2 x i8> %r
 }
 
 define i8 @umax_minval(i8 %x) {
 ; CHECK-LABEL: @umax_minval(
-; CHECK-NEXT:    [[R:%.*]] = call i8 @llvm.umax.i8(i8 [[X:%.*]], i8 0)
-; CHECK-NEXT:    ret i8 [[R]]
+; CHECK-NEXT:    ret i8 [[X:%.*]]
 ;
   %r = call i8 @llvm.umax.i8(i8 %x, i8 0)
   ret i8 %r
 }
 
 define <2 x i8> @umax_minval_commute(<2 x i8> %x) {
 ; CHECK-LABEL: @umax_minval_commute(
-; CHECK-NEXT:    [[R:%.*]] = call <2 x i8> @llvm.umax.v2i8(<2 x i8> zeroinitializer, <2 x i8> [[X:%.*]])
-; CHECK-NEXT:    ret <2 x i8> [[R]]
+; CHECK-NEXT:    ret <2 x i8> [[X:%.*]]
 ;
   %r = call <2 x i8> @llvm.umax.v2i8(<2 x i8> zeroinitializer, <2 x i8> %x)
   ret <2 x i8> %r
 }
 
 define i8 @umin_maxval(i8 %x) {
 ; CHECK-LABEL: @umin_maxval(
-; CHECK-NEXT:    [[R:%.*]] = call i8 @llvm.umin.i8(i8 -1, i8 [[X:%.*]])
-; CHECK-NEXT:    ret i8 [[R]]
+; CHECK-NEXT:    ret i8 [[X:%.*]]
 ;
   %r = call i8 @llvm.umin.i8(i8 255, i8 %x)
   ret i8 %r
 }
 
 define <2 x i8> @umin_maxval_commute(<2 x i8> %x) {
 ; CHECK-LABEL: @umin_maxval_commute(
-; CHECK-NEXT:    [[R:%.*]] = call <2 x i8> @llvm.umin.v2i8(<2 x i8> [[X:%.*]], <2 x i8> <i8 -1, i8 -1>)
-; CHECK-NEXT:    ret <2 x i8> [[R]]
+; CHECK-NEXT:    ret <2 x i8> [[X:%.*]]
 ;
   %r = call <2 x i8> @llvm.umin.v2i8(<2 x i8> %x, <2 x i8> <i8 255, i8 255>)
   ret <2 x i8> %r
 }
 
+; TODO: Could handle partial undef.
+
 define <2 x i8> @smax_maxval_partial_undef(<2 x i8> %x) {
 ; CHECK-LABEL: @smax_maxval_partial_undef(
 ; CHECK-NEXT:    [[R:%.*]] = call <2 x i8> @llvm.smax.v2i8(<2 x i8> <i8 undef, i8 127>, <2 x i8> [[X:%.*]])
 ; CHECK-NEXT:    ret <2 x i8> [[R]]
 ;
   %r = call <2 x i8> @llvm.smax.v2i8(<2 x i8> <i8 undef, i8 127>, <2 x i8> %x)
   ret <2 x i8> %r
 }
 
+; TODO: Could handle partial undef.
+
 define <2 x i8> @smin_minval_partial_undef(<2 x i8> %x) {
 ; CHECK-LABEL: @smin_minval_partial_undef(
 ; CHECK-NEXT:    [[R:%.*]] = call <2 x i8> @llvm.smin.v2i8(<2 x i8> [[X:%.*]], <2 x i8> <i8 -128, i8 undef>)
 ; CHECK-NEXT:    ret <2 x i8> [[R]]
 ;
   %r = call <2 x i8> @llvm.smin.v2i8(<2 x i8> %x, <2 x i8> <i8 -128, i8 undef>)
   ret <2 x i8> %r
 }
 
+; TODO: Could handle partial undef.
+
 define <2 x i8> @umax_maxval_partial_undef(<2 x i8> %x) {
 ; CHECK-LABEL: @umax_maxval_partial_undef(
 ; CHECK-NEXT:    [[R:%.*]] = call <2 x i8> @llvm.umax.v2i8(<2 x i8> <i8 -1, i8 undef>, <2 x i8> [[X:%.*]])
 ; CHECK-NEXT:    ret <2 x i8> [[R]]
 ;
   %r = call <2 x i8> @llvm.umax.v2i8(<2 x i8> <i8 255, i8 undef>, <2 x i8> %x)
   ret <2 x i8> %r
 }
 
+; TODO: Could handle partial undef.
+
 define <2 x i8> @umin_minval_partial_undef(<2 x i8> %x) {
 ; CHECK-LABEL: @umin_minval_partial_undef(
 ; CHECK-NEXT:    [[R:%.*]] = call <2 x i8> @llvm.umin.v2i8(<2 x i8> [[X:%.*]], <2 x i8> <i8 undef, i8 0>)
 ; CHECK-NEXT:    ret <2 x i8> [[R]]
 ;
   %r = call <2 x i8> @llvm.umin.v2i8(<2 x i8> %x, <2 x i8> <i8 undef, i8 0>)
   ret <2 x i8> %r
 }
 
+; TODO: Could handle partial undef.
+
 define <2 x i8> @smax_minval_partial_undef(<2 x i8> %x) {
 ; CHECK-LABEL: @smax_minval_partial_undef(
 ; CHECK-NEXT:    [[R:%.*]] = call <2 x i8> @llvm.smax.v2i8(<2 x i8> <i8 undef, i8 -128>, <2 x i8> [[X:%.*]])
 ; CHECK-NEXT:    ret <2 x i8> [[R]]
 ;
   %r = call <2 x i8> @llvm.smax.v2i8(<2 x i8> <i8 undef, i8 -128>, <2 x i8> %x)
   ret <2 x i8> %r
 }
 
+; TODO: Could handle partial undef.
+
 define <2 x i8> @smin_maxval_partial_undef(<2 x i8> %x) {
 ; CHECK-LABEL: @smin_maxval_partial_undef(
 ; CHECK-NEXT:    [[R:%.*]] = call <2 x i8> @llvm.smin.v2i8(<2 x i8> [[X:%.*]], <2 x i8> <i8 undef, i8 127>)
 ; CHECK-NEXT:    ret <2 x i8> [[R]]
 ;
   %r = call <2 x i8> @llvm.smin.v2i8(<2 x i8> %x, <2 x i8> <i8 undef, i8 127>)
   ret <2 x i8> %r
 }
 
 define <2 x i8> @umax_minval_partial_undef(<2 x i8> %x) {
 ; CHECK-LABEL: @umax_minval_partial_undef(
-; CHECK-NEXT:    [[R:%.*]] = call <2 x i8> @llvm.umax.v2i8(<2 x i8> <i8 0, i8 undef>, <2 x i8> [[X:%.*]])
-; CHECK-NEXT:    ret <2 x i8> [[R]]
+; CHECK-NEXT:    ret <2 x i8> [[X:%.*]]
 ;
   %r = call <2 x i8> @llvm.umax.v2i8(<2 x i8> <i8 0, i8 undef>, <2 x i8> %x)
   ret <2 x i8> %r
 }
 
+; TODO: Could handle partial undef.
+
 define <2 x i8> @umin_maxval_partial_undef(<2 x i8> %x) {
 ; CHECK-LABEL: @umin_maxval_partial_undef(
 ; CHECK-NEXT:    [[R:%.*]] = call <2 x i8> @llvm.umin.v2i8(<2 x i8> [[X:%.*]], <2 x i8> <i8 -1, i8 undef>)
 ; CHECK-NEXT:    ret <2 x i8> [[R]]
 ;
   %r = call <2 x i8> @llvm.umin.v2i8(<2 x i8> %x, <2 x i8> <i8 255, i8 undef>)
   ret <2 x i8> %r
 }