[ConstraintElim] Add facts implied by MinMaxIntrinsic

[dtcxzyw]

Summary

Fixes https://github.com/llvm/llvm-project/issues/63896 and https://github.com/rust-lang/rust/issues/113757.
This patch adds facts implied by llvm.smin/smax/umin/umax intrinsics.

[nikic]

llvm/lib/Transforms/Scalar/ConstraintElimination.cpp

788

I don't think this is right. It does not correctly represent where the fact will apply. This should be rooted at a branch/assume, just like the normal icmp handling.

Likely the fact in the worklist should just be the icmp, and we should only handle the min/max when adding it to the constraint system.

llvm/test/Transforms/ConstraintElimination/minmax.ll

28

Needs more test coverage for different min/max and different predicates.

[fhahn]

llvm/lib/Transforms/Scalar/ConstraintElimination.cpp

788

@dtcxzyw could you add test cases that would be incorrectly simplified? Something like doing a umin in one block, then doing a check that can be simplified with the facts that get added and only later use the result of the umin in a compare.

[fhahn]

llvm/lib/Transforms/Scalar/ConstraintElimination.cpp

788

Hmm not sure if it is actually possible to show a miscompile with the above.

I think one way to handle this would be to inject I <= I->getOperand(0), I <= I->getOperand(1) as facts here.

That leaves the question on how to best synthesize such conditions here. The simplest way would be to create temporary ICMP instructions. Not sure what other people think about that though and if we need a more local/lightweight representation for conditions.

[dtcxzyw]

llvm/lib/Transforms/Scalar/ConstraintElimination.cpp

788

I think the triple (ICmpInst::Predicate Pred, Value* Lhs, Value* Rhs) is better than (ICmpInst* Inst, bool Not) to represent a fact.

[dtcxzyw]

• Rebase
• Add facts with two temporary ICmpInsts for MinMaxIntrinsic
• Add more tests with different predicates and minmax intrinsics.

[nikic]

llvm/lib/Transforms/Scalar/ConstraintElimination.cpp

788

I don't understand why we would want to inject facts at this point at all. We already have a fact for the icmp involving the min/max. Everything else can be handled when inserting that fact into the constraint system.

[dtcxzyw]

llvm/lib/Transforms/Scalar/ConstraintElimination.cpp

788

I want to simplify min/max intrinsics in ConstraintElim.

https://alive2.llvm.org/ce/z/2RQVy5

define i32 @src(i32 noundef %x, i32 noundef %y, i32 noundef %z) {
entry:
  %cmp = icmp slt i32 %x, %y
  br i1 %cmp, label %if, label %end
if:
  %max1 = call i32 @llvm.smax.i32(i32 %x, i32 %z)
  %max2 = call i32 @llvm.smax.i32(i32 %y, i32 %max1)
  ret i32 %max2
end:
  ret i32 0
}

define i32 @tgt(i32 noundef %x, i32 noundef %y, i32 noundef %z) {
entry:
  %cmp = icmp slt i32 %x, %y
  br i1 %cmp, label %if, label %end
if:
  %max1 = call i32 @llvm.smax.i32(i32 %y, i32 %z)
  ret i32 %max1
end:
  ret i32 0
}

declare i32 @llvm.smax.i32(i32, i32)

This transformation cannot be handled by InstCombine.
In this case, there is no icmp involving min/max insts.

[fhahn]

llvm/lib/Transforms/Scalar/ConstraintElimination.cpp

788

I don't understand why we would want to inject facts at this point at all. We already have a fact for the icmp involving the min/max. Everything else can be handled when inserting that fact into the constraint system.

Yep, both are possibilities. If we insert them when they are used at a compare, we would probably need to do it driven by the decomposition logic so we catch cases where the umax is used by more complex expressions. This probably will end up slightly more complicated code-wise, but the advantage would be that we only need to add the additional facts when they are actually used.

Queuing them here directly is probably simpler overall in terms of code at the cost of adding them unnecessarily in some cases . When we add the facts when handling the compares, we may add the same facts multiple times if the min/max is used in multiple places on the other hand.

I think both approaches are fine, it would be good to see if they can be added elegantly directly when simplifying the compares

[nikic]

llvm/lib/Transforms/Scalar/ConstraintElimination.cpp

788

I want to simplify min/max intrinsics in ConstraintElim.

This seems to be orthogonal to the current patch. This would require inserting a check for the min/max, not a fact.

Simplifying the min/max itself should be pretty straightforward, with the same basic approach as we have for with.overflow intrinsics.

[dtcxzyw]

llvm/lib/Transforms/Scalar/ConstraintElimination.cpp

788

In the above case, we will miss this optimization when just adding facts implied by min/max iff they are used by icmp.

[nikic]

llvm/lib/Transforms/Scalar/ConstraintElimination.cpp

788

Ugh, I completely misunderstood what this patch is doing. Ignore everything I've said above.

I assume the reason why we can add the fact at the "wrong" position (start of the block) is that it only becomes meaningful once the value is defined.

My remaining question here would be whether we can handle min/max similarly to assume, i.e. just push the min/max instruction as the "fact" and then decompose it into the two conditions as part of eliminateConstraints(). At that point we no longer need actual icmp instructions.

[dtcxzyw]

llvm/lib/Transforms/Scalar/ConstraintElimination.cpp

788

That is what this patch used to do.
It is worth noting that we still need temporary icmp insts to materialize assumptions for reproduction.

[nikic]

llvm/lib/Transforms/Scalar/ConstraintElimination.cpp

788

That is what this patch used to do.

Indeed! I think your first version was the right way to do this. Sorry for all the confusion I caused.

It is worth noting that we still need temporary icmp insts to materialize assumptions for reproduction.

It seems like this should be easy to avoid by storing Pred + LHS + RHS in ReproducerEntry instead of the CmpInst. The reproducer generation doesn't need an actual instruction (this would allow us to get rid of the awkward IsNot flag as well).

[fhahn]

llvm/lib/Transforms/Scalar/ConstraintElimination.cpp

788

It seems like this should be easy to avoid by storing Pred + LHS + RHS in ReproducerEntry instead of the CmpInst. The reproducer generation doesn't need an actual instruction (this would allow us to get rid of the awkward IsNot flag as well).

Would probably be good to do this cleanup separately first.

llvm/test/Transforms/ConstraintElimination/minmax.ll

2

could you add the tests as a separate patch and then only include the improved check lines in this patch?

17

would be good to also have tests with different second args and conditions also checking the second arg and perhaps some tests with more complicated expressions using the result of the umax (e.g. use it in an add that's then compared)

22

it would probably be good to have tests with signed predicates and other combinations as well

[dtcxzyw]

llvm/lib/Transforms/Scalar/ConstraintElimination.cpp

788

Candidate patch D155782

[dtcxzyw]

• Rebase on the top of D155853 and D155782
• Avoid creating temporary ICmpInsts

[dtcxzyw]

Fix diff to get the full context

[dtcxzyw]

llvm/test/Transforms/ConstraintElimination/minmax.ll

2

Posted as D155853

[nikic]

Implementation looks good to me.

llvm/lib/Transforms/Scalar/ConstraintElimination.cpp

1380

Unnecessary braces

llvm/test/Transforms/ConstraintElimination/minmax.ll

32–33

These tests could be more compact by testing both ugt and uge inside the if. The standard pattern in ConstraintElim tests seems to be to combine multiple conditions with xor i1.

364

I think you're current missing a test for mixing signed and unsigned predicates.

I'd also suggesting to test something like x pred min(x, y), where there is no branch involved, and you're just directly using the fact implied by the min/max.

[dtcxzyw]

Address comments

[fhahn]

LGTM, thanks! Please make sure there also are tests that use mixed signed & unsigned predicates as per @nikic's comment. I could't spot one in the latest version but maybe I missed it.

[dtcxzyw]

In D155412#4523259, @fhahn wrote:

LGTM, thanks! Please make sure there also are tests that use mixed signed & unsigned predicates as per @nikic's comment. I could't spot one in the latest version but maybe I missed it.

I think you're current missing a test for mixing signed and unsigned predicates.

in function smin_ule_mixed at line 255

I'd also suggesting to test something like x pred min(x, y), where there is no branch involved, and you're just directly using the fact implied by the min/max.

in function smin_branchless at line 319

llvm/test/Transforms/ConstraintElimination/minmax.ll

364

I think you're current missing a test for mixing signed and unsigned predicates.

I'd also suggesting to test something like x pred min(x, y), where there is no branch involved, and you're just directly using the fact implied by the min/max.

llvm/lib/Transforms/Scalar/ConstraintElimination.cpp

for (Instruction &I : BB) {
     }
 
     if (match(&I, m_Intrinsic<Intrinsic::ssub_with_overflow>())) {
       WorkList.push_back(
           FactOrCheck::getCheck(DT.getNode(&BB), cast<CallInst>(&I)));
       continue;
     }
 
+    if (isa<MinMaxIntrinsic>(&I)) {
+      WorkList.push_back(FactOrCheck::getFact(DT.getNode(&BB), &I));
+      continue;
+    }
+
     Value *Cond;
     // For now, just handle assumes with a single compare as condition.
     if (match(&I, m_Intrinsic<Intrinsic::assume>(m_Value(Cond))) &&
         isa<ICmpInst>(Cond)) {
       if (GuaranteedToExecute) {
         // The assume is guaranteed to execute when BB is entered, hence Cond
         // holds on entry to BB.
         WorkList.emplace_back(FactOrCheck::getFact(DT.getNode(I.getParent()),
if (CB.isCheck()) {
                                              ReproducerCondStack, DFSInStack);
         }
         Changed |= Simplified;
       }
       continue;
     }
 
     LLVM_DEBUG(dbgs() << "fact to add to the system: " << *CB.Inst << "\n");
-    ICmpInst::Predicate Pred;
-    Value *A, *B;
-    Value *Cmp = CB.Inst;
-    match(Cmp, m_Intrinsic<Intrinsic::assume>(m_Value(Cmp)));
-    if (match(Cmp, m_ICmp(Pred, m_Value(A), m_Value(B)))) {
+    auto AddFact = [&](CmpInst::Predicate Pred, Value *A, Value *B) {
       if (Info.getCS(CmpInst::isSigned(Pred)).size() > MaxRows) {
         LLVM_DEBUG(
             dbgs()
             << "Skip adding constraint because system has too many rows.\n");
-        continue;
+        return;
       }
 
-      // Use the inverse predicate if required.
-      if (CB.Not)
-        Pred = CmpInst::getInversePredicate(Pred);
-
       Info.addFact(Pred, A, B, CB.NumIn, CB.NumOut, DFSInStack);
       if (ReproducerModule && DFSInStack.size() > ReproducerCondStack.size())
         ReproducerCondStack.emplace_back(Pred, A, B);
 
       Info.transferToOtherSystem(Pred, A, B, CB.NumIn, CB.NumOut, DFSInStack);
       if (ReproducerModule && DFSInStack.size() > ReproducerCondStack.size()) {
         // Add dummy entries to ReproducerCondStack to keep it in sync with
         // DFSInStack.
         for (unsigned I = 0,
                       E = (DFSInStack.size() - ReproducerCondStack.size());
              I < E; ++I) {
           ReproducerCondStack.emplace_back(ICmpInst::BAD_ICMP_PREDICATE,
                                            nullptr, nullptr);
         }
       }
+    };
+
+    ICmpInst::Predicate Pred;
+    if (auto *MinMax = dyn_cast<MinMaxIntrinsic>(CB.Inst)) {
+      Pred = ICmpInst::getNonStrictPredicate(MinMax->getPredicate());
+      AddFact(Pred, MinMax, MinMax->getLHS());
+      AddFact(Pred, MinMax, MinMax->getRHS());
+      continue;
+    }
+
+    Value *A, *B;
+    Value *Cmp = CB.Inst;
+    match(Cmp, m_Intrinsic<Intrinsic::assume>(m_Value(Cmp)));
+    if (match(Cmp, m_ICmp(Pred, m_Value(A), m_Value(B)))) {
+      // Use the inverse predicate if required.
+      if (CB.Not)
+        Pred = CmpInst::getInversePredicate(Pred);
+
+      AddFact(Pred, A, B);
     }
   }
 
   if (ReproducerModule && !ReproducerModule->functions().empty()) {
     std::string S;
     raw_string_ostream StringS(S);
     ReproducerModule->print(StringS, nullptr);
     StringS.flush();

llvm/test/Transforms/ConstraintElimination/minmax.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 2
 ; RUN: opt -passes=constraint-elimination -S %s | FileCheck %s
 
 ; Test from PR63896
 define i1 @umax_ugt(i32 %x, i32 %y) {
 ; CHECK-LABEL: define i1 @umax_ugt
 ; CHECK-SAME: (i32 [[X:%.*]], i32 [[Y:%.*]]) {
 ; CHECK-NEXT:    [[MAX:%.*]] = call i32 @llvm.umax.i32(i32 [[X]], i32 1)
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp ugt i32 [[Y]], [[MAX]]
 ; CHECK-NEXT:    br i1 [[CMP]], label [[IF:%.*]], label [[END:%.*]]
 ; CHECK:       if:
 ; CHECK-NEXT:    [[CMP2:%.*]] = icmp ugt i32 [[Y]], [[X]]
 ; CHECK-NEXT:    [[CMP3:%.*]] = icmp uge i32 [[Y]], [[X]]
-; CHECK-NEXT:    [[RET:%.*]] = xor i1 [[CMP2]], [[CMP3]]
+; CHECK-NEXT:    [[RET:%.*]] = xor i1 true, true
 ; CHECK-NEXT:    ret i1 [[RET]]
 ; CHECK:       end:
 ; CHECK-NEXT:    ret i1 false
 ;
   %max = call i32 @llvm.umax.i32(i32 %x, i32 1)
   %cmp = icmp ugt i32 %y, %max
   br i1 %cmp, label %if, label %end
 
 if:
   %cmp2 = icmp ugt i32 %y, %x
   %cmp3 = icmp uge i32 %y, %x
   %ret = xor i1 %cmp2, %cmp3
   ret i1 %ret
 
 end:
   ret i1 false
 }
 
 define i1 @umax_uge(i32 %x, i32 %y) {
 ; CHECK-LABEL: define i1 @umax_uge
 ; CHECK-SAME: (i32 [[X:%.*]], i32 [[Y:%.*]]) {
 ; CHECK-NEXT:    [[MAX:%.*]] = call i32 @llvm.umax.i32(i32 [[X]], i32 1)
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp uge i32 [[Y]], [[MAX]]
 ; CHECK-NEXT:    br i1 [[CMP]], label [[IF:%.*]], label [[END:%.*]]
 ; CHECK:       if:
 ; CHECK-NEXT:    [[CMP2:%.*]] = icmp ugt i32 [[Y]], [[X]]
 ; CHECK-NEXT:    [[CMP3:%.*]] = icmp uge i32 [[Y]], [[X]]
-; CHECK-NEXT:    [[RET:%.*]] = xor i1 [[CMP2]], [[CMP3]]
+; CHECK-NEXT:    [[RET:%.*]] = xor i1 [[CMP2]], true
 ; CHECK-NEXT:    ret i1 [[RET]]
 ; CHECK:       end:
 ; CHECK-NEXT:    ret i1 false
 ;
   %max = call i32 @llvm.umax.i32(i32 %x, i32 1)
   %cmp = icmp uge i32 %y, %max
   br i1 %cmp, label %if, label %end
 

 ; CHECK-LABEL: define i1 @umin_ult
 ; CHECK-SAME: (i32 [[X:%.*]], i32 [[Y:%.*]]) {
 ; CHECK-NEXT:    [[MIN:%.*]] = call i32 @llvm.umin.i32(i32 [[X]], i32 1)
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp ult i32 [[Y]], [[MIN]]
 ; CHECK-NEXT:    br i1 [[CMP]], label [[IF:%.*]], label [[END:%.*]]
 ; CHECK:       if:
 ; CHECK-NEXT:    [[CMP2:%.*]] = icmp ult i32 [[Y]], [[X]]
 ; CHECK-NEXT:    [[CMP3:%.*]] = icmp ule i32 [[Y]], [[X]]
-; CHECK-NEXT:    [[RET:%.*]] = xor i1 [[CMP2]], [[CMP3]]
+; CHECK-NEXT:    [[RET:%.*]] = xor i1 true, true
 ; CHECK-NEXT:    ret i1 [[RET]]
 ; CHECK:       end:
 ; CHECK-NEXT:    ret i1 false
 ;
   %min = call i32 @llvm.umin.i32(i32 %x, i32 1)
   %cmp = icmp ult i32 %y, %min
   br i1 %cmp, label %if, label %end
 

 ; CHECK-LABEL: define i1 @umin_ule
 ; CHECK-SAME: (i32 [[X:%.*]], i32 [[Y:%.*]]) {
 ; CHECK-NEXT:    [[MIN:%.*]] = call i32 @llvm.umin.i32(i32 [[X]], i32 1)
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp ule i32 [[Y]], [[MIN]]
 ; CHECK-NEXT:    br i1 [[CMP]], label [[IF:%.*]], label [[END:%.*]]
 ; CHECK:       if:
 ; CHECK-NEXT:    [[CMP2:%.*]] = icmp ult i32 [[Y]], [[X]]
 ; CHECK-NEXT:    [[CMP3:%.*]] = icmp ule i32 [[Y]], [[X]]
-; CHECK-NEXT:    [[RET:%.*]] = xor i1 [[CMP2]], [[CMP3]]
+; CHECK-NEXT:    [[RET:%.*]] = xor i1 [[CMP2]], true
 ; CHECK-NEXT:    ret i1 [[RET]]
 ; CHECK:       end:
 ; CHECK-NEXT:    ret i1 false
 ;
   %min = call i32 @llvm.umin.i32(i32 %x, i32 1)
   %cmp = icmp ule i32 %y, %min
   br i1 %cmp, label %if, label %end
 

 ; CHECK-LABEL: define i1 @smax_sgt
 ; CHECK-SAME: (i32 [[X:%.*]], i32 [[Y:%.*]]) {
 ; CHECK-NEXT:    [[MAX:%.*]] = call i32 @llvm.smax.i32(i32 [[X]], i32 1)
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt i32 [[Y]], [[MAX]]
 ; CHECK-NEXT:    br i1 [[CMP]], label [[IF:%.*]], label [[END:%.*]]
 ; CHECK:       if:
 ; CHECK-NEXT:    [[CMP2:%.*]] = icmp sgt i32 [[Y]], [[X]]
 ; CHECK-NEXT:    [[CMP3:%.*]] = icmp sge i32 [[Y]], [[X]]
-; CHECK-NEXT:    [[RET:%.*]] = xor i1 [[CMP2]], [[CMP3]]
+; CHECK-NEXT:    [[RET:%.*]] = xor i1 true, true
 ; CHECK-NEXT:    ret i1 [[RET]]
 ; CHECK:       end:
 ; CHECK-NEXT:    ret i1 false
 ;
   %max = call i32 @llvm.smax.i32(i32 %x, i32 1)
   %cmp = icmp sgt i32 %y, %max
   br i1 %cmp, label %if, label %end
 

 ; CHECK-LABEL: define i1 @smax_sge
 ; CHECK-SAME: (i32 [[X:%.*]], i32 [[Y:%.*]]) {
 ; CHECK-NEXT:    [[MAX:%.*]] = call i32 @llvm.smax.i32(i32 [[X]], i32 1)
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp sge i32 [[Y]], [[MAX]]
 ; CHECK-NEXT:    br i1 [[CMP]], label [[IF:%.*]], label [[END:%.*]]
 ; CHECK:       if:
 ; CHECK-NEXT:    [[CMP2:%.*]] = icmp sgt i32 [[Y]], [[X]]
 ; CHECK-NEXT:    [[CMP3:%.*]] = icmp sge i32 [[Y]], [[X]]
-; CHECK-NEXT:    [[RET:%.*]] = xor i1 [[CMP2]], [[CMP3]]
+; CHECK-NEXT:    [[RET:%.*]] = xor i1 [[CMP2]], true
 ; CHECK-NEXT:    ret i1 [[RET]]
 ; CHECK:       end:
 ; CHECK-NEXT:    ret i1 false
 ;
   %max = call i32 @llvm.smax.i32(i32 %x, i32 1)
   %cmp = icmp sge i32 %y, %max
   br i1 %cmp, label %if, label %end
 

 ; CHECK-LABEL: define i1 @smin_slt
 ; CHECK-SAME: (i32 [[X:%.*]], i32 [[Y:%.*]]) {
 ; CHECK-NEXT:    [[MIN:%.*]] = call i32 @llvm.smin.i32(i32 [[X]], i32 1)
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i32 [[Y]], [[MIN]]
 ; CHECK-NEXT:    br i1 [[CMP]], label [[IF:%.*]], label [[END:%.*]]
 ; CHECK:       if:
 ; CHECK-NEXT:    [[CMP2:%.*]] = icmp slt i32 [[Y]], [[X]]
 ; CHECK-NEXT:    [[CMP3:%.*]] = icmp sle i32 [[Y]], [[X]]
-; CHECK-NEXT:    [[RET:%.*]] = xor i1 [[CMP2]], [[CMP3]]
+; CHECK-NEXT:    [[RET:%.*]] = xor i1 true, true
 ; CHECK-NEXT:    ret i1 [[RET]]
 ; CHECK:       end:
 ; CHECK-NEXT:    ret i1 false
 ;
   %min = call i32 @llvm.smin.i32(i32 %x, i32 1)
   %cmp = icmp slt i32 %y, %min
   br i1 %cmp, label %if, label %end
 

 ; CHECK-LABEL: define i1 @smin_sle
 ; CHECK-SAME: (i32 [[X:%.*]], i32 [[Y:%.*]]) {
 ; CHECK-NEXT:    [[MIN:%.*]] = call i32 @llvm.smin.i32(i32 [[X]], i32 1)
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp sle i32 [[Y]], [[MIN]]
 ; CHECK-NEXT:    br i1 [[CMP]], label [[IF:%.*]], label [[END:%.*]]
 ; CHECK:       if:
 ; CHECK-NEXT:    [[CMP2:%.*]] = icmp slt i32 [[Y]], [[X]]
 ; CHECK-NEXT:    [[CMP3:%.*]] = icmp sle i32 [[Y]], [[X]]
-; CHECK-NEXT:    [[RET:%.*]] = xor i1 [[CMP2]], [[CMP3]]
+; CHECK-NEXT:    [[RET:%.*]] = xor i1 [[CMP2]], true
 ; CHECK-NEXT:    ret i1 [[RET]]
 ; CHECK:       end:
 ; CHECK-NEXT:    ret i1 false
 ;
   %min = call i32 @llvm.smin.i32(i32 %x, i32 1)
   %cmp = icmp sle i32 %y, %min
   br i1 %cmp, label %if, label %end
 

 ; CHECK-LABEL: define i1 @umax_uge_ugt_with_add_nuw
 ; CHECK-SAME: (i32 [[X:%.*]], i32 [[Y:%.*]]) {
 ; CHECK-NEXT:    [[MAX:%.*]] = call i32 @llvm.umax.i32(i32 [[X]], i32 1)
 ; CHECK-NEXT:    [[SUM:%.*]] = add nuw i32 [[MAX]], 1
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp uge i32 [[Y]], [[SUM]]
 ; CHECK-NEXT:    br i1 [[CMP]], label [[IF:%.*]], label [[END:%.*]]
 ; CHECK:       if:
 ; CHECK-NEXT:    [[CMP2:%.*]] = icmp ugt i32 [[Y]], [[X]]
-; CHECK-NEXT:    ret i1 [[CMP2]]
+; CHECK-NEXT:    ret i1 true
 ; CHECK:       end:
 ; CHECK-NEXT:    ret i1 false
 ;
   %max = call i32 @llvm.umax.i32(i32 %x, i32 1)
   %sum = add nuw i32 %max, 1
   %cmp = icmp uge i32 %y, %sum
   br i1 %cmp, label %if, label %end
 

 ; CHECK-LABEL: define i1 @umax_ugt_ugt_both
 ; CHECK-SAME: (i32 [[X:%.*]], i32 [[Y:%.*]], i32 [[Z:%.*]]) {
 ; CHECK-NEXT:    [[MAX:%.*]] = call i32 @llvm.umax.i32(i32 [[X]], i32 [[Y]])
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp ugt i32 [[Z]], [[MAX]]
 ; CHECK-NEXT:    br i1 [[CMP]], label [[IF:%.*]], label [[END:%.*]]
 ; CHECK:       if:
 ; CHECK-NEXT:    [[CMP2:%.*]] = icmp ugt i32 [[Z]], [[X]]
 ; CHECK-NEXT:    [[CMP3:%.*]] = icmp ugt i32 [[Z]], [[Y]]
-; CHECK-NEXT:    [[AND:%.*]] = xor i1 [[CMP2]], [[CMP3]]
+; CHECK-NEXT:    [[AND:%.*]] = xor i1 true, true
 ; CHECK-NEXT:    ret i1 [[AND]]
 ; CHECK:       end:
 ; CHECK-NEXT:    ret i1 false
 ;
   %max = call i32 @llvm.umax.i32(i32 %x, i32 %y)
   %cmp = icmp ugt i32 %z, %max
   br i1 %cmp, label %if, label %end
 

 
 define i1 @smin_branchless(i32 %x, i32 %y) {
 ; CHECK-LABEL: define i1 @smin_branchless
 ; CHECK-SAME: (i32 [[X:%.*]], i32 [[Y:%.*]]) {
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[MIN:%.*]] = call i32 @llvm.smin.i32(i32 [[X]], i32 [[Y]])
 ; CHECK-NEXT:    [[CMP1:%.*]] = icmp sle i32 [[MIN]], [[X]]
 ; CHECK-NEXT:    [[CMP2:%.*]] = icmp sgt i32 [[MIN]], [[X]]
-; CHECK-NEXT:    [[RET:%.*]] = xor i1 [[CMP1]], [[CMP2]]
+; CHECK-NEXT:    [[RET:%.*]] = xor i1 true, false
 ; CHECK-NEXT:    ret i1 [[RET]]
 ;
 entry:
   %min = call i32 @llvm.smin.i32(i32 %x, i32 %y)
   %cmp1 = icmp sle i32 %min, %x
   %cmp2 = icmp sgt i32 %min, %x
   %ret = xor i1 %cmp1, %cmp2
   ret i1 %ret
if:
   ret i32 %max2
 end:
   ret i32 0
 }
 
 declare i32 @llvm.smin.i32(i32, i32)
 declare i32 @llvm.smax.i32(i32, i32)
 declare i32 @llvm.umin.i32(i32, i32)
 declare i32 @llvm.umax.i32(i32, i32)