[ConstraintElim] Remove dead compares after simplification.

[fhahn]

Summary

Remove compares after replacing all uses. Cleaning dead compares can
enable additional simplifications when adjusting the position of the
pass slightly. In particular, it seems like the additional dead
instructions may prevent SimplifyCFG performing some folds.

[nikic]

LGTM

As a possible followup, we could use RecursivelyDeleteTriviallyDeadInstructions to also remove the instructions feeding the icmp.

[fhahn]

In D158760#4614654, @nikic wrote:

LGTM

As a possible followup, we could use RecursivelyDeleteTriviallyDeadInstructions to also remove the instructions feeding the icmp.

Can do!

llvm/lib/Transforms/Scalar/ConstraintElimination.cpp

static std::optional<bool> checkCondition(CmpInst *Cmp, ConstraintInfo &Info,
   }
 
   return std::nullopt;
 }
 
 static bool checkAndReplaceCondition(
     CmpInst *Cmp, ConstraintInfo &Info, unsigned NumIn, unsigned NumOut,
     Instruction *ContextInst, Module *ReproducerModule,
-    ArrayRef<ReproducerEntry> ReproducerCondStack, DominatorTree &DT) {
+    ArrayRef<ReproducerEntry> ReproducerCondStack, DominatorTree &DT,
+    SmallVectorImpl<Instruction *> &ToRemove) {
   auto ReplaceCmpWithConstant = [&](CmpInst *Cmp, bool IsTrue) {
     generateReproducer(Cmp, ReproducerModule, ReproducerCondStack, Info, DT);
     Constant *ConstantC = ConstantInt::getBool(
         CmpInst::makeCmpResultType(Cmp->getType()), IsTrue);
     Cmp->replaceUsesWithIf(ConstantC, [&DT, NumIn, NumOut,
                                        ContextInst](Use &U) {
       auto *UserI = getContextInstForUse(U);
       auto *DTN = DT.getNode(UserI->getParent());
       if (!DTN || DTN->getDFSNumIn() < NumIn || DTN->getDFSNumOut() > NumOut)
         return false;
       if (UserI->getParent() == ContextInst->getParent() &&
           UserI->comesBefore(ContextInst))
         return false;
 
       // Conditions in an assume trivially simplify to true. Skip uses
       // in assume calls to not destroy the available information.
       auto *II = dyn_cast<IntrinsicInst>(U.getUser());
       return !II || II->getIntrinsicID() != Intrinsic::assume;
     });
     NumCondsRemoved++;
+    if (Cmp->use_empty())
+      ToRemove.push_back(Cmp);
     return true;
   };
 
   if (auto ImpliedCondition =
           checkCondition(Cmp, Info, NumIn, NumOut, ContextInst))
     return ReplaceCmpWithConstant(Cmp, *ImpliedCondition);
   return false;
 }
if (CB.isCheck()) {
       if (!Inst)
         continue;
       LLVM_DEBUG(dbgs() << "condition to simplify: " << *Inst << "\n");
       if (auto *II = dyn_cast<WithOverflowInst>(Inst)) {
         Changed |= tryToSimplifyOverflowMath(II, Info, ToRemove);
       } else if (auto *Cmp = dyn_cast<ICmpInst>(Inst)) {
         bool Simplified = checkAndReplaceCondition(
             Cmp, Info, CB.NumIn, CB.NumOut, CB.getContextInst(),
-            ReproducerModule.get(), ReproducerCondStack, S.DT);
+            ReproducerModule.get(), ReproducerCondStack, S.DT, ToRemove);
         if (!Simplified && match(CB.getContextInst(),
                                  m_LogicalAnd(m_Value(), m_Specific(Inst)))) {
           Simplified =
               checkAndSecondOpImpliedByFirst(CB, Info, ReproducerModule.get(),
                                              ReproducerCondStack, DFSInStack);
         }
         Changed |= Simplified;
       }

llvm/test/Transforms/ConstraintElimination/add-nsw.ll

 ; CHECK-LABEL: @test.not.sge.slt(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[ADD_PTR_I:%.*]] = add nsw i8 [[START:%.*]], 3
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp sge i8 [[ADD_PTR_I]], [[HIGH:%.*]]
 ; CHECK-NEXT:    br i1 [[C_1]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
 ; CHECK:       if.then:
 ; CHECK-NEXT:    ret void
 ; CHECK:       if.end:
-; CHECK-NEXT:    [[T_0:%.*]] = icmp slt i8 [[START]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    [[START_1:%.*]] = add nsw i8 [[START]], 1
-; CHECK-NEXT:    [[T_1:%.*]] = icmp slt i8 [[START_1]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    [[START_2:%.*]] = add nsw i8 [[START]], 2
-; CHECK-NEXT:    [[T_2:%.*]] = icmp slt i8 [[START_2]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    [[START_3:%.*]] = add nsw i8 [[START]], 3
-; CHECK-NEXT:    [[T_3:%.*]] = icmp slt i8 [[START_3]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    [[START_4:%.*]] = add nsw i8 [[START]], 4
 ; CHECK-NEXT:    [[C_4:%.*]] = icmp slt i8 [[START_4]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 [[C_4]])
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %add.ptr.i = add nsw i8 %start, 3

 ; CHECK-NEXT:    br i1 [[AND_0]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
 ; CHECK:       if.then:
 ; CHECK-NEXT:    [[C_2:%.*]] = icmp sge i8 [[A]], 0
 ; CHECK-NEXT:    [[C_3:%.*]] = icmp sge i8 [[B]], 0
 ; CHECK-NEXT:    [[AND_1:%.*]] = and i1 [[C_2]], [[C_3]]
 ; CHECK-NEXT:    br i1 [[AND_1]], label [[IF_THEN_2:%.*]], label [[IF_END]]
 ; CHECK:       if.then.2:
 ; CHECK-NEXT:    [[ADD_0:%.*]] = add nsw i8 [[A]], [[B]]
-; CHECK-NEXT:    [[T_0:%.*]] = icmp sge i8 [[ADD_0]], [[C]]
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    [[ADD_1:%.*]] = add nsw i8 [[A]], [[A]]
-; CHECK-NEXT:    [[T_1:%.*]] = icmp sge i8 [[ADD_0]], [[C]]
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    [[ADD_2:%.*]] = add nsw i8 [[A]], [[D:%.*]]
 ; CHECK-NEXT:    [[C_4:%.*]] = icmp sge i8 [[ADD_2]], [[C]]
 ; CHECK-NEXT:    call void @use(i1 [[C_4]])
 ; CHECK-NEXT:    ret void
 ; CHECK:       if.end:
 ; CHECK-NEXT:    ret void
 ;

 ; CHECK-NEXT:    call void @use(i1 [[C_2]])
 ; CHECK-NEXT:    [[START_1:%.*]] = add nsw i8 [[START]], 1
 ; CHECK-NEXT:    [[C_3:%.*]] = icmp slt i8 [[START_1]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 [[C_3]])
 ; CHECK-NEXT:    [[START_2:%.*]] = add nsw i8 [[START]], -2
 ; CHECK-NEXT:    [[C_4:%.*]] = icmp slt i8 [[START_2]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 [[C_4]])
 ; CHECK-NEXT:    [[START_3:%.*]] = add nsw i8 [[START]], -3
-; CHECK-NEXT:    [[T_1:%.*]] = icmp slt i8 [[START_3]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    [[START_4:%.*]] = add nsw i8 [[START]], -4
-; CHECK-NEXT:    [[T_2:%.*]] = icmp slt i8 [[START_4]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %add.ptr.i = add nsw i8 %start, -3
   %c.1 = icmp slt i8 %add.ptr.i, %high
   call void @llvm.assume(i1 %c.1)
   %c.2 = icmp slt i8 %start, %high

 define i1 @test_ult_add_nsw_pos_1(i8 %start, i8 %high) {
 ; CHECK-LABEL: @test_ult_add_nsw_pos_1(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[HIGH_EXT:%.*]] = zext i8 [[HIGH:%.*]] to i16
 ; CHECK-NEXT:    [[START_EXT:%.*]] = zext i8 [[START:%.*]] to i16
 ; CHECK-NEXT:    [[ADD_EXT:%.*]] = add nsw i16 [[START_EXT]], 3
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ult i16 [[ADD_EXT]], [[HIGH_EXT]]
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C_1]])
-; CHECK-NEXT:    [[T:%.*]] = icmp ult i16 [[START_EXT]], [[HIGH_EXT]]
 ; CHECK-NEXT:    ret i1 true
 ;
 entry:
   %high.ext = zext i8 %high to i16
   %start.ext = zext i8 %start to i16
   %add.ext = add nsw i16 %start.ext, 3
   %c.1 = icmp ult i16 %add.ext, %high.ext
   call void @llvm.assume(i1 %c.1)
 
   %t = icmp ult i16 %start.ext, %high.ext
   ret i1 %t
 }
 
 define i1 @test_ult_add_nsw_pos_1_assume_pos(i8 %start, i8 %high) {
 ; CHECK-LABEL: @test_ult_add_nsw_pos_1_assume_pos(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[START_POS:%.*]] = icmp sge i8 [[START:%.*]], 0
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[START_POS]])
 ; CHECK-NEXT:    [[ADD:%.*]] = add nsw i8 [[START]], 3
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ult i8 [[ADD]], [[HIGH:%.*]]
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C_1]])
-; CHECK-NEXT:    [[T:%.*]] = icmp ult i8 [[START]], [[HIGH]]
 ; CHECK-NEXT:    ret i1 true
 ;
 entry:
   %start.pos = icmp sge i8 %start, 0
   call void @llvm.assume(i1 %start.pos)
   %add = add nsw i8 %start, 3
   %c.1 = icmp ult i8 %add, %high
   call void @llvm.assume(i1 %c.1)

 define i1 @test_ult_add_nsw_pos_1_cmp_no_ext(i8 %start, i8 %high) {
 ; CHECK-LABEL: @test_ult_add_nsw_pos_1_cmp_no_ext(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[HIGH_EXT:%.*]] = zext i8 [[HIGH:%.*]] to i16
 ; CHECK-NEXT:    [[START_EXT:%.*]] = zext i8 [[START:%.*]] to i16
 ; CHECK-NEXT:    [[ADD_EXT:%.*]] = add nsw i16 [[START_EXT]], 3
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ult i16 [[ADD_EXT]], [[HIGH_EXT]]
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C_1]])
-; CHECK-NEXT:    [[T:%.*]] = icmp ult i8 [[START]], [[HIGH]]
 ; CHECK-NEXT:    ret i1 true
 ;
 entry:
   %high.ext = zext i8 %high to i16
   %start.ext = zext i8 %start to i16
   %add.ext = add nsw i16 %start.ext, 3
   %c.1 = icmp ult i16 %add.ext, %high.ext
   call void @llvm.assume(i1 %c.1)
 
   %t = icmp ult i8 %start, %high
   ret i1 %t
 }
 
 define i1 @test_ult_add_nsw_pos_2(i8 %start, i8 %high) {
 ; CHECK-LABEL: @test_ult_add_nsw_pos_2(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[HIGH_EXT:%.*]] = zext i8 [[HIGH:%.*]] to i16
 ; CHECK-NEXT:    [[START_EXT:%.*]] = zext i8 [[START:%.*]] to i16
 ; CHECK-NEXT:    [[ADD_EXT:%.*]] = add nsw i16 [[START_EXT]], 3
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ult i16 [[ADD_EXT]], [[HIGH_EXT]]
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C_1]])
-; CHECK-NEXT:    [[F:%.*]] = icmp uge i16 [[START_EXT]], [[HIGH_EXT]]
 ; CHECK-NEXT:    ret i1 false
 ;
 entry:
   %high.ext = zext i8 %high to i16
   %start.ext = zext i8 %start to i16
   %add.ext = add nsw i16 %start.ext, 3
   %c.1 = icmp ult i16 %add.ext, %high.ext
   call void @llvm.assume(i1 %c.1)
 
   %f = icmp uge i16 %start.ext, %high.ext
   ret i1 %f
 }
 
 define i1 @test_ult_add_nsw_pos_2_assume_pos(i8 %start, i8 %high) {
 ; CHECK-LABEL: @test_ult_add_nsw_pos_2_assume_pos(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[START_POS:%.*]] = icmp sge i8 [[START:%.*]], 0
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[START_POS]])
 ; CHECK-NEXT:    [[ADD:%.*]] = add nsw i8 [[START]], 3
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ult i8 [[ADD]], [[HIGH:%.*]]
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C_1]])
-; CHECK-NEXT:    [[F:%.*]] = icmp uge i8 [[START]], [[HIGH]]
 ; CHECK-NEXT:    ret i1 false
 ;
 entry:
   %start.pos = icmp sge i8 %start, 0
   call void @llvm.assume(i1 %start.pos)
   %add = add nsw i8 %start, 3
   %c.1 = icmp ult i8 %add, %high
   call void @llvm.assume(i1 %c.1)
 
   %f = icmp uge i8 %start, %high
   ret i1 %f
 }
 
 define i1 @test_ult_add_nsw_pos_2_cmp_no_ext(i8 %start, i8 %high) {
 ; CHECK-LABEL: @test_ult_add_nsw_pos_2_cmp_no_ext(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[HIGH_EXT:%.*]] = zext i8 [[HIGH:%.*]] to i16
 ; CHECK-NEXT:    [[START_EXT:%.*]] = zext i8 [[START:%.*]] to i16
 ; CHECK-NEXT:    [[ADD_EXT:%.*]] = add nsw i16 [[START_EXT]], 3
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ult i16 [[ADD_EXT]], [[HIGH_EXT]]
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C_1]])
-; CHECK-NEXT:    [[C:%.*]] = icmp uge i8 [[START]], [[HIGH]]
 ; CHECK-NEXT:    ret i1 false
 ;
 entry:
   %high.ext = zext i8 %high to i16
   %start.ext = zext i8 %start to i16
   %add.ext = add nsw i16 %start.ext, 3
   %c.1 = icmp ult i16 %add.ext, %high.ext
   call void @llvm.assume(i1 %c.1)

 ; CHECK-LABEL: @test_ult_add_nsw_pos_4(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[HIGH_EXT:%.*]] = zext i8 [[HIGH:%.*]] to i16
 ; CHECK-NEXT:    [[START_EXT:%.*]] = zext i8 [[START:%.*]] to i16
 ; CHECK-NEXT:    [[ADD_EXT:%.*]] = add nsw i16 [[START_EXT]], 3
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ult i16 [[ADD_EXT]], [[HIGH_EXT]]
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C_1]])
 ; CHECK-NEXT:    [[ADD_2:%.*]] = add nsw i16 [[START_EXT]], 2
-; CHECK-NEXT:    [[C:%.*]] = icmp ult i16 [[ADD_2]], [[HIGH_EXT]]
 ; CHECK-NEXT:    ret i1 true
 ;
 entry:
   %high.ext = zext i8 %high to i16
   %start.ext = zext i8 %start to i16
   %add.ext = add nsw i16 %start.ext, 3
   %c.1 = icmp ult i16 %add.ext, %high.ext
   call void @llvm.assume(i1 %c.1)
 
   %add.2 = add nsw i16 %start.ext, 2
   %c = icmp ult i16 %add.2, %high.ext
   ret i1 %c
 }
 
 define i1 @test_ult_add_nsw_pos_4_assume_pos(i8 %start, i8 %high) {
 ; CHECK-LABEL: @test_ult_add_nsw_pos_4_assume_pos(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[START_POS:%.*]] = icmp sge i8 [[START:%.*]], 0
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[START_POS]])
 ; CHECK-NEXT:    [[ADD:%.*]] = add nsw i8 [[START]], 3
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ult i8 [[ADD]], [[HIGH:%.*]]
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C_1]])
 ; CHECK-NEXT:    [[ADD_2:%.*]] = add nsw i8 [[START]], 2
-; CHECK-NEXT:    [[C:%.*]] = icmp ult i8 [[ADD_2]], [[HIGH]]
 ; CHECK-NEXT:    ret i1 true
 ;
 entry:
   %start.pos = icmp sge i8 %start, 0
   call void @llvm.assume(i1 %start.pos)
   %add = add nsw i8 %start, 3
   %c.1 = icmp ult i8 %add, %high
   call void @llvm.assume(i1 %c.1)

 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C_1]])
 ; CHECK-NEXT:    [[OFF_1_POS:%.*]] = icmp sge i8 [[OFF_1:%.*]], 0
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[OFF_1_POS]])
 ; CHECK-NEXT:    [[OFF_2_POS:%.*]] = icmp sge i8 [[OFF_2]], 0
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[OFF_2_POS]])
 ; CHECK-NEXT:    [[OFF_1_ULT:%.*]] = icmp ult i8 [[OFF_1]], [[OFF_2]]
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[OFF_1_ULT]])
 ; CHECK-NEXT:    [[ADD_OFF_2:%.*]] = add nsw i8 [[START]], [[OFF_1]]
-; CHECK-NEXT:    [[C:%.*]] = icmp ult i8 [[ADD_OFF_2]], [[HIGH]]
 ; CHECK-NEXT:    ret i1 true
 ;
 entry:
   %start.pos = icmp sge i8 %start, 0
   call void @llvm.assume(i1 %start.pos)
   %add = add nsw i8 %start, %off.2
   %c.1 = icmp ult i8 %add, %high
   call void @llvm.assume(i1 %c.1)

llvm/test/Transforms/ConstraintElimination/add-nuw.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -passes=constraint-elimination -S %s | FileCheck %s
 
 define void @test.not.uge.ult(i8 %start, i8 %low, i8 %high) {
 ; CHECK-LABEL: @test.not.uge.ult(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[ADD_PTR_I:%.*]] = add nuw i8 [[START:%.*]], 3
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp uge i8 [[ADD_PTR_I]], [[HIGH:%.*]]
 ; CHECK-NEXT:    br i1 [[C_1]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
 ; CHECK:       if.then:
 ; CHECK-NEXT:    ret void
 ; CHECK:       if.end:
-; CHECK-NEXT:    [[T_0:%.*]] = icmp ult i8 [[START]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    [[START_1:%.*]] = add nuw i8 [[START]], 1
-; CHECK-NEXT:    [[T_1:%.*]] = icmp ult i8 [[START_1]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    [[START_2:%.*]] = add nuw i8 [[START]], 2
-; CHECK-NEXT:    [[T_2:%.*]] = icmp ult i8 [[START_2]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    [[START_3:%.*]] = add nuw i8 [[START]], 3
-; CHECK-NEXT:    [[T_3:%.*]] = icmp ult i8 [[START_3]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    [[START_4:%.*]] = add nuw i8 [[START]], 4
 ; CHECK-NEXT:    [[C_4:%.*]] = icmp ult i8 [[START_4]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 [[C_4]])
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %add.ptr.i = add nuw i8 %start, 3

 ; CHECK-LABEL: @test.not.uge.ule(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[ADD_PTR_I:%.*]] = add nuw i8 [[START:%.*]], 3
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp uge i8 [[ADD_PTR_I]], [[HIGH:%.*]]
 ; CHECK-NEXT:    br i1 [[C_1]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
 ; CHECK:       if.then:
 ; CHECK-NEXT:    ret void
 ; CHECK:       if.end:
-; CHECK-NEXT:    [[T_0:%.*]] = icmp ule i8 [[START]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    [[START_1:%.*]] = add nuw i8 [[START]], 1
-; CHECK-NEXT:    [[T_1:%.*]] = icmp ule i8 [[START_1]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    [[START_2:%.*]] = add nuw i8 [[START]], 2
-; CHECK-NEXT:    [[T_2:%.*]] = icmp ule i8 [[START_2]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    [[START_3:%.*]] = add nuw i8 [[START]], 3
-; CHECK-NEXT:    [[T_3:%.*]] = icmp ule i8 [[START_3]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    [[START_4:%.*]] = add nuw i8 [[START]], 4
-; CHECK-NEXT:    [[T_4:%.*]] = icmp ule i8 [[START_4]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    [[START_5:%.*]] = add nuw i8 [[START]], 5
 ; CHECK-NEXT:    [[C_5:%.*]] = icmp ule i8 [[START_5]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 [[C_5]])
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %add.ptr.i = add nuw i8 %start, 3

 ; CHECK-LABEL: @test.not.uge.ugt(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[ADD_PTR_I:%.*]] = add nuw i8 [[START:%.*]], 3
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp uge i8 [[ADD_PTR_I]], [[HIGH:%.*]]
 ; CHECK-NEXT:    br i1 [[C_1]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
 ; CHECK:       if.then:
 ; CHECK-NEXT:    ret void
 ; CHECK:       if.end:
-; CHECK-NEXT:    [[F_0:%.*]] = icmp ugt i8 [[START]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 false)
 ; CHECK-NEXT:    [[START_1:%.*]] = add nuw i8 [[START]], 1
-; CHECK-NEXT:    [[F_1:%.*]] = icmp ugt i8 [[START_1]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 false)
 ; CHECK-NEXT:    [[START_2:%.*]] = add nuw i8 [[START]], 2
-; CHECK-NEXT:    [[F_2:%.*]] = icmp ugt i8 [[START_2]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 false)
 ; CHECK-NEXT:    [[START_3:%.*]] = add nuw i8 [[START]], 3
-; CHECK-NEXT:    [[F_3:%.*]] = icmp ugt i8 [[START_3]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 false)
 ; CHECK-NEXT:    [[START_4:%.*]] = add nuw i8 [[START]], 4
-; CHECK-NEXT:    [[F_4:%.*]] = icmp ugt i8 [[START_4]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 false)
 ; CHECK-NEXT:    [[START_5:%.*]] = add nuw i8 [[START]], 5
 ; CHECK-NEXT:    [[C_5:%.*]] = icmp ugt i8 [[START_5]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 [[C_5]])
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %add.ptr.i = add nuw i8 %start, 3

 ; CHECK-LABEL: @test.not.uge.uge(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[ADD_PTR_I:%.*]] = add nuw i8 [[START:%.*]], 3
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp uge i8 [[ADD_PTR_I]], [[HIGH:%.*]]
 ; CHECK-NEXT:    br i1 [[C_1]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
 ; CHECK:       if.then:
 ; CHECK-NEXT:    ret void
 ; CHECK:       if.end:
-; CHECK-NEXT:    [[F_0:%.*]] = icmp ugt i8 [[START]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 false)
 ; CHECK-NEXT:    [[START_1:%.*]] = add nuw i8 [[START]], 1
-; CHECK-NEXT:    [[F_1:%.*]] = icmp uge i8 [[START_1]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 false)
 ; CHECK-NEXT:    [[START_2:%.*]] = add nuw i8 [[START]], 2
-; CHECK-NEXT:    [[F_2:%.*]] = icmp uge i8 [[START_2]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 false)
 ; CHECK-NEXT:    [[START_3:%.*]] = add nuw i8 [[START]], 3
-; CHECK-NEXT:    [[F_3:%.*]] = icmp uge i8 [[START_3]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 false)
 ; CHECK-NEXT:    [[START_4:%.*]] = add nuw i8 [[START]], 4
 ; CHECK-NEXT:    [[C_4:%.*]] = icmp uge i8 [[START_4]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 [[C_4]])
 ; CHECK-NEXT:    [[START_5:%.*]] = add nuw i8 [[START]], 5
 ; CHECK-NEXT:    [[C_5:%.*]] = icmp uge i8 [[START_5]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 [[C_5]])
 ; CHECK-NEXT:    ret void

 ; CHECK-NEXT:    br i1 [[AND_0]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
 ; CHECK:       if.then:
 ; CHECK-NEXT:    [[C_2:%.*]] = icmp uge i8 [[A]], 0
 ; CHECK-NEXT:    [[C_3:%.*]] = icmp uge i8 [[B]], 0
 ; CHECK-NEXT:    [[AND_1:%.*]] = and i1 [[C_2]], [[C_3]]
 ; CHECK-NEXT:    br i1 [[AND_1]], label [[IF_THEN_2:%.*]], label [[IF_END]]
 ; CHECK:       if.then.2:
 ; CHECK-NEXT:    [[ADD_0:%.*]] = add nuw i8 [[A]], [[B]]
-; CHECK-NEXT:    [[T_0:%.*]] = icmp uge i8 [[ADD_0]], [[C]]
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    [[ADD_1:%.*]] = add nuw i8 [[A]], [[A]]
-; CHECK-NEXT:    [[T_1:%.*]] = icmp uge i8 [[ADD_0]], [[C]]
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    [[ADD_2:%.*]] = add nuw i8 [[A]], [[D:%.*]]
 ; CHECK-NEXT:    [[C_4:%.*]] = icmp uge i8 [[ADD_2]], [[C]]
 ; CHECK-NEXT:    call void @use(i1 [[C_4]])
 ; CHECK-NEXT:    ret void
 ; CHECK:       if.end:
 ; CHECK-NEXT:    ret void
 ;

 define i1 @test_n_must_ule_1_due_to_nuw(i8 %n, i8 %i) {
 ; CHECK-LABEL: @test_n_must_ule_1_due_to_nuw(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[SUB_N_1:%.*]] = add nuw i8 [[N:%.*]], -1
 ; CHECK-NEXT:    [[ADD:%.*]] = add nuw i8 [[I:%.*]], [[SUB_N_1]]
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp uge i8 [[I]], [[ADD]]
 ; CHECK-NEXT:    br i1 [[C_1]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
 ; CHECK:       if.then:
-; CHECK-NEXT:    [[T:%.*]] = icmp ule i8 [[N]], 1
 ; CHECK-NEXT:    ret i1 true
 ; CHECK:       if.end:
 ; CHECK-NEXT:    [[F:%.*]] = icmp ule i8 [[N]], 1
 ; CHECK-NEXT:    ret i1 [[F]]
 ;
 entry:
   %sub.n.1 = add nuw i8 %n, -1
   %add = add nuw i8 %i, %sub.n.1

 define i1 @test_n_must_ule_2_due_to_nuw(i8 %n, i8 %i) {
 ; CHECK-LABEL: @test_n_must_ule_2_due_to_nuw(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[SUB_N_1:%.*]] = add nuw i8 [[N:%.*]], -2
 ; CHECK-NEXT:    [[ADD:%.*]] = add nuw i8 [[I:%.*]], [[SUB_N_1]]
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp uge i8 [[I]], [[ADD]]
 ; CHECK-NEXT:    br i1 [[C_1]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
 ; CHECK:       if.then:
-; CHECK-NEXT:    [[T:%.*]] = icmp ule i8 [[N]], 2
 ; CHECK-NEXT:    ret i1 true
 ; CHECK:       if.end:
 ; CHECK-NEXT:    [[F:%.*]] = icmp ule i8 [[N]], 2
 ; CHECK-NEXT:    ret i1 [[F]]
 ;
 entry:
   %sub.n.1 = add nuw i8 %n, -2
   %add = add nuw i8 %i, %sub.n.1

 
 define i1 @add_nuw_neg_pr54224_i16(i16 %a) {
 ; CHECK-LABEL: @add_nuw_neg_pr54224_i16(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[NEG2:%.*]] = add nuw i16 [[A:%.*]], -305
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ugt i16 0, [[NEG2]]
 ; CHECK-NEXT:    br i1 [[C_1]], label [[EXIT_1:%.*]], label [[EXIT_2:%.*]]
 ; CHECK:       exit.1:
-; CHECK-NEXT:    [[C_2:%.*]] = icmp ugt i16 [[A]], 0
 ; CHECK-NEXT:    ret i1 false
 ; CHECK:       exit.2:
 ; CHECK-NEXT:    [[C_3:%.*]] = icmp ugt i16 [[A]], 0
 ; CHECK-NEXT:    ret i1 [[C_3]]
 ;
 entry:
   %neg2 = add nuw i16 %a, -305
   %c.1 = icmp ugt i16 0, %neg2

 
 define i1 @add_nuw_neg2_i8(i8 %a) {
 ; CHECK-LABEL: @add_nuw_neg2_i8(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[NEG2:%.*]] = add nuw i8 [[A:%.*]], -4
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ult i8 [[NEG2]], -2
 ; CHECK-NEXT:    br i1 [[C_1]], label [[EXIT_1:%.*]], label [[EXIT_2:%.*]]
 ; CHECK:       exit.1:
-; CHECK-NEXT:    [[T_1:%.*]] = icmp ult i8 [[A]], 2
 ; CHECK-NEXT:    [[C_2:%.*]] = icmp ult i8 [[A]], 1
 ; CHECK-NEXT:    [[RES_1:%.*]] = xor i1 true, [[C_2]]
 ; CHECK-NEXT:    ret i1 [[RES_1]]
 ; CHECK:       exit.2:
 ; CHECK-NEXT:    [[C_3:%.*]] = icmp ult i8 [[A]], 3
-; CHECK-NEXT:    [[F_1:%.*]] = icmp ult i8 [[A]], 2
 ; CHECK-NEXT:    [[RES_2:%.*]] = xor i1 [[C_3]], false
 ; CHECK-NEXT:    ret i1 [[RES_2]]
 ;
 entry:
   %neg2 = add nuw i8 %a, -4
   %c.1 = icmp ult i8 %neg2, -2
   br i1 %c.1, label %exit.1, label %exit.2
 

 ; CHECK-LABEL: @test_chained_adds_nuw_1(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[C_A:%.*]] = icmp uge i8 [[A:%.*]], 5
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C_A]])
 ; CHECK-NEXT:    [[C_B:%.*]] = icmp uge i8 [[B:%.*]], 6
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C_B]])
 ; CHECK-NEXT:    [[ADD_1:%.*]] = add nuw i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[ADD_2:%.*]] = add nuw i8 [[ADD_1]], 2
-; CHECK-NEXT:    [[T_1:%.*]] = icmp uge i8 [[ADD_2]], 13
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp uge i8 [[ADD_2]], 14
 ; CHECK-NEXT:    [[RES_1:%.*]] = xor i1 true, [[C_1]]
 ; CHECK-NEXT:    ret i1 [[RES_1]]
 ;
 entry:
   %c.a = icmp uge i8 %a, 5
   call void @llvm.assume(i1 %c.a)
   %c.b = icmp uge i8 %b, 6

 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[C_A:%.*]] = icmp uge i8 [[A:%.*]], 5
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C_A]])
 ; CHECK-NEXT:    [[C_B:%.*]] = icmp uge i8 [[B:%.*]], 6
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C_B]])
 ; CHECK-NEXT:    [[ADD_1:%.*]] = add nuw i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[ADD_2:%.*]] = add nuw i8 [[ADD_1]], 2
 ; CHECK-NEXT:    [[ADD_3:%.*]] = add nuw i8 [[ADD_2]], [[A]]
-; CHECK-NEXT:    [[T_1:%.*]] = icmp uge i8 [[ADD_3]], 18
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp uge i8 [[ADD_3]], 19
 ; CHECK-NEXT:    [[RES_1:%.*]] = xor i1 true, [[C_1]]
 ; CHECK-NEXT:    ret i1 [[RES_1]]
 ;
 entry:
   %c.a = icmp uge i8 %a, 5
   call void @llvm.assume(i1 %c.a)
   %c.b = icmp uge i8 %b, 6

 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[C_A:%.*]] = icmp uge i8 [[A:%.*]], 5
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C_A]])
 ; CHECK-NEXT:    [[C_B:%.*]] = icmp uge i8 [[B:%.*]], 6
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C_B]])
 ; CHECK-NEXT:    [[ADD_1:%.*]] = add nuw i8 [[A]], 2
 ; CHECK-NEXT:    [[ADD_2:%.*]] = add nuw i8 [[ADD_1]], [[B]]
 ; CHECK-NEXT:    [[ADD_3:%.*]] = add nuw i8 [[ADD_2]], [[A]]
-; CHECK-NEXT:    [[T_1:%.*]] = icmp uge i8 [[ADD_3]], 18
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp uge i8 [[ADD_3]], 19
 ; CHECK-NEXT:    [[RES_1:%.*]] = xor i1 true, [[C_1]]
 ; CHECK-NEXT:    ret i1 [[RES_1]]
 ;
 entry:
   %c.a = icmp uge i8 %a, 5
   call void @llvm.assume(i1 %c.a)
   %c.b = icmp uge i8 %b, 6

 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[C_A:%.*]] = icmp uge i8 [[A:%.*]], 5
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C_A]])
 ; CHECK-NEXT:    [[C_B:%.*]] = icmp uge i8 [[B:%.*]], 6
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C_B]])
 ; CHECK-NEXT:    [[ADD_1:%.*]] = add nuw i8 [[A]], 2
 ; CHECK-NEXT:    [[ADD_2:%.*]] = add nuw i8 [[ADD_1]], [[B]]
 ; CHECK-NEXT:    [[ADD_3:%.*]] = add nuw i8 [[ADD_2]], 10
-; CHECK-NEXT:    [[T_1:%.*]] = icmp uge i8 [[ADD_3]], 23
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp uge i8 [[ADD_3]], 24
 ; CHECK-NEXT:    [[RES_1:%.*]] = xor i1 true, [[C_1]]
 ; CHECK-NEXT:    ret i1 [[RES_1]]
 ;
 entry:
   %c.a = icmp uge i8 %a, 5
   call void @llvm.assume(i1 %c.a)
   %c.b = icmp uge i8 %b, 6

llvm/test/Transforms/ConstraintElimination/analysis-invalidation.ll

+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 2
 ; RUN: opt -passes='require<demanded-bits>,constraint-elimination,require<demanded-bits>' -disable-verify -verify-analysis-invalidation=false -debug-pass-manager -disable-output %s 2>&1 | FileCheck %s
 
 ; Check that constraint-elimination properly invalidates anlyses.
 
 ; FIXME: ssub simplification currently doesn't properly set the change status
 ;        after modifying the IR, which causes DemandedBits to be preserved.
 
 ; CHECK:      Running pass: RequireAnalysisPass

 
 bb1:
   %t.1 = icmp uge i16 %x.ext, %y
   ret i1 %t.1
 
 bb2:
   ret i1 false
 }
+;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line:
+; CHECK: {{.*}}

llvm/test/Transforms/ConstraintElimination/and-implied-by-operands.ll

 ; CHECK:       then.2:
 ; CHECK-NEXT:    [[C_2:%.*]] = icmp ne ptr [[A]], null
 ; CHECK-NEXT:    [[C_3:%.*]] = icmp sgt i64 [[B:%.*]], 0
 ; CHECK-NEXT:    [[AND:%.*]] = and i1 [[C_2]], [[C_3]]
 ; CHECK-NEXT:    ret i1 [[AND]]
 ; CHECK:       else.2:
 ; CHECK-NEXT:    ret i1 false
 ; CHECK:       exit:
-; CHECK-NEXT:    [[T:%.*]] = icmp eq ptr null, null
 ; CHECK-NEXT:    ret i1 true
 ;
 entry:
   br i1 %c, label %then.1, label %exit
 
 then.1:
   %0 = load ptr, ptr %C, align 8
   %c.1 = icmp ult ptr %0, %A
exit:
   %t = icmp eq ptr null, null
   ret i1 %t
 }
 
 define i1 @test_and_op_0_simplified(i32 %v) {
 ; CHECK-LABEL: @test_and_op_0_simplified(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp sgt i32 [[V:%.*]], 0
-; CHECK-NEXT:    [[T_1:%.*]] = icmp sgt i32 0, 0
 ; CHECK-NEXT:    [[AND:%.*]] = and i1 false, [[C_1]]
 ; CHECK-NEXT:    ret i1 [[AND]]
 ;
 entry:
   %c.1 = icmp sgt i32 %v, 0
   %t.1 = icmp sgt i32 0, 0
   %and = and i1 %t.1, %c.1
   ret i1 %and
 }
 
 define i1 @test_and_op_1_simplified(i32 %v) {
 ; CHECK-LABEL: @test_and_op_1_simplified(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp sgt i32 [[V:%.*]], 0
-; CHECK-NEXT:    [[T_1:%.*]] = icmp sgt i32 0, 0
 ; CHECK-NEXT:    [[AND:%.*]] = and i1 [[C_1]], false
 ; CHECK-NEXT:    ret i1 [[AND]]
 ;
 entry:
   %c.1 = icmp sgt i32 %v, 0
   %t.1 = icmp sgt i32 0, 0
   %and = and i1 %c.1, %t.1
   ret i1 %and

llvm/test/Transforms/ConstraintElimination/and.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -passes=constraint-elimination -S %s | FileCheck %s
 
 declare void @use(i1)
 
 define i1 @test_and_ule(i4 %x, i4 %y, i4 %z, i4 %a) {
 ; CHECK-LABEL: @test_and_ule(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ule i4 [[X:%.*]], [[Y:%.*]]
 ; CHECK-NEXT:    [[C_2:%.*]] = icmp ule i4 [[Y]], [[Z:%.*]]
 ; CHECK-NEXT:    [[AND:%.*]] = and i1 [[C_1]], [[C_2]]
 ; CHECK-NEXT:    br i1 [[AND]], label [[BB1:%.*]], label [[EXIT:%.*]]
 ; CHECK:       bb1:
-; CHECK-NEXT:    [[T_1:%.*]] = icmp ule i4 [[X]], [[Z]]
-; CHECK-NEXT:    [[T_2:%.*]] = icmp ule i4 [[X]], [[Y]]
 ; CHECK-NEXT:    [[R_1:%.*]] = xor i1 true, true
-; CHECK-NEXT:    [[T_3:%.*]] = icmp ule i4 [[Y]], [[Z]]
 ; CHECK-NEXT:    [[R_2:%.*]] = xor i1 [[R_1]], true
 ; CHECK-NEXT:    [[C_3:%.*]] = icmp ule i4 [[X]], [[A:%.*]]
 ; CHECK-NEXT:    [[R_3:%.*]] = xor i1 [[R_2]], [[C_3]]
 ; CHECK-NEXT:    ret i1 [[R_3]]
 ; CHECK:       exit:
 ; CHECK-NEXT:    [[C_4:%.*]] = icmp ule i4 [[X]], [[Z]]
 ; CHECK-NEXT:    [[C_5:%.*]] = icmp ule i4 [[X]], [[A]]
 ; CHECK-NEXT:    [[R_4:%.*]] = xor i1 [[C_4]], [[C_5]]

 define i1 @test_and_select_ule(i4 %x, i4 %y, i4 %z, i4 %a) {
 ; CHECK-LABEL: @test_and_select_ule(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ule i4 [[X:%.*]], [[Y:%.*]]
 ; CHECK-NEXT:    [[C_2:%.*]] = icmp ule i4 [[Y]], [[Z:%.*]]
 ; CHECK-NEXT:    [[AND:%.*]] = select i1 [[C_1]], i1 [[C_2]], i1 false
 ; CHECK-NEXT:    br i1 [[AND]], label [[BB1:%.*]], label [[EXIT:%.*]]
 ; CHECK:       bb1:
-; CHECK-NEXT:    [[T_1:%.*]] = icmp ule i4 [[X]], [[Z]]
-; CHECK-NEXT:    [[T_2:%.*]] = icmp ule i4 [[X]], [[Y]]
 ; CHECK-NEXT:    [[R_1:%.*]] = xor i1 true, true
-; CHECK-NEXT:    [[T_3:%.*]] = icmp ule i4 [[Y]], [[Z]]
 ; CHECK-NEXT:    [[R_2:%.*]] = xor i1 [[R_1]], true
 ; CHECK-NEXT:    [[C_3:%.*]] = icmp ule i4 [[X]], [[A:%.*]]
 ; CHECK-NEXT:    [[R_3:%.*]] = xor i1 [[R_2]], [[C_3]]
 ; CHECK-NEXT:    ret i1 [[R_3]]
 ; CHECK:       exit:
 ; CHECK-NEXT:    [[C_4:%.*]] = icmp ule i4 [[X]], [[Z]]
 ; CHECK-NEXT:    [[C_5:%.*]] = icmp ule i4 [[X]], [[A]]
 ; CHECK-NEXT:    [[R_4:%.*]] = xor i1 [[C_4]], [[C_5]]
exit:
   ret i4 3
 }
 
 define i1 @test_and_condition_trivially_false(i1 %c, ptr %ptr.1, i8 %idx, ptr %ptr.2) {
 ; CHECK-LABEL: @test_and_condition_trivially_false(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br i1 [[C:%.*]], label [[THEN:%.*]], label [[EXIT_3:%.*]]
 ; CHECK:       then:
-; CHECK-NEXT:    [[CMP_1:%.*]] = icmp ugt ptr [[PTR_2:%.*]], [[PTR_2]]
 ; CHECK-NEXT:    [[IDX_EXT:%.*]] = zext i8 [[IDX:%.*]] to i16
 ; CHECK-NEXT:    [[GEP_IDX_EXT:%.*]] = getelementptr inbounds i8, ptr [[PTR_1:%.*]], i16 [[IDX_EXT]]
-; CHECK-NEXT:    [[CMP_2:%.*]] = icmp ult ptr [[PTR_2]], [[GEP_IDX_EXT]]
+; CHECK-NEXT:    [[CMP_2:%.*]] = icmp ult ptr [[PTR_2:%.*]], [[GEP_IDX_EXT]]
 ; CHECK-NEXT:    [[AND:%.*]] = and i1 false, [[CMP_2]]
 ; CHECK-NEXT:    br i1 [[AND]], label [[EXIT_1:%.*]], label [[EXIT_2:%.*]]
 ; CHECK:       exit.1:
 ; CHECK-NEXT:    ret i1 true
 ; CHECK:       exit.2:
 ; CHECK-NEXT:    ret i1 false
 ; CHECK:       exit.3:
 ; CHECK-NEXT:    [[CMP_3:%.*]] = icmp ne i8 [[IDX]], 0

 ; CHECK-NEXT:    [[C_2:%.*]] = icmp ule i4 [[Y]], [[Z:%.*]]
 ; CHECK-NEXT:    [[C_3:%.*]] = icmp ule i4 3, [[X]]
 ; CHECK-NEXT:    [[C_4:%.*]] = icmp ule i4 3, [[A:%.*]]
 ; CHECK-NEXT:    [[AND_1:%.*]] = and i1 [[C_1]], [[C_2]]
 ; CHECK-NEXT:    [[AND_2:%.*]] = and i1 [[AND_1]], [[C_3]]
 ; CHECK-NEXT:    [[AND_3:%.*]] = and i1 [[C_4]], [[AND_2]]
 ; CHECK-NEXT:    br i1 [[AND_3]], label [[BB1:%.*]], label [[EXIT:%.*]]
 ; CHECK:       bb1:
-; CHECK-NEXT:    [[T_1:%.*]] = icmp ule i4 [[X]], [[Z]]
-; CHECK-NEXT:    [[T_2:%.*]] = icmp ule i4 [[X]], [[Y]]
 ; CHECK-NEXT:    [[R_1:%.*]] = xor i1 true, true
-; CHECK-NEXT:    [[T_3:%.*]] = icmp ule i4 [[Y]], [[Z]]
 ; CHECK-NEXT:    [[R_2:%.*]] = xor i1 [[R_1]], true
-; CHECK-NEXT:    [[T_4:%.*]] = icmp ule i4 3, [[X]]
 ; CHECK-NEXT:    [[R_3:%.*]] = xor i1 [[R_2]], true
-; CHECK-NEXT:    [[T_5:%.*]] = icmp ule i4 3, [[A]]
 ; CHECK-NEXT:    [[R_4:%.*]] = xor i1 [[R_3]], true
 ; CHECK-NEXT:    [[C_5:%.*]] = icmp ule i4 [[X]], [[A]]
 ; CHECK-NEXT:    [[R_5:%.*]] = xor i1 [[R_4]], [[C_5]]
 ; CHECK-NEXT:    ret i1 [[R_5]]
 ; CHECK:       exit:
 ; CHECK-NEXT:    [[C_6:%.*]] = icmp ule i4 [[X]], [[Z]]
 ; CHECK-NEXT:    [[C_7:%.*]] = icmp ule i4 [[X]], [[A]]
 ; CHECK-NEXT:    [[R_6:%.*]] = xor i1 [[C_6]], [[C_7]]

 ; CHECK-NEXT:    [[C_2:%.*]] = icmp ule i4 [[Y]], [[Z:%.*]]
 ; CHECK-NEXT:    [[C_3:%.*]] = icmp ule i4 3, [[X]]
 ; CHECK-NEXT:    [[C_4:%.*]] = icmp ule i4 3, [[A:%.*]]
 ; CHECK-NEXT:    [[AND_1:%.*]] = and i1 [[C_1]], [[C_2]]
 ; CHECK-NEXT:    [[AND_2:%.*]] = and i1 [[C_3]], [[C_4]]
 ; CHECK-NEXT:    [[AND_3:%.*]] = and i1 [[AND_1]], [[AND_2]]
 ; CHECK-NEXT:    br i1 [[AND_3]], label [[BB1:%.*]], label [[EXIT:%.*]]
 ; CHECK:       bb1:
-; CHECK-NEXT:    [[T_1:%.*]] = icmp ule i4 [[X]], [[Z]]
-; CHECK-NEXT:    [[T_2:%.*]] = icmp ule i4 [[X]], [[Y]]
 ; CHECK-NEXT:    [[R_1:%.*]] = xor i1 true, true
-; CHECK-NEXT:    [[T_3:%.*]] = icmp ule i4 [[Y]], [[Z]]
 ; CHECK-NEXT:    [[R_2:%.*]] = xor i1 [[R_1]], true
-; CHECK-NEXT:    [[T_4:%.*]] = icmp ule i4 3, [[X]]
 ; CHECK-NEXT:    [[R_3:%.*]] = xor i1 [[R_2]], true
-; CHECK-NEXT:    [[T_5:%.*]] = icmp ule i4 3, [[A]]
 ; CHECK-NEXT:    [[R_4:%.*]] = xor i1 [[R_3]], true
 ; CHECK-NEXT:    [[C_5:%.*]] = icmp ule i4 [[X]], [[A]]
 ; CHECK-NEXT:    [[R_5:%.*]] = xor i1 [[R_4]], [[C_5]]
 ; CHECK-NEXT:    ret i1 [[R_5]]
 ; CHECK:       exit:
 ; CHECK-NEXT:    [[C_6:%.*]] = icmp ule i4 [[X]], [[Z]]
 ; CHECK-NEXT:    [[C_7:%.*]] = icmp ule i4 [[X]], [[A]]
 ; CHECK-NEXT:    [[R_6:%.*]] = xor i1 [[C_6]], [[C_7]]

 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ule i4 [[X:%.*]], [[Y:%.*]]
 ; CHECK-NEXT:    [[C_2:%.*]] = icmp ule i4 [[Y]], [[Z:%.*]]
 ; CHECK-NEXT:    [[C_3:%.*]] = call i1 @cond()
 ; CHECK-NEXT:    [[AND_1:%.*]] = and i1 [[C_1]], [[C_2]]
 ; CHECK-NEXT:    [[AND_2:%.*]] = and i1 [[C_3]], [[ARG_C:%.*]]
 ; CHECK-NEXT:    [[AND_3:%.*]] = and i1 [[AND_1]], [[AND_2]]
 ; CHECK-NEXT:    br i1 [[AND_3]], label [[BB1:%.*]], label [[EXIT:%.*]]
 ; CHECK:       bb1:
-; CHECK-NEXT:    [[T_1:%.*]] = icmp ule i4 [[X]], [[Z]]
-; CHECK-NEXT:    [[T_2:%.*]] = icmp ule i4 [[X]], [[Y]]
 ; CHECK-NEXT:    [[R_1:%.*]] = xor i1 true, true
-; CHECK-NEXT:    [[T_3:%.*]] = icmp ule i4 [[Y]], [[Z]]
 ; CHECK-NEXT:    [[R_2:%.*]] = xor i1 [[R_1]], true
 ; CHECK-NEXT:    [[C_4:%.*]] = icmp ule i4 3, [[X]]
 ; CHECK-NEXT:    [[R_3:%.*]] = xor i1 [[R_2]], [[C_4]]
 ; CHECK-NEXT:    [[C_5:%.*]] = icmp ule i4 3, [[A:%.*]]
 ; CHECK-NEXT:    [[R_4:%.*]] = xor i1 [[R_3]], [[C_5]]
 ; CHECK-NEXT:    [[C_6:%.*]] = icmp ule i4 [[X]], [[A]]
 ; CHECK-NEXT:    [[R_5:%.*]] = xor i1 [[R_4]], [[C_6]]
 ; CHECK-NEXT:    ret i1 [[R_5]]

 ; CHECK-NEXT:    [[C_3:%.*]] = icmp ule i4 3, [[X]]
 ; CHECK-NEXT:    [[C_4:%.*]] = icmp ule i4 3, [[A:%.*]]
 ; CHECK-NEXT:    [[AND_1:%.*]] = select i1 [[C_1]], i1 true, i1 false
 ; CHECK-NEXT:    [[AND_2:%.*]] = select i1 [[AND_1]], i1 [[C_3]], i1 false
 ; CHECK-NEXT:    [[AND_3:%.*]] = select i1 [[C_4]], i1 [[AND_2]], i1 false
 ; CHECK-NEXT:    br i1 [[AND_3]], label [[BB1:%.*]], label [[EXIT:%.*]]
 ; CHECK:       bb1:
 ; CHECK-NEXT:    [[T_1:%.*]] = icmp ule i4 [[X]], [[Z]]
-; CHECK-NEXT:    [[T_2:%.*]] = icmp ule i4 [[X]], [[Y]]
 ; CHECK-NEXT:    [[R_1:%.*]] = xor i1 [[T_1]], true
 ; CHECK-NEXT:    [[T_3:%.*]] = icmp ule i4 [[Y]], [[Z]]
 ; CHECK-NEXT:    [[R_2:%.*]] = xor i1 [[R_1]], [[T_3]]
-; CHECK-NEXT:    [[T_4:%.*]] = icmp ule i4 3, [[X]]
 ; CHECK-NEXT:    [[R_3:%.*]] = xor i1 [[R_2]], true
-; CHECK-NEXT:    [[T_5:%.*]] = icmp ule i4 3, [[A]]
 ; CHECK-NEXT:    [[R_4:%.*]] = xor i1 [[R_3]], true
 ; CHECK-NEXT:    [[C_5:%.*]] = icmp ule i4 [[X]], [[A]]
 ; CHECK-NEXT:    [[R_5:%.*]] = xor i1 [[R_4]], [[C_5]]
 ; CHECK-NEXT:    ret i1 [[R_5]]
 ; CHECK:       exit:
 ; CHECK-NEXT:    [[C_6:%.*]] = icmp ule i4 [[X]], [[Z]]
 ; CHECK-NEXT:    [[C_7:%.*]] = icmp ule i4 [[X]], [[A]]
 ; CHECK-NEXT:    [[R_6:%.*]] = xor i1 [[C_6]], [[C_7]]

llvm/test/Transforms/ConstraintElimination/assumes.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -passes=constraint-elimination -S %s | FileCheck %s
 
 declare void @llvm.assume(i1)
 
 declare void @may_unwind()
 
 declare void @use(i1)
 
 define i1 @assume_dominates(i8 %a, i8 %b, i1 %c) {
 ; CHECK-LABEL: @assume_dominates(
 ; CHECK-NEXT:    [[ADD_1:%.*]] = add nuw nsw i8 [[A:%.*]], 1
 ; CHECK-NEXT:    [[CMP_1:%.*]] = icmp ule i8 [[ADD_1]], [[B:%.*]]
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[CMP_1]])
 ; CHECK-NEXT:    br i1 [[C:%.*]], label [[THEN:%.*]], label [[ELSE:%.*]]
 ; CHECK:       then:
-; CHECK-NEXT:    [[T_1:%.*]] = icmp ule i8 [[ADD_1]], [[B]]
-; CHECK-NEXT:    [[T_2:%.*]] = icmp ule i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[RES_1:%.*]] = xor i1 true, true
 ; CHECK-NEXT:    [[ADD_2:%.*]] = add nuw nsw i8 [[A]], 2
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ule i8 [[ADD_2]], [[B]]
 ; CHECK-NEXT:    [[RES_2:%.*]] = xor i1 [[RES_1]], [[C_1]]
 ; CHECK-NEXT:    ret i1 [[RES_2]]
 ; CHECK:       else:
-; CHECK-NEXT:    [[T_3:%.*]] = icmp ule i8 [[ADD_1]], [[B]]
-; CHECK-NEXT:    [[T_4:%.*]] = icmp ule i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[RES_3:%.*]] = xor i1 true, true
 ; CHECK-NEXT:    [[ADD_2_1:%.*]] = add nuw nsw i8 [[A]], 2
 ; CHECK-NEXT:    [[C_2:%.*]] = icmp ule i8 [[ADD_2_1]], [[B]]
 ; CHECK-NEXT:    [[RES_4:%.*]] = xor i1 [[RES_3]], [[C_2]]
 ; CHECK-NEXT:    ret i1 [[RES_4]]
 ;
   %add.1 = add nsw nuw i8 %a, 1
   %cmp.1 = icmp ule i8 %add.1, %b

 define i1 @assume_dominates_with_may_unwind_call_before_assume(i8 %a, i8 %b, i1 %c) {
 ; CHECK-LABEL: @assume_dominates_with_may_unwind_call_before_assume(
 ; CHECK-NEXT:    [[ADD_1:%.*]] = add nuw nsw i8 [[A:%.*]], 1
 ; CHECK-NEXT:    [[CMP_1:%.*]] = icmp ule i8 [[ADD_1]], [[B:%.*]]
 ; CHECK-NEXT:    call void @may_unwind()
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[CMP_1]])
 ; CHECK-NEXT:    br i1 [[C:%.*]], label [[THEN:%.*]], label [[ELSE:%.*]]
 ; CHECK:       then:
-; CHECK-NEXT:    [[T_1:%.*]] = icmp ule i8 [[ADD_1]], [[B]]
-; CHECK-NEXT:    [[T_2:%.*]] = icmp ule i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[RES_1:%.*]] = xor i1 true, true
 ; CHECK-NEXT:    [[ADD_2:%.*]] = add nuw nsw i8 [[A]], 2
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ule i8 [[ADD_2]], [[B]]
 ; CHECK-NEXT:    [[RES_2:%.*]] = xor i1 [[RES_1]], [[C_1]]
 ; CHECK-NEXT:    ret i1 [[RES_2]]
 ; CHECK:       else:
-; CHECK-NEXT:    [[T_3:%.*]] = icmp ule i8 [[ADD_1]], [[B]]
-; CHECK-NEXT:    [[T_4:%.*]] = icmp ule i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[RES_3:%.*]] = xor i1 true, true
 ; CHECK-NEXT:    [[ADD_2_1:%.*]] = add nuw nsw i8 [[A]], 2
 ; CHECK-NEXT:    [[C_2:%.*]] = icmp ule i8 [[ADD_2_1]], [[B]]
 ; CHECK-NEXT:    [[RES_4:%.*]] = xor i1 [[RES_3]], [[C_2]]
 ; CHECK-NEXT:    ret i1 [[RES_4]]
 ;
   %add.1 = add nsw nuw i8 %a, 1
   %cmp.1 = icmp ule i8 %add.1, %b

 define i1 @assume_dominates_with_may_unwind_call_after_assume(i8 %a, i8 %b, i1 %c) {
 ; CHECK-LABEL: @assume_dominates_with_may_unwind_call_after_assume(
 ; CHECK-NEXT:    [[ADD_1:%.*]] = add nuw nsw i8 [[A:%.*]], 1
 ; CHECK-NEXT:    [[CMP_1:%.*]] = icmp ule i8 [[ADD_1]], [[B:%.*]]
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[CMP_1]])
 ; CHECK-NEXT:    call void @may_unwind()
 ; CHECK-NEXT:    br i1 [[C:%.*]], label [[THEN:%.*]], label [[ELSE:%.*]]
 ; CHECK:       then:
-; CHECK-NEXT:    [[T_1:%.*]] = icmp ule i8 [[ADD_1]], [[B]]
-; CHECK-NEXT:    [[T_2:%.*]] = icmp ule i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[RES_1:%.*]] = xor i1 true, true
 ; CHECK-NEXT:    [[ADD_2:%.*]] = add nuw nsw i8 [[A]], 2
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ule i8 [[ADD_2]], [[B]]
 ; CHECK-NEXT:    [[RES_2:%.*]] = xor i1 [[RES_1]], [[C_1]]
 ; CHECK-NEXT:    ret i1 [[RES_2]]
 ; CHECK:       else:
-; CHECK-NEXT:    [[T_3:%.*]] = icmp ule i8 [[ADD_1]], [[B]]
-; CHECK-NEXT:    [[T_4:%.*]] = icmp ule i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[RES_3:%.*]] = xor i1 true, true
 ; CHECK-NEXT:    [[ADD_2_1:%.*]] = add nuw nsw i8 [[A]], 2
 ; CHECK-NEXT:    [[C_2:%.*]] = icmp ule i8 [[ADD_2_1]], [[B]]
 ; CHECK-NEXT:    [[RES_4:%.*]] = xor i1 [[RES_3]], [[C_2]]
 ; CHECK-NEXT:    ret i1 [[RES_4]]
 ;
   %add.1 = add nsw nuw i8 %a, 1
   %cmp.1 = icmp ule i8 %add.1, %b

 define i1 @assume_dominates_successor_with_may_unwind_call_before_assume_uncond_branch(i16 %a) {
 ; CHECK-LABEL: @assume_dominates_successor_with_may_unwind_call_before_assume_uncond_branch(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    call void @may_unwind()
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp eq i16 [[A:%.*]], 0
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C_1]])
 ; CHECK-NEXT:    br label [[EXIT:%.*]]
 ; CHECK:       exit:
-; CHECK-NEXT:    [[C_2:%.*]] = icmp eq i16 [[A]], 0
 ; CHECK-NEXT:    ret i1 true
 ;
 entry:
   call void @may_unwind()
   %c.1 = icmp eq i16 %a, 0
   call void @llvm.assume(i1 %c.1)
   br label %exit
 
exit:
   ret i1 %c.2
 }
 
 define i1 @assume_single_bb(i8 %a, i8 %b, i1 %c) {
 ; CHECK-LABEL: @assume_single_bb(
 ; CHECK-NEXT:    [[ADD_1:%.*]] = add nuw nsw i8 [[A:%.*]], 1
 ; CHECK-NEXT:    [[CMP_1:%.*]] = icmp ule i8 [[ADD_1]], [[B:%.*]]
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[CMP_1]])
-; CHECK-NEXT:    [[T_1:%.*]] = icmp ule i8 [[ADD_1]], [[B]]
-; CHECK-NEXT:    [[T_2:%.*]] = icmp ule i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[RES_1:%.*]] = xor i1 true, true
 ; CHECK-NEXT:    [[ADD_2:%.*]] = add nuw nsw i8 [[A]], 2
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ule i8 [[ADD_2]], [[B]]
 ; CHECK-NEXT:    [[RES_2:%.*]] = xor i1 [[RES_1]], [[C_1]]
 ; CHECK-NEXT:    ret i1 [[RES_2]]
 ;
   %add.1 = add nsw nuw i8 %a, 1
   %cmp.1 = icmp ule i8 %add.1, %b

 
 define i1 @assume_same_bb(i8 %a, i8 %b, i1 %c) {
 ; CHECK-LABEL: @assume_same_bb(
 ; CHECK-NEXT:    [[ADD_1:%.*]] = add nuw nsw i8 [[A:%.*]], 1
 ; CHECK-NEXT:    [[CMP_1:%.*]] = icmp ule i8 [[ADD_1]], [[B:%.*]]
 ; CHECK-NEXT:    br i1 [[C:%.*]], label [[THEN:%.*]], label [[ELSE:%.*]]
 ; CHECK:       then:
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[CMP_1]])
-; CHECK-NEXT:    [[T_1:%.*]] = icmp ule i8 [[ADD_1]], [[B]]
-; CHECK-NEXT:    [[T_2:%.*]] = icmp ule i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[RES_1:%.*]] = xor i1 true, true
 ; CHECK-NEXT:    [[ADD_2:%.*]] = add nuw nsw i8 [[A]], 2
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ule i8 [[ADD_2]], [[B]]
 ; CHECK-NEXT:    [[RES_2:%.*]] = xor i1 [[RES_1]], [[C_1]]
 ; CHECK-NEXT:    ret i1 [[RES_2]]
 ; CHECK:       else:
 ; CHECK-NEXT:    [[T_3:%.*]] = icmp ule i8 [[ADD_1]], [[B]]
 ; CHECK-NEXT:    [[T_4:%.*]] = icmp ule i8 [[A]], [[B]]
else:
   ret i1 %res.4
 }
 
 define i1 @assume_same_bb2(i8 %a, i8 %b, i1 %c) {
 ; CHECK-LABEL: @assume_same_bb2(
 ; CHECK-NEXT:    [[ADD_1:%.*]] = add nuw nsw i8 [[A:%.*]], 1
 ; CHECK-NEXT:    [[CMP_1:%.*]] = icmp ule i8 [[ADD_1]], [[B:%.*]]
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[CMP_1]])
-; CHECK-NEXT:    [[T_1:%.*]] = icmp ule i8 [[ADD_1]], [[B]]
-; CHECK-NEXT:    [[T_2:%.*]] = icmp ule i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[RES_1:%.*]] = xor i1 true, true
 ; CHECK-NEXT:    [[ADD_2:%.*]] = add nuw nsw i8 [[A]], 2
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ule i8 [[ADD_2]], [[B]]
 ; CHECK-NEXT:    [[RES_2:%.*]] = xor i1 [[RES_1]], [[C_1]]
 ; CHECK-NEXT:    br label [[EXIT:%.*]]
 ; CHECK:       exit:
 ; CHECK-NEXT:    ret i1 [[RES_2]]
 ;

 ; TODO: Keep track of position of assume and may unwinding calls, simplify
 ; conditions if possible.
 define i1 @assume_same_bb_after_may_exiting_call(i8 %a, i8 %b, i1 %c) {
 ; CHECK-LABEL: @assume_same_bb_after_may_exiting_call(
 ; CHECK-NEXT:    [[ADD_1:%.*]] = add nuw nsw i8 [[A:%.*]], 1
 ; CHECK-NEXT:    [[CMP_1:%.*]] = icmp ule i8 [[ADD_1]], [[B:%.*]]
 ; CHECK-NEXT:    call void @may_unwind()
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[CMP_1]])
-; CHECK-NEXT:    [[T_1:%.*]] = icmp ule i8 [[ADD_1]], [[B]]
-; CHECK-NEXT:    [[T_2:%.*]] = icmp ule i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[RES_1:%.*]] = xor i1 true, true
 ; CHECK-NEXT:    [[ADD_2:%.*]] = add nuw nsw i8 [[A]], 2
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ule i8 [[ADD_2]], [[B]]
 ; CHECK-NEXT:    [[RES_2:%.*]] = xor i1 [[RES_1]], [[C_1]]
 ; CHECK-NEXT:    br label [[EXIT:%.*]]
 ; CHECK:       exit:
 ; CHECK-NEXT:    ret i1 [[RES_2]]
 ;

 ; TODO: Keep track of position of assume and may unwinding calls, simplify
 ; conditions if possible.
 define i1 @assume_same_bb_before_may_exiting_call(i8 %a, i8 %b, i1 %c) {
 ; CHECK-LABEL: @assume_same_bb_before_may_exiting_call(
 ; CHECK-NEXT:    [[ADD_1:%.*]] = add nuw nsw i8 [[A:%.*]], 1
 ; CHECK-NEXT:    [[CMP_1:%.*]] = icmp ule i8 [[ADD_1]], [[B:%.*]]
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[CMP_1]])
 ; CHECK-NEXT:    call void @may_unwind()
-; CHECK-NEXT:    [[T_1:%.*]] = icmp ule i8 [[ADD_1]], [[B]]
-; CHECK-NEXT:    [[T_2:%.*]] = icmp ule i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[RES_1:%.*]] = xor i1 true, true
 ; CHECK-NEXT:    [[ADD_2:%.*]] = add nuw nsw i8 [[A]], 2
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ule i8 [[ADD_2]], [[B]]
 ; CHECK-NEXT:    [[RES_2:%.*]] = xor i1 [[RES_1]], [[C_1]]
 ; CHECK-NEXT:    br label [[EXIT:%.*]]
 ; CHECK:       exit:
 ; CHECK-NEXT:    ret i1 [[RES_2]]
 ;

 
 exit:
   ret i1 %res.2
 }
 
 define i1 @assume_same_bb_after_condition(i8 %a, i8 %b, i1 %c) {
 ; CHECK-LABEL: @assume_same_bb_after_condition(
 ; CHECK-NEXT:    [[ADD_1:%.*]] = add nuw nsw i8 [[A:%.*]], 1
-; CHECK-NEXT:    [[T_1:%.*]] = icmp ule i8 [[ADD_1]], [[B:%.*]]
-; CHECK-NEXT:    [[T_2:%.*]] = icmp ule i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[RES_1:%.*]] = xor i1 true, true
 ; CHECK-NEXT:    [[ADD_2:%.*]] = add nuw nsw i8 [[A]], 2
-; CHECK-NEXT:    [[C_1:%.*]] = icmp ule i8 [[ADD_2]], [[B]]
+; CHECK-NEXT:    [[C_1:%.*]] = icmp ule i8 [[ADD_2]], [[B:%.*]]
 ; CHECK-NEXT:    [[RES_2:%.*]] = xor i1 [[RES_1]], [[C_1]]
 ; CHECK-NEXT:    [[CMP_1:%.*]] = icmp ule i8 [[ADD_1]], [[B]]
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[CMP_1]])
 ; CHECK-NEXT:    br label [[EXIT:%.*]]
 ; CHECK:       exit:
 ; CHECK-NEXT:    ret i1 [[RES_2]]
 ;
   %add.1 = add nsw nuw i8 %a, 1

 define i1 @assume_single_bb_conditions_after_assume(i8 %a, i8 %b, i1 %c) {
 ; CHECK-LABEL: @assume_single_bb_conditions_after_assume(
 ; CHECK-NEXT:    [[ADD_1:%.*]] = add nuw nsw i8 [[A:%.*]], 1
 ; CHECK-NEXT:    [[CMP_1:%.*]] = icmp ule i8 [[ADD_1]], [[B:%.*]]
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ule i8 [[ADD_1]], [[B]]
 ; CHECK-NEXT:    call void @use(i1 [[C_1]])
 ; CHECK-NEXT:    call void @may_unwind()
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[CMP_1]])
-; CHECK-NEXT:    [[T_2:%.*]] = icmp ule i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[RES_1:%.*]] = xor i1 true, true
 ; CHECK-NEXT:    [[ADD_2:%.*]] = add nuw nsw i8 [[A]], 2
 ; CHECK-NEXT:    [[C_2:%.*]] = icmp ule i8 [[ADD_2]], [[B]]
 ; CHECK-NEXT:    [[RES_2:%.*]] = xor i1 [[RES_1]], [[C_2]]
 ; CHECK-NEXT:    ret i1 [[RES_2]]
 ;
   %add.1 = add nsw nuw i8 %a, 1
   %cmp.1 = icmp ule i8 %add.1, %b

 ; The definition of %t.2 is before the @llvm.assume call, but all uses are
 ; after the call. %t.2 can be simplified.
 ; TODO
 define i1 @all_uses_after_assume(i8 %a, i8 %b, i1 %c) {
 ; CHECK-LABEL: @all_uses_after_assume(
 ; CHECK-NEXT:    [[ADD_1:%.*]] = add nuw nsw i8 [[A:%.*]], 1
 ; CHECK-NEXT:    [[CMP_1:%.*]] = icmp ule i8 [[ADD_1]], [[B:%.*]]
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ule i8 [[ADD_1]], [[B]]
-; CHECK-NEXT:    [[T_2:%.*]] = icmp ule i8 [[A]], [[B]]
 ; CHECK-NEXT:    call void @use(i1 [[C_1]])
 ; CHECK-NEXT:    call void @may_unwind()
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[CMP_1]])
 ; CHECK-NEXT:    [[RES_1:%.*]] = xor i1 true, true
 ; CHECK-NEXT:    [[ADD_2:%.*]] = add nuw nsw i8 [[A]], 2
 ; CHECK-NEXT:    [[C_2:%.*]] = icmp ule i8 [[ADD_2]], [[B]]
 ; CHECK-NEXT:    [[RES_2:%.*]] = xor i1 [[RES_1]], [[C_2]]
 ; CHECK-NEXT:    ret i1 [[RES_2]]

llvm/test/Transforms/ConstraintElimination/cond-used-in-phi.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -passes=constraint-elimination -S %s | FileCheck %s
 
 declare void @use(i1)
 declare void @llvm.assume(i1)
 
 define void @phi_loop_1(i8 %x) {
 ; CHECK-LABEL: @phi_loop_1(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[C_0:%.*]] = icmp uge i8 [[X:%.*]], 10
 ; CHECK-NEXT:    br i1 [[C_0]], label [[LOOP:%.*]], label [[EXIT:%.*]]
 ; CHECK:       loop:
 ; CHECK-NEXT:    [[IV:%.*]] = phi i8 [ 0, [[ENTRY:%.*]] ], [ [[IV_NEXT:%.*]], [[LOOP]] ]
 ; CHECK-NEXT:    [[C_PHI:%.*]] = phi i1 [ false, [[ENTRY]] ], [ true, [[LOOP]] ]
-; CHECK-NEXT:    [[T_1:%.*]] = icmp uge i8 [[X]], 8
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    [[IV_NEXT]] = add i8 [[IV]], 1
 ; CHECK-NEXT:    [[EC:%.*]] = icmp ult i8 [[IV_NEXT]], 3
 ; CHECK-NEXT:    br i1 [[EC]], label [[LOOP]], label [[LOOP_EXIT:%.*]]
 ; CHECK:       loop.exit:
 ; CHECK-NEXT:    call void @use(i1 [[C_PHI]])
 ; CHECK-NEXT:    br label [[EXIT]]
 ; CHECK:       exit:

 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[C_0:%.*]] = icmp uge i8 [[X:%.*]], 10
 ; CHECK-NEXT:    br i1 [[C_0]], label [[LOOP_1_HEADER:%.*]], label [[EXIT:%.*]]
 ; CHECK:       loop.1.header:
 ; CHECK-NEXT:    [[C_PHI:%.*]] = phi i1 [ false, [[ENTRY:%.*]] ], [ true, [[LOOP_1_LATCH:%.*]] ]
 ; CHECK-NEXT:    br label [[LOOP_2:%.*]]
 ; CHECK:       loop.2:
 ; CHECK-NEXT:    [[IV:%.*]] = phi i8 [ 0, [[LOOP_1_HEADER]] ], [ [[IV_NEXT:%.*]], [[LOOP_2]] ]
-; CHECK-NEXT:    [[T_1:%.*]] = icmp uge i8 [[X]], 8
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    [[IV_NEXT]] = add i8 [[IV]], 1
 ; CHECK-NEXT:    [[EC:%.*]] = icmp ult i8 [[IV_NEXT]], 3
 ; CHECK-NEXT:    br i1 [[EC]], label [[LOOP_2]], label [[LOOP_1_LATCH]]
 ; CHECK:       loop.1.latch:
 ; CHECK-NEXT:    br i1 false, label [[LOOP_1_HEADER]], label [[LOOP_1_EXIT:%.*]]
 ; CHECK:       loop.1.exit:
 ; CHECK-NEXT:    call void @use(i1 [[C_PHI]])

 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[C_0:%.*]] = icmp uge i8 [[X:%.*]], 10
 ; CHECK-NEXT:    br i1 [[C_0]], label [[LOOP:%.*]], label [[EXIT:%.*]]
 ; CHECK:       loop:
 ; CHECK-NEXT:    [[IV:%.*]] = phi i8 [ 0, [[ENTRY:%.*]] ], [ [[IV_NEXT:%.*]], [[LOOP_LATCH:%.*]] ]
 ; CHECK-NEXT:    [[C_PHI:%.*]] = phi i1 [ false, [[ENTRY]] ], [ true, [[LOOP_LATCH]] ]
 ; CHECK-NEXT:    br i1 [[C:%.*]], label [[LOOP_LATCH]], label [[LOOP_EXIT:%.*]]
 ; CHECK:       loop.latch:
-; CHECK-NEXT:    [[T_1:%.*]] = icmp uge i8 [[X]], 8
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    [[IV_NEXT]] = add i8 [[IV]], 1
 ; CHECK-NEXT:    [[EC:%.*]] = icmp ult i8 [[IV_NEXT]], 3
 ; CHECK-NEXT:    br i1 [[EC]], label [[LOOP]], label [[LOOP_EXIT]]
 ; CHECK:       loop.exit:
 ; CHECK-NEXT:    call void @use(i1 [[C_PHI]])
 ; CHECK-NEXT:    br label [[EXIT]]
 ; CHECK:       exit:

 }
 
 define i1 @test_if_then_1(i8 %x) {
 ; CHECK-LABEL: @test_if_then_1(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[CMP1:%.*]] = icmp sgt i8 [[X:%.*]], 1
 ; CHECK-NEXT:    br i1 [[CMP1]], label [[IF:%.*]], label [[JOIN:%.*]]
 ; CHECK:       if:
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp sgt i8 [[X]], 0
 ; CHECK-NEXT:    br label [[JOIN]]
 ; CHECK:       join:
 ; CHECK-NEXT:    [[PHI:%.*]] = phi i1 [ true, [[IF]] ], [ false, [[ENTRY:%.*]] ]
 ; CHECK-NEXT:    ret i1 [[PHI]]
 ;
 entry:
   %cmp1 = icmp sgt i8 %x, 1
   br i1 %cmp1, label %if, label %join
 
 if:
   %cmp2 = icmp sgt i8 %x, 0
   br label %join
 
 join:
   %phi = phi i1 [ %cmp2, %if ], [ false, %entry ]
   ret i1 %phi
 }
 
 
 define i1 @test_if_then_2(i1 %c, i8 %x) {
 ; CHECK-LABEL: @test_if_then_2(
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp sgt i8 [[X:%.*]], 0
 ; CHECK-NEXT:    br i1 [[C:%.*]], label [[IF:%.*]], label [[JOIN:%.*]]
 ; CHECK:       if:
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp sgt i8 [[X]], 1
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp sgt i8 [[X:%.*]], 1
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[CMP1]])
 ; CHECK-NEXT:    br label [[JOIN]]
 ; CHECK:       join:
 ; CHECK-NEXT:    [[PHI:%.*]] = phi i1 [ true, [[IF]] ], [ false, [[ENTRY:%.*]] ]
 ; CHECK-NEXT:    ret i1 [[PHI]]
 ;
 entry:
   %cmp2 = icmp sgt i8 %x, 0

 }
 
 define i1 @test_if_then_4(i1 %c.0, i8 %x) {
 ; CHECK-LABEL: @test_if_then_4(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br i1 [[C_0:%.*]], label [[IF:%.*]], label [[JOIN:%.*]]
 ; CHECK:       if:
 ; CHECK-NEXT:    [[CMP1:%.*]] = icmp sgt i8 [[X:%.*]], 1
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp sgt i8 [[X]], 1
 ; CHECK-NEXT:    br i1 [[CMP1]], label [[THEN_1:%.*]], label [[ELSE_1:%.*]]
 ; CHECK:       then.1:
 ; CHECK-NEXT:    br label [[JOIN]]
 ; CHECK:       else.1:
 ; CHECK-NEXT:    br label [[JOIN]]
 ; CHECK:       join:
 ; CHECK-NEXT:    [[PHI:%.*]] = phi i1 [ false, [[ELSE_1]] ], [ true, [[THEN_1]] ], [ false, [[ENTRY:%.*]] ]
 ; CHECK-NEXT:    ret i1 [[PHI]]

llvm/test/Transforms/ConstraintElimination/constants-signed-predicates.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -passes=constraint-elimination -S %s | FileCheck %s
 
 define i1 @test_slt() {
 ; CHECK-LABEL: @test_slt(
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[T_0:%.*]] = icmp slt i8 10, 11
-; CHECK-NEXT:    [[F_0:%.*]] = icmp slt i8 10, 10
 ; CHECK-NEXT:    [[RES_1:%.*]] = xor i1 true, false
-; CHECK-NEXT:    [[F_1:%.*]] = icmp slt i8 10, 9
 ; CHECK-NEXT:    [[RES_2:%.*]] = xor i1 [[RES_1]], false
-; CHECK-NEXT:    [[F_2:%.*]] = icmp slt i8 10, -10
 ; CHECK-NEXT:    [[RES_3:%.*]] = xor i1 [[RES_2]], false
-; CHECK-NEXT:    [[T_1:%.*]] = icmp slt i8 10, 11
 ; CHECK-NEXT:    [[RES_4:%.*]] = xor i1 [[RES_3]], true
 ; CHECK-NEXT:    ret i1 [[RES_4]]
 ;
 entry:
   %t.0 = icmp slt i8 10, 11
   %f.0 = icmp slt i8 10, 10
   %res.1 = xor i1 %t.0, %f.0
   %f.1 = icmp slt i8 10, 9
   %res.2 = xor i1 %res.1, %f.1
   %f.2 = icmp slt i8 10, -10
   %res.3 = xor i1 %res.2, %f.2
   %t.1 = icmp slt i8 10, 11
   %res.4 = xor i1 %res.3, %t.1
   ret i1 %res.4
 }
 
 define i1 @test_sgt() {
 ; CHECK-LABEL: @test_sgt(
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[T_0:%.*]] = icmp sgt i8 11, 10
-; CHECK-NEXT:    [[F_0:%.*]] = icmp sgt i8 10, 10
 ; CHECK-NEXT:    [[RES_1:%.*]] = xor i1 true, false
-; CHECK-NEXT:    [[F_1:%.*]] = icmp sgt i8 9, 10
 ; CHECK-NEXT:    [[RES_2:%.*]] = xor i1 [[RES_1]], false
-; CHECK-NEXT:    [[F_2:%.*]] = icmp sgt i8 -10, 10
 ; CHECK-NEXT:    [[RES_3:%.*]] = xor i1 [[RES_2]], false
-; CHECK-NEXT:    [[T_1:%.*]] = icmp sgt i8 -1, -2
 ; CHECK-NEXT:    [[RES_4:%.*]] = xor i1 [[RES_3]], true
 ; CHECK-NEXT:    ret i1 [[RES_4]]
 ;
 entry:
   %t.0 = icmp sgt i8 11, 10
   %f.0 = icmp sgt i8 10, 10
   %res.1 = xor i1 %t.0, %f.0
   %f.1 = icmp sgt i8 9, 10
   %res.2 = xor i1 %res.1, %f.1
   %f.2 = icmp sgt i8 -10, 10
   %res.3 = xor i1 %res.2, %f.2
   %t.1 = icmp sgt i8 -1, -2
   %res.4 = xor i1 %res.3, %t.1
   ret i1 %res.4
 }
 
 ; Test cases where lhs - rhs results in constant offset.
 define i1 @test_slt_gep_1(ptr %base) {
 ; CHECK-LABEL: @test_slt_gep_1(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[GEP_1:%.*]] = getelementptr inbounds i8, ptr [[BASE:%.*]], i8 1
 ; CHECK-NEXT:    [[T_0:%.*]] = icmp slt ptr [[BASE]], [[GEP_1]]
 ; CHECK-NEXT:    [[GEP_0:%.*]] = getelementptr inbounds i8, ptr [[BASE]], i8 0
-; CHECK-NEXT:    [[F_0:%.*]] = icmp slt ptr [[BASE]], [[GEP_0]]
 ; CHECK-NEXT:    [[RES_1:%.*]] = xor i1 [[T_0]], false
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp slt ptr [[GEP_1]], [[BASE]]
 ; CHECK-NEXT:    [[RES_2:%.*]] = xor i1 [[RES_1]], [[C_1]]
 ; CHECK-NEXT:    ret i1 [[RES_2]]
 ;
 entry:
   %gep.1 = getelementptr inbounds i8, ptr %base, i8 1
   %t.0 = icmp slt ptr %base, %gep.1

llvm/test/Transforms/ConstraintElimination/constants-unsigned-predicates.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -passes=constraint-elimination -S %s | FileCheck %s
 
 define i1 @test_ult() {
 ; CHECK-LABEL: @test_ult(
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[T_0:%.*]] = icmp ult i8 10, 11
-; CHECK-NEXT:    [[F_0:%.*]] = icmp ult i8 10, 10
 ; CHECK-NEXT:    [[RES_1:%.*]] = xor i1 true, false
-; CHECK-NEXT:    [[F_1:%.*]] = icmp ult i8 10, 9
 ; CHECK-NEXT:    [[RES_2:%.*]] = xor i1 [[RES_1]], false
-; CHECK-NEXT:    [[T_1:%.*]] = icmp ult i8 10, -10
 ; CHECK-NEXT:    [[RES_3:%.*]] = xor i1 [[RES_2]], true
 ; CHECK-NEXT:    ret i1 [[RES_3]]
 ;
 entry:
   %t.0 = icmp ult i8 10, 11
   %f.0 = icmp ult i8 10, 10
   %res.1 = xor i1 %t.0, %f.0
   %f.1 = icmp ult i8 10, 9
   %res.2 = xor i1 %res.1, %f.1
   %t.1 = icmp ult i8 10, -10
   %res.3 = xor i1 %res.2, %t.1
   ret i1 %res.3
 }
 
 ; Test cases where lhs - rhs results in constant offset.
 define i1 @test_ult_gep_1(ptr %base) {
 ; CHECK-LABEL: @test_ult_gep_1(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[GEP_1:%.*]] = getelementptr inbounds i8, ptr [[BASE:%.*]], i8 1
-; CHECK-NEXT:    [[T_0:%.*]] = icmp ult ptr [[BASE]], [[GEP_1]]
 ; CHECK-NEXT:    [[GEP_0:%.*]] = getelementptr inbounds i8, ptr [[BASE]], i8 0
-; CHECK-NEXT:    [[F_0:%.*]] = icmp ult ptr [[BASE]], [[GEP_0]]
 ; CHECK-NEXT:    [[RES_1:%.*]] = xor i1 true, false
-; CHECK-NEXT:    [[F_1:%.*]] = icmp ult ptr [[GEP_1]], [[BASE]]
 ; CHECK-NEXT:    [[RES_2:%.*]] = xor i1 [[RES_1]], false
 ; CHECK-NEXT:    ret i1 [[RES_2]]
 ;
 entry:
   %gep.1 = getelementptr inbounds i8, ptr %base, i8 1
   %t.0 = icmp ult ptr %base, %gep.1
   %gep.0 = getelementptr inbounds i8, ptr %base, i8 0
   %f.0 = icmp ult ptr %base, %gep.0
   %res.1 = xor i1 %t.0, %f.0
   %f.1 = icmp ult ptr %gep.1, %base
   %res.2 = xor i1 %res.1, %f.1
   ret i1 %res.2
 }
 
 define i1 @test_ult_gep_2(ptr %base) {
 ; CHECK-LABEL: @test_ult_gep_2(
 ; CHECK-NEXT:    [[GEP_SUB_1:%.*]] = getelementptr inbounds i8, ptr [[BASE:%.*]], i8 -1
-; CHECK-NEXT:    [[C_1:%.*]] = icmp ult ptr [[BASE]], [[GEP_SUB_1]]
 ; CHECK-NEXT:    ret i1 false
 ;
   %gep.sub.1 = getelementptr inbounds i8, ptr %base, i8 -1
   %c.1 = icmp ult ptr %base, %gep.sub.1
   ret i1 %c.1
 }
 
 define i1 @test_ult_gep_3(ptr %base) {
 ; CHECK-LABEL: @test_ult_gep_3(
 ; CHECK-NEXT:    [[GEP_1_NOINBOUNDS:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i8 1
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ult ptr [[BASE]], [[GEP_1_NOINBOUNDS]]
 ; CHECK-NEXT:    ret i1 [[C_1]]
 ;
   %gep.1.noinbounds = getelementptr i8, ptr %base, i8 1
   %c.1 = icmp ult ptr %base, %gep.1.noinbounds
   ret i1 %c.1
 }
 
 define i1 @test_eq() {
 ; CHECK-LABEL: @test_eq(
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[F_0:%.*]] = icmp eq i8 10, 11
-; CHECK-NEXT:    [[T_0:%.*]] = icmp eq i8 10, 10
 ; CHECK-NEXT:    [[RES_1:%.*]] = xor i1 true, false
-; CHECK-NEXT:    [[F_1:%.*]] = icmp eq i8 10, 9
 ; CHECK-NEXT:    [[RES_2:%.*]] = xor i1 [[RES_1]], false
 ; CHECK-NEXT:    ret i1 [[RES_2]]
 ;
 entry:
   %f.0 = icmp eq i8 10, 11
   %t.0 = icmp eq i8 10, 10
   %res.1 = xor i1 %t.0, %f.0
   %f.1 = icmp eq i8 10, 9
   %res.2 = xor i1 %res.1, %f.1
   ret i1 %res.2
 }
 
 define i1 @test_ne() {
 ; CHECK-LABEL: @test_ne(
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[T_0:%.*]] = icmp ne i8 10, 11
-; CHECK-NEXT:    [[F_0:%.*]] = icmp ne i8 10, 10
 ; CHECK-NEXT:    [[RES_1:%.*]] = xor i1 true, false
-; CHECK-NEXT:    [[T_1:%.*]] = icmp ne i8 10, 9
 ; CHECK-NEXT:    [[RES_2:%.*]] = xor i1 [[RES_1]], true
 ; CHECK-NEXT:    ret i1 [[RES_2]]
 ;
 entry:
   %t.0 = icmp ne i8 10, 11
   %f.0 = icmp ne i8 10, 10
   %res.1 = xor i1 %t.0, %f.0
   %t.1 = icmp ne i8 10, 9
   %res.2 = xor i1 %res.1, %t.1
   ret i1 %res.2
 }

llvm/test/Transforms/ConstraintElimination/decompose-with-temporary-indices.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -passes=constraint-elimination -S %s | FileCheck %s
 
 declare void @use(i1)
 
 
 define i1 @test_uge_temporary_indices_decompose(i8 %start, i8 %n, i8 %idx) {
 ; CHECK-LABEL: @test_uge_temporary_indices_decompose(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[CMP_PRE:%.*]] = icmp ult i8 [[IDX:%.*]], [[N:%.*]]
 ; CHECK-NEXT:    [[START_ADD_IDX:%.*]] = add nuw nsw i8 [[START:%.*]], [[IDX]]
 ; CHECK-NEXT:    [[START_ADD_N:%.*]] = add nuw nsw i8 [[START]], [[N]]
 ; CHECK-NEXT:    [[START_ADD_1:%.*]] = add nuw nsw i8 [[START]], 1
 ; CHECK-NEXT:    br i1 [[CMP_PRE]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
 ; CHECK:       if.then:
-; CHECK-NEXT:    [[T_0:%.*]] = icmp ult i8 [[START_ADD_IDX]], [[START_ADD_N]]
-; CHECK-NEXT:    [[F_0:%.*]] = icmp uge i8 [[START_ADD_IDX]], [[START_ADD_N]]
 ; CHECK-NEXT:    [[R_1:%.*]] = xor i1 true, false
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ult i8 [[START_ADD_1]], [[START_ADD_N]]
 ; CHECK-NEXT:    [[R_2:%.*]] = xor i1 [[R_1]], [[C_1]]
 ; CHECK-NEXT:    [[C_2:%.*]] = icmp ult i8 [[START_ADD_IDX]], [[START_ADD_1]]
 ; CHECK-NEXT:    [[R_3:%.*]] = xor i1 [[R_2]], [[C_2]]
 ; CHECK-NEXT:    ret i1 [[R_3]]
 ; CHECK:       if.end:
-; CHECK-NEXT:    [[F_1:%.*]] = icmp ult i8 [[START_ADD_IDX]], [[START_ADD_N]]
-; CHECK-NEXT:    [[T_1:%.*]] = icmp uge i8 [[START_ADD_IDX]], [[START_ADD_N]]
 ; CHECK-NEXT:    [[R_4:%.*]] = xor i1 false, true
 ; CHECK-NEXT:    [[C_3:%.*]] = icmp ult i8 [[START_ADD_1]], [[START_ADD_N]]
 ; CHECK-NEXT:    [[R_5:%.*]] = xor i1 [[R_4]], [[C_3]]
 ; CHECK-NEXT:    [[C_4:%.*]] = icmp ult i8 [[START_ADD_IDX]], [[START_ADD_1]]
 ; CHECK-NEXT:    [[R_6:%.*]] = xor i1 [[R_5]], [[C_4]]
 ; CHECK-NEXT:    ret i1 [[R_6]]
 ;
 entry:

llvm/test/Transforms/ConstraintElimination/dom.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -passes=constraint-elimination -S %s | FileCheck %s
 
 ; Test cases where both the true and false successors reach the same block,
 ; dominated by one of them.
 
 declare void @use(i1)
 
 define i1 @test1(i8 %x) {
 ; CHECK-LABEL: @test1(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ule i8 [[X:%.*]], 10
 ; CHECK-NEXT:    br i1 [[C_1]], label [[BB1:%.*]], label [[BB2:%.*]]
 ; CHECK:       bb1:
-; CHECK-NEXT:    [[C_2:%.*]] = icmp ule i8 [[X]], 10
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    br label [[BB2]]
 ; CHECK:       bb2:
 ; CHECK-NEXT:    [[C_3:%.*]] = icmp ugt i8 [[X]], 10
 ; CHECK-NEXT:    ret i1 [[C_3]]
 ;
 entry:
   %c.1 = icmp ule i8 %x, 10

 }
 
 define i1 @test_chain_1(i8 %x) {
 ; CHECK-LABEL: @test_chain_1(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ule i8 [[X:%.*]], 10
 ; CHECK-NEXT:    br i1 [[C_1]], label [[THEN:%.*]], label [[ELSE:%.*]]
 ; CHECK:       then:
-; CHECK-NEXT:    [[C_2:%.*]] = icmp ule i8 [[X]], 10
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    br label [[EXIT:%.*]]
 ; CHECK:       else:
 ; CHECK-NEXT:    br label [[EXIT]]
 ; CHECK:       exit:
 ; CHECK-NEXT:    [[C_3:%.*]] = icmp ugt i8 [[X]], 10
 ; CHECK-NEXT:    ret i1 [[C_3]]
 ;

 define i1 @test_chain_2(i8 %x) {
 ; CHECK-LABEL: @test_chain_2(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ule i8 [[X:%.*]], 10
 ; CHECK-NEXT:    br i1 [[C_1]], label [[THEN:%.*]], label [[ELSE:%.*]]
 ; CHECK:       then:
 ; CHECK-NEXT:    br label [[EXIT:%.*]]
 ; CHECK:       else:
-; CHECK-NEXT:    [[C_2:%.*]] = icmp ule i8 [[X]], 10
 ; CHECK-NEXT:    call void @use(i1 false)
 ; CHECK-NEXT:    br label [[EXIT]]
 ; CHECK:       exit:
 ; CHECK-NEXT:    [[C_3:%.*]] = icmp ugt i8 [[X]], 10
 ; CHECK-NEXT:    ret i1 [[C_3]]
 ;
 entry:
   %c.1 = icmp ule i8 %x, 10

 ; CHECK-LABEL: @test2(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ule i8 [[X:%.*]], 10
 ; CHECK-NEXT:    br i1 [[C_1]], label [[BB2:%.*]], label [[BB1:%.*]]
 ; CHECK:       bb1:
 ; CHECK-NEXT:    [[C_2:%.*]] = icmp ugt i8 [[X]], 10
 ; CHECK-NEXT:    ret i1 [[C_2]]
 ; CHECK:       bb2:
-; CHECK-NEXT:    [[C_3:%.*]] = icmp ule i8 [[X]], 10
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    br label [[BB1]]
 ;
 entry:
   %c.1 = icmp ule i8 %x, 10
   br i1 %c.1, label %bb2, label %bb1
 
 bb1:

 ; CHECK-NEXT:    br i1 [[C:%.*]], label [[BB_COND:%.*]], label [[BB1:%.*]]
 ; CHECK:       bb.cond:
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ule i8 [[X:%.*]], 10
 ; CHECK-NEXT:    br i1 [[C_1]], label [[BB1]], label [[BB2:%.*]]
 ; CHECK:       bb1:
 ; CHECK-NEXT:    [[C_2:%.*]] = icmp ule i8 [[X]], 10
 ; CHECK-NEXT:    ret i1 [[C_2]]
 ; CHECK:       bb2:
-; CHECK-NEXT:    [[C_3:%.*]] = icmp ugt i8 [[X]], 10
 ; CHECK-NEXT:    ret i1 true
 ;
 entry:
   br i1 %c, label %bb.cond, label %bb1
 
 bb.cond:
   %c.1 = icmp ule i8 %x, 10
   br i1 %c.1, label %bb1, label %bb2

 define i1 @test4(i8 %x, i1 %c) {
 ; CHECK-LABEL: @test4(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br i1 [[C:%.*]], label [[BB_COND:%.*]], label [[BB2:%.*]]
 ; CHECK:       bb.cond:
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ule i8 [[X:%.*]], 10
 ; CHECK-NEXT:    br i1 [[C_1]], label [[BB1:%.*]], label [[BB2]]
 ; CHECK:       bb1:
-; CHECK-NEXT:    [[C_2:%.*]] = icmp ule i8 [[X]], 10
 ; CHECK-NEXT:    ret i1 true
 ; CHECK:       bb2:
 ; CHECK-NEXT:    [[C_3:%.*]] = icmp ugt i8 [[X]], 10
 ; CHECK-NEXT:    ret i1 [[C_3]]
 ;
 entry:
   br i1 %c, label %bb.cond, label %bb2
 

 define i1 @test_cond_from_preheader(i8 %x, i1 %c) {
 ; CHECK-LABEL: @test_cond_from_preheader(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br i1 [[C:%.*]], label [[PRE:%.*]], label [[BB2:%.*]]
 ; CHECK:       pre:
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ule i8 [[X:%.*]], 10
 ; CHECK-NEXT:    br i1 [[C_1]], label [[LOOP:%.*]], label [[BB2]]
 ; CHECK:       loop:
-; CHECK-NEXT:    [[T_1:%.*]] = icmp ule i8 [[X]], 10
 ; CHECK-NEXT:    call void @use(i1 true)
-; CHECK-NEXT:    [[F_1:%.*]] = icmp ugt i8 [[X]], 10
 ; CHECK-NEXT:    call void @use(i1 false)
 ; CHECK-NEXT:    [[C_2:%.*]] = icmp ule i8 [[X]], 9
 ; CHECK-NEXT:    call void @use(i1 [[C_2]])
 ; CHECK-NEXT:    [[C_3:%.*]] = icmp ugt i8 [[X]], 9
 ; CHECK-NEXT:    call void @use(i1 [[C_3]])
 ; CHECK-NEXT:    br i1 true, label [[EXIT:%.*]], label [[LOOP]]
 ; CHECK:       exit:
-; CHECK-NEXT:    [[C_4:%.*]] = icmp ule i8 [[X]], 10
 ; CHECK-NEXT:    ret i1 true
 ; CHECK:       bb2:
 ; CHECK-NEXT:    [[C_5:%.*]] = icmp ugt i8 [[X]], 10
 ; CHECK-NEXT:    ret i1 [[C_5]]
 ;
 entry:
   br i1 %c, label %pre, label %bb2
 

 define i1 @test_cond_from_preheader_successors_flipped(i8 %x, i1 %c) {
 ; CHECK-LABEL: @test_cond_from_preheader_successors_flipped(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br i1 [[C:%.*]], label [[PRE:%.*]], label [[BB2:%.*]]
 ; CHECK:       pre:
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ule i8 [[X:%.*]], 10
 ; CHECK-NEXT:    br i1 [[C_1]], label [[BB2]], label [[LOOP:%.*]]
 ; CHECK:       loop:
-; CHECK-NEXT:    [[F_1:%.*]] = icmp ule i8 [[X]], 10
 ; CHECK-NEXT:    call void @use(i1 false)
-; CHECK-NEXT:    [[T_1:%.*]] = icmp ugt i8 [[X]], 10
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    [[C_2:%.*]] = icmp ule i8 [[X]], 11
 ; CHECK-NEXT:    call void @use(i1 [[C_2]])
 ; CHECK-NEXT:    [[C_3:%.*]] = icmp ugt i8 [[X]], 11
 ; CHECK-NEXT:    call void @use(i1 [[C_3]])
 ; CHECK-NEXT:    br i1 true, label [[EXIT:%.*]], label [[LOOP]]
 ; CHECK:       exit:
-; CHECK-NEXT:    [[F_2:%.*]] = icmp ule i8 [[X]], 10
 ; CHECK-NEXT:    ret i1 false
 ; CHECK:       bb2:
 ; CHECK-NEXT:    [[C_5:%.*]] = icmp ugt i8 [[X]], 10
 ; CHECK-NEXT:    ret i1 [[C_5]]
 ;
 entry:
   br i1 %c, label %pre, label %bb2
 

 ; CHECK-NEXT:    [[C_5:%.*]] = icmp ugt i8 [[Y:%.*]], 10
 ; CHECK-NEXT:    ret i1 [[C_5]]
 ; CHECK:       pre:
 ; CHECK-NEXT:    [[X_1:%.*]] = icmp ule i8 [[X:%.*]], 10
 ; CHECK-NEXT:    [[Y_1:%.*]] = icmp ugt i8 [[Y]], 99
 ; CHECK-NEXT:    [[AND:%.*]] = and i1 [[X_1]], [[Y_1]]
 ; CHECK-NEXT:    br i1 [[AND]], label [[LOOP:%.*]], label [[EXIT_1:%.*]]
 ; CHECK:       loop:
-; CHECK-NEXT:    [[T_1:%.*]] = icmp ule i8 [[X]], 10
-; CHECK-NEXT:    [[F_1:%.*]] = icmp ugt i8 [[X]], 10
 ; CHECK-NEXT:    [[R_1:%.*]] = xor i1 true, false
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ule i8 [[X]], 9
 ; CHECK-NEXT:    [[R_2:%.*]] = xor i1 [[R_1]], [[C_1]]
 ; CHECK-NEXT:    [[C_2:%.*]] = icmp ugt i8 [[X]], 9
 ; CHECK-NEXT:    [[R_3:%.*]] = xor i1 [[R_2]], [[C_2]]
-; CHECK-NEXT:    [[T_2:%.*]] = icmp ugt i8 [[Y]], 99
 ; CHECK-NEXT:    [[R_4:%.*]] = xor i1 [[R_3]], true
-; CHECK-NEXT:    [[F_2:%.*]] = icmp ule i8 [[Y]], 99
 ; CHECK-NEXT:    [[R_5:%.*]] = xor i1 [[R_4]], false
 ; CHECK-NEXT:    [[C_3:%.*]] = icmp ugt i8 [[Y]], 100
 ; CHECK-NEXT:    [[R_6:%.*]] = xor i1 [[R_5]], [[C_3]]
 ; CHECK-NEXT:    [[C_4:%.*]] = icmp ugt i8 [[Y]], 100
 ; CHECK-NEXT:    [[R_7:%.*]] = xor i1 [[R_6]], [[C_4]]
 ; CHECK-NEXT:    call void @use(i1 [[R_7]])
 ; CHECK-NEXT:    br i1 true, label [[EXIT]], label [[LOOP]]
 ; CHECK:       exit.1:

 ; CHECK-NEXT:    [[R_5:%.*]] = xor i1 [[R_4]], [[C_6]]
 ; CHECK-NEXT:    [[C_7:%.*]] = icmp ugt i8 [[Y]], 100
 ; CHECK-NEXT:    [[R_6:%.*]] = xor i1 [[R_5]], [[C_7]]
 ; CHECK-NEXT:    [[C_8:%.*]] = icmp ugt i8 [[Y]], 100
 ; CHECK-NEXT:    [[R_7:%.*]] = xor i1 [[R_6]], [[C_8]]
 ; CHECK-NEXT:    call void @use(i1 [[R_7]])
 ; CHECK-NEXT:    br i1 true, label [[EXIT]], label [[LOOP]]
 ; CHECK:       exit.1:
-; CHECK-NEXT:    [[T_1:%.*]] = icmp ugt i8 [[Y]], 10
 ; CHECK-NEXT:    ret i1 true
 ;
 entry:
   br i1 %c, label %pre, label %exit
 
 exit:
   %c.9 = icmp ugt i8 %y, 10
   ret i1 %c.9

 ; CHECK-NEXT:    [[C_5:%.*]] = icmp ugt i8 [[Y:%.*]], 10
 ; CHECK-NEXT:    ret i1 [[C_5]]
 ; CHECK:       pre:
 ; CHECK-NEXT:    [[X_1:%.*]] = icmp ule i8 [[X:%.*]], 10
 ; CHECK-NEXT:    [[Y_1:%.*]] = icmp ugt i8 [[Y]], 99
 ; CHECK-NEXT:    [[OR:%.*]] = or i1 [[X_1]], [[Y_1]]
 ; CHECK-NEXT:    br i1 [[OR]], label [[EXIT_1:%.*]], label [[LOOP:%.*]]
 ; CHECK:       loop:
-; CHECK-NEXT:    [[T_1:%.*]] = icmp ugt i8 [[X]], 10
-; CHECK-NEXT:    [[F_1:%.*]] = icmp ule i8 [[X]], 10
 ; CHECK-NEXT:    [[R_1:%.*]] = xor i1 true, false
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ugt i8 [[X]], 11
 ; CHECK-NEXT:    [[R_2:%.*]] = xor i1 [[R_1]], [[C_1]]
 ; CHECK-NEXT:    [[C_2:%.*]] = icmp ule i8 [[X]], 11
 ; CHECK-NEXT:    [[R_3:%.*]] = xor i1 [[R_2]], [[C_2]]
-; CHECK-NEXT:    [[T_2:%.*]] = icmp ule i8 [[Y]], 99
 ; CHECK-NEXT:    [[R_4:%.*]] = xor i1 [[R_3]], true
-; CHECK-NEXT:    [[F_2:%.*]] = icmp ugt i8 [[Y]], 99
 ; CHECK-NEXT:    [[R_5:%.*]] = xor i1 [[R_4]], false
 ; CHECK-NEXT:    [[C_3:%.*]] = icmp ule i8 [[Y]], 98
 ; CHECK-NEXT:    [[R_6:%.*]] = xor i1 [[R_5]], [[C_3]]
 ; CHECK-NEXT:    [[C_4:%.*]] = icmp ule i8 [[Y]], 98
 ; CHECK-NEXT:    [[R_7:%.*]] = xor i1 [[R_6]], [[C_4]]
 ; CHECK-NEXT:    call void @use(i1 [[R_7]])
 ; CHECK-NEXT:    br i1 true, label [[EXIT]], label [[LOOP]]
 ; CHECK:       exit.1:

 ; CHECK-NEXT:    [[R_5:%.*]] = xor i1 [[R_4]], [[C_6]]
 ; CHECK-NEXT:    [[C_7:%.*]] = icmp ugt i8 [[Y]], 100
 ; CHECK-NEXT:    [[R_6:%.*]] = xor i1 [[R_5]], [[C_7]]
 ; CHECK-NEXT:    [[C_8:%.*]] = icmp ugt i8 [[Y]], 100
 ; CHECK-NEXT:    [[R_7:%.*]] = xor i1 [[R_6]], [[C_8]]
 ; CHECK-NEXT:    call void @use(i1 [[R_7]])
 ; CHECK-NEXT:    br i1 true, label [[EXIT]], label [[LOOP]]
 ; CHECK:       exit.1:
-; CHECK-NEXT:    [[T_1:%.*]] = icmp ule i8 [[Y]], 100
 ; CHECK-NEXT:    ret i1 true
 ;
 entry:
   br i1 %c, label %pre, label %exit
 
 exit:
   %c.9 = icmp ugt i8 %y, 10
   ret i1 %c.9

llvm/test/Transforms/ConstraintElimination/empty-constraint.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -passes=constraint-elimination -S %s | FileCheck %s
 
 ; Make sure constraints where all variable coefficients are 0 are handled
 ; properly.
 
 define i1 @test_1_always_false(i32 %A, i32 %B) {
 ; CHECK-LABEL: @test_1_always_false(
-; CHECK-NEXT:    [[C_1:%.*]] = icmp ugt i32 [[A:%.*]], [[A]]
 ; CHECK-NEXT:    br i1 false, label [[IF_END_I16:%.*]], label [[IF_THEN_I10:%.*]]
 ; CHECK:       if.then.i10:
 ; CHECK-NEXT:    ret i1 false
 ; CHECK:       if.end.i16:
-; CHECK-NEXT:    [[C_2:%.*]] = icmp ugt i32 [[A]], [[A]]
 ; CHECK-NEXT:    ret i1 false
 ;
   %c.1 = icmp ugt i32 %A, %A
   br i1 %c.1, label %if.end.i16, label %if.then.i10
 
 if.then.i10:
   ret i1 false
 
 if.end.i16:
   %c.2 = icmp ugt i32 %A, %A
   ret i1 %c.2
 }
 
 define i1 @test_2_always_true(i32 %A, i32 %B) {
 ; CHECK-LABEL: @test_2_always_true(
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp uge i32 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    br i1 [[C_1]], label [[IF_END_I16:%.*]], label [[IF_THEN_I10:%.*]]
 ; CHECK:       if.then.i10:
 ; CHECK-NEXT:    ret i1 false
 ; CHECK:       if.end.i16:
-; CHECK-NEXT:    [[C_2:%.*]] = icmp uge i32 [[A]], [[A]]
 ; CHECK-NEXT:    ret i1 true
 ;
   %c.1 = icmp uge i32 %A, %B
   br i1 %c.1, label %if.end.i16, label %if.then.i10
 
 if.then.i10:
   ret i1 false
 
 if.end.i16:
   %c.2 = icmp uge i32 %A, %A
   ret i1 %c.2
 }

llvm/test/Transforms/ConstraintElimination/eq.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -passes=constraint-elimination -S %s | FileCheck %s
 
 declare void @llvm.assume(i1)
 
 define i1 @test_eq_1(i8 %a, i8 %b) {
 ; CHECK-LABEL: @test_eq_1(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i8 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    br i1 [[CMP]], label [[THEN:%.*]], label [[ELSE:%.*]]
 ; CHECK:       then:
-; CHECK-NEXT:    [[T_1:%.*]] = icmp uge i8 [[A]], [[B]]
-; CHECK-NEXT:    [[T_2:%.*]] = icmp ule i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[RES_1:%.*]] = xor i1 true, true
-; CHECK-NEXT:    [[T_3:%.*]] = icmp eq i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[RES_2:%.*]] = xor i1 [[RES_1]], true
-; CHECK-NEXT:    [[T_4:%.*]] = icmp eq i8 [[B]], [[A]]
 ; CHECK-NEXT:    [[RES_3:%.*]] = xor i1 [[RES_2]], true
-; CHECK-NEXT:    [[F_1:%.*]] = icmp ugt i8 [[B]], [[A]]
 ; CHECK-NEXT:    [[RES_4:%.*]] = xor i1 [[RES_3]], false
-; CHECK-NEXT:    [[F_2:%.*]] = icmp ult i8 [[B]], [[A]]
 ; CHECK-NEXT:    [[RES_5:%.*]] = xor i1 [[RES_4]], false
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ult i8 [[B]], 99
 ; CHECK-NEXT:    [[RES_6:%.*]] = xor i1 [[RES_5]], [[C_1]]
 ; CHECK-NEXT:    ret i1 [[RES_6]]
 ; CHECK:       else:
 ; CHECK-NEXT:    [[F_3:%.*]] = icmp eq i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[F_4:%.*]] = icmp eq i8 [[B]], [[A]]
 ; CHECK-NEXT:    [[RES_7:%.*]] = xor i1 [[F_3]], [[F_4]]

 ; CHECK-LABEL: @test_eq_2(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[PRE_1:%.*]] = icmp eq i8 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    br i1 [[PRE_1]], label [[THEN:%.*]], label [[ELSE:%.*]]
 ; CHECK:       then:
 ; CHECK-NEXT:    [[PRE_3:%.*]] = icmp ult i8 [[B]], 100
 ; CHECK-NEXT:    br i1 [[PRE_3]], label [[THEN_THEN:%.*]], label [[THEN_ELSE:%.*]]
 ; CHECK:       then.then:
-; CHECK-NEXT:    [[T_1:%.*]] = icmp ult i8 [[A]], 100
-; CHECK-NEXT:    [[T_2:%.*]] = icmp ult i8 [[B]], 100
 ; CHECK-NEXT:    [[XOR_1:%.*]] = xor i1 true, true
-; CHECK-NEXT:    [[F_1:%.*]] = icmp uge i8 [[A]], 100
 ; CHECK-NEXT:    [[XOR_2:%.*]] = xor i1 [[XOR_1]], false
-; CHECK-NEXT:    [[F_2:%.*]] = icmp uge i8 [[B]], 100
 ; CHECK-NEXT:    [[XOR_3:%.*]] = xor i1 [[XOR_2]], false
-; CHECK-NEXT:    [[F_3_1:%.*]] = icmp ugt i8 [[A]], 99
 ; CHECK-NEXT:    [[XOR_4:%.*]] = xor i1 [[XOR_3]], false
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ult i8 [[A]], 99
 ; CHECK-NEXT:    [[XOR_5:%.*]] = xor i1 [[XOR_4]], [[C_1]]
 ; CHECK-NEXT:    [[C_2:%.*]] = icmp ugt i8 [[A]], 98
 ; CHECK-NEXT:    [[XOR_6:%.*]] = xor i1 [[XOR_5]], [[C_1]]
 ; CHECK-NEXT:    ret i1 [[XOR_6]]
 ; CHECK:       then.else:
-; CHECK-NEXT:    [[F_4:%.*]] = icmp ult i8 [[A]], 100
-; CHECK-NEXT:    [[F_5:%.*]] = icmp ult i8 [[B]], 100
 ; CHECK-NEXT:    [[XOR_7:%.*]] = xor i1 false, false
-; CHECK-NEXT:    [[T_3:%.*]] = icmp uge i8 [[A]], 100
 ; CHECK-NEXT:    [[XOR_8:%.*]] = xor i1 [[XOR_7]], true
-; CHECK-NEXT:    [[T_4:%.*]] = icmp uge i8 [[B]], 100
 ; CHECK-NEXT:    [[XOR_9:%.*]] = xor i1 [[XOR_8]], true
-; CHECK-NEXT:    [[T_5:%.*]] = icmp ugt i8 [[A]], 99
 ; CHECK-NEXT:    [[XOR_10:%.*]] = xor i1 [[XOR_9]], true
-; CHECK-NEXT:    [[C_3:%.*]] = icmp ult i8 [[A]], 99
 ; CHECK-NEXT:    [[XOR_11:%.*]] = xor i1 [[XOR_10]], false
-; CHECK-NEXT:    [[C_4:%.*]] = icmp ugt i8 [[A]], 98
 ; CHECK-NEXT:    [[XOR_12:%.*]] = xor i1 [[XOR_11]], true
 ; CHECK-NEXT:    ret i1 [[XOR_12]]
 ; CHECK:       else:
 ; CHECK-NEXT:    [[CMP_2:%.*]] = icmp ult i8 [[A]], 100
 ; CHECK-NEXT:    ret i1 [[CMP_2]]
 ;
 entry:
   %pre.1 = icmp eq i8 %a, %b

 ; CHECK-NEXT:    [[PRE_1:%.*]] = icmp uge i8 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    [[PRE_2:%.*]] = icmp ule i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[PRE_AND:%.*]] = and i1 [[PRE_1]], [[PRE_2]]
 ; CHECK-NEXT:    br i1 [[PRE_AND]], label [[THEN:%.*]], label [[ELSE:%.*]]
 ; CHECK:       then:
 ; CHECK-NEXT:    [[PRE_3:%.*]] = icmp ult i8 [[B]], 100
 ; CHECK-NEXT:    br i1 [[PRE_3]], label [[THEN_THEN:%.*]], label [[THEN_ELSE:%.*]]
 ; CHECK:       then.then:
-; CHECK-NEXT:    [[T_1:%.*]] = icmp ult i8 [[A]], 100
-; CHECK-NEXT:    [[T_2:%.*]] = icmp ult i8 [[B]], 100
 ; CHECK-NEXT:    [[XOR_1:%.*]] = xor i1 true, true
-; CHECK-NEXT:    [[F_1:%.*]] = icmp uge i8 [[A]], 100
 ; CHECK-NEXT:    [[XOR_2:%.*]] = xor i1 [[XOR_1]], false
-; CHECK-NEXT:    [[F_2:%.*]] = icmp uge i8 [[B]], 100
 ; CHECK-NEXT:    [[XOR_3:%.*]] = xor i1 [[XOR_2]], false
-; CHECK-NEXT:    [[F_3_1:%.*]] = icmp ugt i8 [[A]], 99
 ; CHECK-NEXT:    [[XOR_4:%.*]] = xor i1 [[XOR_3]], false
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ult i8 [[A]], 99
 ; CHECK-NEXT:    [[XOR_5:%.*]] = xor i1 [[XOR_4]], [[C_1]]
 ; CHECK-NEXT:    [[C_2:%.*]] = icmp ugt i8 [[A]], 98
 ; CHECK-NEXT:    [[XOR_6:%.*]] = xor i1 [[XOR_5]], [[C_1]]
 ; CHECK-NEXT:    ret i1 [[XOR_6]]
 ; CHECK:       then.else:
-; CHECK-NEXT:    [[F_4:%.*]] = icmp ult i8 [[A]], 100
-; CHECK-NEXT:    [[F_5:%.*]] = icmp ult i8 [[B]], 100
 ; CHECK-NEXT:    [[XOR_7:%.*]] = xor i1 false, false
-; CHECK-NEXT:    [[T_3:%.*]] = icmp uge i8 [[A]], 100
 ; CHECK-NEXT:    [[XOR_8:%.*]] = xor i1 [[XOR_7]], true
-; CHECK-NEXT:    [[T_4:%.*]] = icmp uge i8 [[B]], 100
 ; CHECK-NEXT:    [[XOR_9:%.*]] = xor i1 [[XOR_8]], true
-; CHECK-NEXT:    [[T_5:%.*]] = icmp ugt i8 [[A]], 99
 ; CHECK-NEXT:    [[XOR_10:%.*]] = xor i1 [[XOR_9]], true
-; CHECK-NEXT:    [[C_3:%.*]] = icmp ult i8 [[A]], 99
 ; CHECK-NEXT:    [[XOR_11:%.*]] = xor i1 [[XOR_10]], false
-; CHECK-NEXT:    [[C_4:%.*]] = icmp ugt i8 [[A]], 98
 ; CHECK-NEXT:    [[XOR_12:%.*]] = xor i1 [[XOR_11]], true
 ; CHECK-NEXT:    ret i1 [[XOR_12]]
 ; CHECK:       else:
 ; CHECK-NEXT:    [[CMP_2:%.*]] = icmp ult i8 [[A]], 100
 ; CHECK-NEXT:    ret i1 [[CMP_2]]
 ;
 entry:
   %pre.1 = icmp uge i8 %a, %b

 define i1 @test_eq_ult_and(i8 %a, i8 %b) {
 ; CHECK-LABEL: @test_eq_ult_and(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[PRE_1:%.*]] = icmp eq i8 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    [[PRE_2:%.*]] = icmp ult i8 [[B]], 100
 ; CHECK-NEXT:    [[PRE_AND:%.*]] = and i1 [[PRE_1]], [[PRE_2]]
 ; CHECK-NEXT:    br i1 [[PRE_AND]], label [[THEN:%.*]], label [[ELSE:%.*]]
 ; CHECK:       then:
-; CHECK-NEXT:    [[T_1:%.*]] = icmp ult i8 [[A]], 100
-; CHECK-NEXT:    [[T_2:%.*]] = icmp ult i8 [[B]], 100
 ; CHECK-NEXT:    [[XOR_1:%.*]] = xor i1 true, true
-; CHECK-NEXT:    [[F_1:%.*]] = icmp uge i8 [[A]], 100
 ; CHECK-NEXT:    [[XOR_2:%.*]] = xor i1 [[XOR_1]], false
-; CHECK-NEXT:    [[F_2:%.*]] = icmp uge i8 [[B]], 100
 ; CHECK-NEXT:    [[XOR_3:%.*]] = xor i1 [[XOR_2]], false
-; CHECK-NEXT:    [[F_3_1:%.*]] = icmp ugt i8 [[A]], 99
 ; CHECK-NEXT:    [[XOR_4:%.*]] = xor i1 [[XOR_3]], false
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ult i8 [[A]], 99
 ; CHECK-NEXT:    [[XOR_5:%.*]] = xor i1 [[XOR_4]], [[C_1]]
 ; CHECK-NEXT:    [[C_2:%.*]] = icmp ugt i8 [[A]], 98
 ; CHECK-NEXT:    [[XOR_6:%.*]] = xor i1 [[XOR_5]], [[C_1]]
 ; CHECK-NEXT:    ret i1 [[XOR_6]]
 ; CHECK:       else:
 ; CHECK-NEXT:    [[F_4:%.*]] = icmp ult i8 [[A]], 100
else:
   ret i1 %xor.12
 }
 
 define i1 @assume_b_plus_1_ult_a(i64 %a, i64 %b)  {
 ; CHECK-LABEL: @assume_b_plus_1_ult_a(
 ; CHECK-NEXT:    [[TMP1:%.*]] = add nuw i64 [[B:%.*]], 1
 ; CHECK-NEXT:    [[TMP2:%.*]] = icmp ult i64 [[TMP1]], [[A:%.*]]
 ; CHECK-NEXT:    tail call void @llvm.assume(i1 [[TMP2]])
-; CHECK-NEXT:    [[TMP3:%.*]] = icmp eq i64 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 false
 ;
   %1 = add nuw i64 %b, 1
   %2 = icmp ult i64 %1, %a
   tail call void @llvm.assume(i1 %2)
   %3 = icmp eq i64 %a, %b
   ret i1 %3
 }
 
 define i1 @assume_a_plus_1_eq_b(i64 %a, i64 %b)  {
 ; CHECK-LABEL: @assume_a_plus_1_eq_b(
 ; CHECK-NEXT:    [[TMP1:%.*]] = add nuw i64 [[A:%.*]], 1
 ; CHECK-NEXT:    [[TMP2:%.*]] = icmp eq i64 [[TMP1]], [[B:%.*]]
 ; CHECK-NEXT:    tail call void @llvm.assume(i1 [[TMP2]])
-; CHECK-NEXT:    [[TMP3:%.*]] = icmp eq i64 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 false
 ;
   %1 = add nuw i64 %a, 1
   %2 = icmp eq i64 %1, %b
   tail call void @llvm.assume(i1 %2)
   %3 = icmp eq i64 %a, %b
   ret i1 %3
 }

 ; CHECK-LABEL: @test_transitivity_of_equality_and_plus_1(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[PRE_1:%.*]] = icmp eq i64 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    br i1 [[PRE_1]], label [[AB_EQUAL:%.*]], label [[NOT_EQ:%.*]]
 ; CHECK:       ab_equal:
 ; CHECK-NEXT:    [[BC_EQ:%.*]] = icmp eq i64 [[B]], [[C:%.*]]
 ; CHECK-NEXT:    br i1 [[BC_EQ]], label [[BC_EQUAL:%.*]], label [[NOT_EQ]]
 ; CHECK:       bc_equal:
-; CHECK-NEXT:    [[AC_EQ:%.*]] = icmp eq i64 [[A]], [[C]]
 ; CHECK-NEXT:    [[A_PLUS_1:%.*]] = add nuw i64 [[A]], 1
 ; CHECK-NEXT:    [[C_PLUS_1:%.*]] = add nuw i64 [[C]], 1
-; CHECK-NEXT:    [[AC_PLUS_1_EQ:%.*]] = icmp eq i64 [[A_PLUS_1]], [[C_PLUS_1]]
 ; CHECK-NEXT:    [[RESULT:%.*]] = and i1 true, true
 ; CHECK-NEXT:    ret i1 [[RESULT]]
 ; CHECK:       not_eq:
 ; CHECK-NEXT:    ret i1 false
 ;
 entry:
   %pre.1 = icmp eq i64 %a, %b
   br i1 %pre.1, label %ab_equal, label %not_eq

llvm/test/Transforms/ConstraintElimination/gep-add-multiple-indices.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -passes=constraint-elimination -S %s | FileCheck %s
 
 target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
 
 define i1 @test_outer_gep_last_index_no_overflow_all_inbounds_1(ptr %dst) {
 ; CHECK-LABEL: @test_outer_gep_last_index_no_overflow_all_inbounds_1(
 ; CHECK-NEXT:    [[DST_0:%.*]] = getelementptr inbounds ptr, ptr [[DST:%.*]], i64 0
 ; CHECK-NEXT:    [[UPPER:%.*]] = getelementptr inbounds ptr, ptr [[DST]], i64 2
 ; CHECK-NEXT:    [[GEP_1:%.*]] = getelementptr inbounds [2 x i32], ptr [[DST_0]], i64 1, i64 1
-; CHECK-NEXT:    [[C_1:%.*]] = icmp ult ptr [[GEP_1]], [[UPPER]]
 ; CHECK-NEXT:    ret i1 true
 ;
   %dst.0 = getelementptr inbounds ptr, ptr %dst, i64 0
   %upper = getelementptr inbounds ptr, ptr %dst, i64 2
   %gep.1 = getelementptr inbounds [2 x i32] , ptr %dst.0, i64 1, i64 1
   %c.1 = icmp ult ptr %gep.1, %upper
   ret i1 %c.1
 }
 
 define i1 @test_outer_gep_last_index_no_overflow_all_inbounds_2(ptr %dst) {
 ; CHECK-LABEL: @test_outer_gep_last_index_no_overflow_all_inbounds_2(
 ; CHECK-NEXT:    [[DST_0:%.*]] = getelementptr inbounds ptr, ptr [[DST:%.*]], i64 0
 ; CHECK-NEXT:    [[UPPER:%.*]] = getelementptr inbounds ptr, ptr [[DST]], i64 3
 ; CHECK-NEXT:    [[GEP_1:%.*]] = getelementptr inbounds [2 x i32], ptr [[DST_0]], i64 1, i64 1
-; CHECK-NEXT:    [[C_1:%.*]] = icmp ult ptr [[GEP_1]], [[UPPER]]
 ; CHECK-NEXT:    ret i1 true
 ;
   %dst.0 = getelementptr inbounds ptr, ptr %dst, i64 0
   %upper = getelementptr inbounds ptr, ptr %dst, i64 3
   %gep.1 = getelementptr inbounds [2 x i32] , ptr %dst.0, i64 1, i64 1
   %c.1 = icmp ult ptr %gep.1, %upper
   ret i1 %c.1
 }
 
 define i1 @test_outer_gep_last_index_overflow_all_inbounds(ptr %dst) {
 ; CHECK-LABEL: @test_outer_gep_last_index_overflow_all_inbounds(
 ; CHECK-NEXT:    [[DST_0:%.*]] = getelementptr inbounds ptr, ptr [[DST:%.*]], i64 0
 ; CHECK-NEXT:    [[UPPER:%.*]] = getelementptr inbounds ptr, ptr [[DST]], i64 2
 ; CHECK-NEXT:    [[GEP_1:%.*]] = getelementptr inbounds [2 x i32], ptr [[DST_0]], i64 1, i64 2
-; CHECK-NEXT:    [[C:%.*]] = icmp ult ptr [[GEP_1]], [[UPPER]]
 ; CHECK-NEXT:    ret i1 false
 ;
   %dst.0 = getelementptr inbounds ptr, ptr %dst, i64 0
   %upper = getelementptr inbounds ptr, ptr %dst, i64 2
   %gep.1 = getelementptr inbounds [2 x i32] , ptr %dst.0, i64 1, i64 2
   %c = icmp ult ptr %gep.1, %upper
   ret i1 %c
 }
entry:
   ret i1 %c
 }
 
 define i1 @test_inner_gep_multi_index(ptr %dst) {
 ; CHECK-LABEL: @test_inner_gep_multi_index(
 ; CHECK-NEXT:    [[DST_0:%.*]] = getelementptr inbounds ptr, ptr [[DST:%.*]], i64 0
 ; CHECK-NEXT:    [[UPPER:%.*]] = getelementptr inbounds ptr, ptr [[DST]], i64 2
 ; CHECK-NEXT:    [[GEP_1:%.*]] = getelementptr inbounds [2 x i32], ptr [[DST_0]], i64 1, i64 1
-; CHECK-NEXT:    [[C_1:%.*]] = icmp ult ptr [[GEP_1]], [[UPPER]]
 ; CHECK-NEXT:    ret i1 true
 ;
   %dst.0 = getelementptr inbounds ptr, ptr %dst, i64 0
   %upper = getelementptr inbounds ptr, ptr %dst, i64 2
   %gep.1 = getelementptr inbounds [2 x i32] , ptr %dst.0, i64 1, i64 1
   %c.1 = icmp ult ptr %gep.1, %upper
   ret i1 %c.1
 }

llvm/test/Transforms/ConstraintElimination/gep-arithmetic-add.ll

 ; CHECK:       step.check:
 ; CHECK-NEXT:    [[STEP_ADD_1:%.*]] = add nuw nsw i16 [[STEP:%.*]], 1
 ; CHECK-NEXT:    [[STEP_ADD_1_EXT:%.*]] = zext i16 [[STEP_ADD_1]] to i32
 ; CHECK-NEXT:    [[STEP_ULT_N:%.*]] = icmp ult i32 [[STEP_ADD_1_EXT]], [[N_ADD_1_EXT]]
 ; CHECK-NEXT:    br i1 [[STEP_ULT_N]], label [[PTR_CHECK:%.*]], label [[EXIT:%.*]]
 ; CHECK:       ptr.check:
 ; CHECK-NEXT:    [[SRC_STEP:%.*]] = getelementptr inbounds i8, ptr [[SRC]], i32 [[STEP_ADD_1_EXT]]
 ; CHECK-NEXT:    [[CMP_STEP_START:%.*]] = icmp ult ptr [[SRC_STEP]], [[LOWER]]
-; CHECK-NEXT:    [[CMP_STEP_END:%.*]] = icmp uge ptr [[SRC_STEP]], [[UPPER]]
 ; CHECK-NEXT:    [[OR_CHECK:%.*]] = or i1 [[CMP_STEP_START]], false
 ; CHECK-NEXT:    br i1 [[OR_CHECK]], label [[TRAP_BB]], label [[EXIT]]
 ; CHECK:       exit:
 ; CHECK-NEXT:    ret i4 3
 ;
 entry:
   %N.add.1 = add nuw nsw i16 %N, 1
   %N.add.1.ext = zext i16 %N.add.1 to i32

llvm/test/Transforms/ConstraintElimination/gep-arithmetic-different-types.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -passes=constraint-elimination -S %s | FileCheck %s
 
 declare void @llvm.assume(i1 noundef) #0
 
 define i1 @gep_constant_positive_index(ptr %A, ptr %upper) {
 ; CHECK-LABEL: @gep_constant_positive_index(
 ; CHECK-NEXT:    [[ADD_I8_4:%.*]] = getelementptr inbounds i8, ptr [[A:%.*]], i64 4
 ; CHECK-NEXT:    [[C_0:%.*]] = icmp ult ptr [[ADD_I8_4]], [[UPPER:%.*]]
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C_0]])
 ; CHECK-NEXT:    [[ADD_I16_4:%.*]] = getelementptr inbounds i16, ptr [[A]], i64 4
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ult ptr [[ADD_I16_4]], [[UPPER]]
 ; CHECK-NEXT:    [[ADD_I16_2:%.*]] = getelementptr inbounds i16, ptr [[A]], i64 2
-; CHECK-NEXT:    [[T_1:%.*]] = icmp ult ptr [[ADD_I16_2]], [[UPPER]]
 ; CHECK-NEXT:    [[RES_1:%.*]] = xor i1 [[C_1]], true
 ; CHECK-NEXT:    ret i1 [[RES_1]]
 ;
   %add.i8.4 = getelementptr inbounds i8, ptr %A, i64 4
   %c.0 = icmp ult ptr %add.i8.4, %upper
   call void @llvm.assume(i1 %c.0)
 
   %add.i16.4 = getelementptr inbounds i16, ptr %A, i64 4
   %c.1 = icmp ult ptr %add.i16.4, %upper
 
   %add.i16.2 = getelementptr inbounds i16, ptr %A, i64 2
   %t.1 = icmp ult ptr %add.i16.2, %upper
   %res.1 = xor i1 %c.1, %t.1
   ret i1 %res.1
 }
 
 define i1 @gep_constant_positive_index_chained(ptr %A, ptr %upper) {
 ; CHECK-LABEL: @gep_constant_positive_index_chained(
 ; CHECK-NEXT:    [[ADD_I8_4:%.*]] = getelementptr inbounds i8, ptr [[A:%.*]], i64 4
 ; CHECK-NEXT:    [[C_0:%.*]] = icmp ult ptr [[ADD_I8_4]], [[UPPER:%.*]]
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C_0]])
 ; CHECK-NEXT:    [[ADD_I8_1:%.*]] = getelementptr inbounds i8, ptr [[A]], i64 1
 ; CHECK-NEXT:    [[ADD_I16_1:%.*]] = getelementptr inbounds i16, ptr [[ADD_I8_1]], i64 1
-; CHECK-NEXT:    [[T_1:%.*]] = icmp ult ptr [[ADD_I16_1]], [[UPPER]]
 ; CHECK-NEXT:    [[ADD_I16_2:%.*]] = getelementptr inbounds i16, ptr [[ADD_I8_1]], i64 2
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ult ptr [[ADD_I16_2]], [[UPPER]]
 ; CHECK-NEXT:    [[RES_1:%.*]] = xor i1 true, [[C_1]]
 ; CHECK-NEXT:    ret i1 [[RES_1]]
 ;
   %add.i8.4 = getelementptr inbounds i8, ptr %A, i64 4
   %c.0 = icmp ult ptr %add.i8.4, %upper
   call void @llvm.assume(i1 %c.0)

 ; CHECK-NEXT:    [[IDX_POS:%.*]] = icmp sge i8 [[IDX:%.*]], 0
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[IDX_POS]])
 ; CHECK-NEXT:    [[ADD_I16_IDX:%.*]] = getelementptr inbounds i16, ptr [[A:%.*]], i8 [[IDX]]
 ; CHECK-NEXT:    [[C_0:%.*]] = icmp ult ptr [[ADD_I16_IDX]], [[UPPER:%.*]]
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C_0]])
 ; CHECK-NEXT:    [[ADD_I32_IDX:%.*]] = getelementptr inbounds i32, ptr [[A]], i8 [[IDX]]
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ult ptr [[ADD_I32_IDX]], [[UPPER]]
 ; CHECK-NEXT:    [[ADD_I8_IDX:%.*]] = getelementptr inbounds i8, ptr [[A]], i8 [[IDX]]
-; CHECK-NEXT:    [[T_1:%.*]] = icmp ult ptr [[ADD_I8_IDX]], [[UPPER]]
 ; CHECK-NEXT:    [[RES_1:%.*]] = xor i1 [[C_1]], true
 ; CHECK-NEXT:    ret i1 [[RES_1]]
 ;
   %idx.pos = icmp sge i8 %idx, 0
   call void @llvm.assume(i1 %idx.pos)
   %add.i16.idx = getelementptr inbounds i16, ptr %A, i8 %idx
   %c.0 = icmp ult ptr %add.i16.idx, %upper
   call void @llvm.assume(i1 %c.0)

 ; CHECK-NEXT:    [[IDX_3:%.*]] = add nsw i8 [[IDX]], 3
 ; CHECK-NEXT:    [[ADD_I8_IDX_3:%.*]] = getelementptr inbounds i8, ptr [[A:%.*]], i8 [[IDX_3]]
 ; CHECK-NEXT:    [[C_0:%.*]] = icmp ult ptr [[ADD_I8_IDX_3]], [[UPPER:%.*]]
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C_0]])
 ; CHECK-NEXT:    [[IDX_1:%.*]] = add nsw i8 [[IDX]], 1
 ; CHECK-NEXT:    [[ADD_I32_IDX_1:%.*]] = getelementptr inbounds i32, ptr [[A]], i8 [[IDX_1]]
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ult ptr [[ADD_I32_IDX_1]], [[UPPER]]
 ; CHECK-NEXT:    [[ADD_I8_IDX_1:%.*]] = getelementptr inbounds i8, ptr [[A]], i8 [[IDX_1]]
-; CHECK-NEXT:    [[T_1:%.*]] = icmp ult ptr [[ADD_I8_IDX_1]], [[UPPER]]
 ; CHECK-NEXT:    [[RES_1:%.*]] = xor i1 [[C_1]], true
 ; CHECK-NEXT:    [[ADD_I16_IDX_1:%.*]] = getelementptr inbounds i16, ptr [[A]], i8 [[IDX_1]]
 ; CHECK-NEXT:    [[C_2:%.*]] = icmp ult ptr [[ADD_I16_IDX_1]], [[UPPER]]
 ; CHECK-NEXT:    [[RES_2:%.*]] = xor i1 [[RES_1]], [[C_2]]
 ; CHECK-NEXT:    ret i1 [[RES_2]]
 ;
   %idx.pos = icmp sge i8 %idx, 0
   call void @llvm.assume(i1 %idx.pos)

 ; CHECK-NEXT:    [[ADD_I8_IDX_3:%.*]] = getelementptr inbounds i8, ptr [[A:%.*]], i16 [[IDX_3_EXT]]
 ; CHECK-NEXT:    [[C_0:%.*]] = icmp ult ptr [[ADD_I8_IDX_3]], [[UPPER:%.*]]
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C_0]])
 ; CHECK-NEXT:    [[IDX_1:%.*]] = add nuw nsw i8 [[IDX]], 1
 ; CHECK-NEXT:    [[IDX_1_EXT:%.*]] = zext i8 [[IDX_1]] to i16
 ; CHECK-NEXT:    [[ADD_I32_IDX_1:%.*]] = getelementptr inbounds i32, ptr [[A]], i16 [[IDX_1_EXT]]
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ult ptr [[ADD_I32_IDX_1]], [[UPPER]]
 ; CHECK-NEXT:    [[ADD_I8_IDX_1:%.*]] = getelementptr inbounds i8, ptr [[A]], i16 [[IDX_1_EXT]]
-; CHECK-NEXT:    [[T_1:%.*]] = icmp ult ptr [[ADD_I8_IDX_1]], [[UPPER]]
 ; CHECK-NEXT:    [[RES_1:%.*]] = xor i1 [[C_1]], true
 ; CHECK-NEXT:    [[ADD_I16_IDX_1:%.*]] = getelementptr inbounds i16, ptr [[A]], i16 [[IDX_1_EXT]]
 ; CHECK-NEXT:    [[C_2:%.*]] = icmp ult ptr [[ADD_I16_IDX_1]], [[UPPER]]
 ; CHECK-NEXT:    [[RES_2:%.*]] = xor i1 [[RES_1]], [[C_2]]
 ; CHECK-NEXT:    ret i1 [[RES_2]]
 ;
   %idx.3 = add nuw nsw i8 %idx, 3
   %idx.3.ext = zext i8 %idx.3 to i16

 ; CHECK-NEXT:    [[ADD_I8_IDX_2:%.*]] = getelementptr inbounds i8, ptr [[A:%.*]], i16 [[IDX_2_EXT]]
 ; CHECK-NEXT:    [[C_0:%.*]] = icmp ult ptr [[ADD_I8_IDX_2]], [[UPPER:%.*]]
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C_0]])
 ; CHECK-NEXT:    [[IDX_1:%.*]] = add nuw i8 [[IDX]], 1
 ; CHECK-NEXT:    [[IDX_1_EXT:%.*]] = zext i8 [[IDX_1]] to i16
 ; CHECK-NEXT:    [[ADD_I32_IDX_1:%.*]] = getelementptr inbounds i32, ptr [[A]], i16 [[IDX_1_EXT]]
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ult ptr [[ADD_I32_IDX_1]], [[UPPER]]
 ; CHECK-NEXT:    [[ADD_I8_IDX_1:%.*]] = getelementptr inbounds i8, ptr [[A]], i16 [[IDX_1_EXT]]
-; CHECK-NEXT:    [[T_1:%.*]] = icmp ult ptr [[ADD_I8_IDX_1]], [[UPPER]]
 ; CHECK-NEXT:    [[RES_1:%.*]] = xor i1 [[C_1]], true
 ; CHECK-NEXT:    ret i1 [[RES_1]]
 ;
   %idx.2 = add nuw i8 %idx, 2
   %idx.2.ext = zext i8 %idx.2 to i16
   %add.i8.idx.2 = getelementptr inbounds i8, ptr %A, i16 %idx.2.ext
   %c.0 = icmp ult ptr %add.i8.idx.2, %upper
   call void @llvm.assume(i1 %c.0)

 ; CHECK-NEXT:    [[C_0:%.*]] = icmp ult i8 [[IDX_1:%.*]], [[IDX_2:%.*]]
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C_0]])
 ; CHECK-NEXT:    [[IDX_2_EXT:%.*]] = zext i8 [[IDX_2]] to i16
 ; CHECK-NEXT:    [[ADD_I8_IDX_2:%.*]] = getelementptr inbounds i8, ptr [[A:%.*]], i16 [[IDX_2_EXT]]
 ; CHECK-NEXT:    [[IDX_1_EXT:%.*]] = zext i8 [[IDX_1]] to i16
 ; CHECK-NEXT:    [[ADD_I32_IDX_1:%.*]] = getelementptr inbounds i32, ptr [[A]], i16 [[IDX_1_EXT]]
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ult ptr [[ADD_I32_IDX_1]], [[ADD_I8_IDX_2]]
 ; CHECK-NEXT:    [[ADD_I8_IDX_1:%.*]] = getelementptr inbounds i8, ptr [[A]], i16 [[IDX_1_EXT]]
-; CHECK-NEXT:    [[T_1:%.*]] = icmp ult ptr [[ADD_I8_IDX_1]], [[ADD_I8_IDX_2]]
 ; CHECK-NEXT:    [[RES_1:%.*]] = xor i1 [[C_1]], true
 ; CHECK-NEXT:    ret i1 [[RES_1]]
 ;
   %c.0 = icmp ult i8 %idx.1, %idx.2
   call void @llvm.assume(i1 %c.0)
 
 
   %idx.2.ext = zext i8 %idx.2 to i16

 ; CHECK-NEXT:    [[ADD_I8_IDX_2:%.*]] = getelementptr inbounds i8, ptr [[A:%.*]], i16 [[IDX_2_EXT]]
 ; CHECK-NEXT:    [[C_0:%.*]] = icmp ult ptr [[ADD_I8_IDX_2]], [[UPPER:%.*]]
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C_0]])
 ; CHECK-NEXT:    [[IDX_1:%.*]] = shl nuw i8 [[IDX]], 1
 ; CHECK-NEXT:    [[IDX_1_EXT:%.*]] = zext i8 [[IDX_1]] to i16
 ; CHECK-NEXT:    [[ADD_I32_IDX_1:%.*]] = getelementptr inbounds i32, ptr [[A]], i16 [[IDX_1_EXT]]
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ult ptr [[ADD_I32_IDX_1]], [[UPPER]]
 ; CHECK-NEXT:    [[ADD_I8_IDX_1:%.*]] = getelementptr inbounds i8, ptr [[A]], i16 [[IDX_1_EXT]]
-; CHECK-NEXT:    [[T_1:%.*]] = icmp ult ptr [[ADD_I8_IDX_1]], [[UPPER]]
 ; CHECK-NEXT:    [[RES_1:%.*]] = xor i1 [[C_1]], true
 ; CHECK-NEXT:    ret i1 [[RES_1]]
 ;
   %idx.pos = icmp sgt i8 %idx, 0
   call void @llvm.assume(i1 %idx.pos)
   %idx.2 = shl nuw i8 %idx, 2
   %idx.2.ext = zext i8 %idx.2 to i16
   %add.i8.idx.2 = getelementptr inbounds i8, ptr %A, i16 %idx.2.ext

 ; CHECK-NEXT:    [[IDX_3:%.*]] = add nsw i8 [[IDX]], 2
 ; CHECK-NEXT:    [[ADD_I8_IDX_3:%.*]] = getelementptr inbounds [[STRUCT_T:%.*]], ptr [[A:%.*]], i8 [[IDX_3]]
 ; CHECK-NEXT:    [[C_0:%.*]] = icmp ult ptr [[ADD_I8_IDX_3]], [[UPPER:%.*]]
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C_0]])
 ; CHECK-NEXT:    [[IDX_1:%.*]] = add nsw i8 [[IDX]], 1
 ; CHECK-NEXT:    [[ADD_I32_IDX_1:%.*]] = getelementptr inbounds i32, ptr [[A]], i8 [[IDX_1]]
 ; CHECK-NEXT:    [[T_1:%.*]] = icmp ult ptr [[ADD_I32_IDX_1]], [[UPPER]]
 ; CHECK-NEXT:    [[ADD_I8_IDX_1:%.*]] = getelementptr inbounds i8, ptr [[A]], i8 [[IDX_1]]
-; CHECK-NEXT:    [[T_2:%.*]] = icmp ult ptr [[ADD_I8_IDX_1]], [[UPPER]]
 ; CHECK-NEXT:    [[RES_1:%.*]] = xor i1 [[T_1]], true
 ; CHECK-NEXT:    [[ADD_I16_IDX_1:%.*]] = getelementptr inbounds i16, ptr [[A]], i8 [[IDX_1]]
-; CHECK-NEXT:    [[T_3:%.*]] = icmp ult ptr [[ADD_I16_IDX_1]], [[UPPER]]
 ; CHECK-NEXT:    [[RES_2:%.*]] = xor i1 [[RES_1]], true
 ; CHECK-NEXT:    [[ADD_I64_IDX_1:%.*]] = getelementptr inbounds i64, ptr [[A]], i8 [[IDX_1]]
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ult ptr [[ADD_I64_IDX_1]], [[UPPER]]
 ; CHECK-NEXT:    [[RES_3:%.*]] = xor i1 [[RES_2]], [[C_1]]
 ; CHECK-NEXT:    ret i1 [[RES_3]]
 ;
   %idx.pos = icmp sge i8 %idx, 0
   call void @llvm.assume(i1 %idx.pos)

 define i1 @gep_constant_positive_index_fixed_vector_ty(ptr %A, ptr %upper) {
 ; CHECK-LABEL: @gep_constant_positive_index_fixed_vector_ty(
 ; CHECK-NEXT:    [[ADD_I8_4:%.*]] = getelementptr inbounds <4 x i8>, ptr [[A:%.*]], i64 4
 ; CHECK-NEXT:    [[C_0:%.*]] = icmp ult ptr [[ADD_I8_4]], [[UPPER:%.*]]
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C_0]])
 ; CHECK-NEXT:    [[ADD_I16_4:%.*]] = getelementptr inbounds <4 x i16>, ptr [[A]], i64 4
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ult ptr [[ADD_I16_4]], [[UPPER]]
 ; CHECK-NEXT:    [[ADD_I16_2:%.*]] = getelementptr inbounds <4 x i16>, ptr [[A]], i64 2
-; CHECK-NEXT:    [[T_1:%.*]] = icmp ult ptr [[ADD_I16_2]], [[UPPER]]
 ; CHECK-NEXT:    [[RES_1:%.*]] = xor i1 [[C_1]], true
 ; CHECK-NEXT:    ret i1 [[RES_1]]
 ;
   %add.i8.4 = getelementptr inbounds <4 x i8>, ptr %A, i64 4
   %c.0 = icmp ult ptr %add.i8.4, %upper
   call void @llvm.assume(i1 %c.0)
 
   %add.i16.4 = getelementptr inbounds <4 x i16>, ptr %A, i64 4

llvm/test/Transforms/ConstraintElimination/gep-arithmetic-signed-predicates.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -passes=constraint-elimination -S %s | FileCheck %s
 
 declare void @llvm.assume(i1 noundef) #0
 
 define i1 @gep_constant_positive_index(ptr %dst, ptr %lower, ptr %upper) {
 ; CHECK-LABEL: @gep_constant_positive_index(
 ; CHECK-NEXT:    [[DST_ADD_4:%.*]] = getelementptr inbounds i8, ptr [[DST:%.*]], i64 4
 ; CHECK-NEXT:    [[PRE_DST_LOWER:%.*]] = icmp sge ptr [[DST]], [[LOWER:%.*]]
 ; CHECK-NEXT:    [[PRE_DST_UPPER:%.*]] = icmp slt ptr [[DST_ADD_4]], [[UPPER:%.*]]
 ; CHECK-NEXT:    [[AND:%.*]] = and i1 [[PRE_DST_LOWER]], [[PRE_DST_UPPER]]
 ; CHECK-NEXT:    br i1 [[AND]], label [[THEN:%.*]], label [[ELSE:%.*]]
 ; CHECK:       then:
-; CHECK-NEXT:    [[CMP_DST_LOWER:%.*]] = icmp sge ptr [[DST]], [[LOWER]]
 ; CHECK-NEXT:    [[CMP_DST_UPPER:%.*]] = icmp slt ptr [[DST]], [[UPPER]]
 ; CHECK-NEXT:    [[RES_1:%.*]] = xor i1 true, [[CMP_DST_UPPER]]
 ; CHECK-NEXT:    [[DST_ADD_3:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 3
 ; CHECK-NEXT:    [[CMP_DST_ADD_3_LOWER:%.*]] = icmp sge ptr [[DST_ADD_3]], [[LOWER]]
 ; CHECK-NEXT:    [[CMP_DST_ADD_3_UPPER:%.*]] = icmp slt ptr [[DST_ADD_3]], [[UPPER]]
 ; CHECK-NEXT:    [[RES_2:%.*]] = xor i1 [[RES_1]], [[CMP_DST_ADD_3_LOWER]]
 ; CHECK-NEXT:    [[RES_3:%.*]] = xor i1 [[RES_2]], [[CMP_DST_ADD_3_UPPER]]
 ; CHECK-NEXT:    [[CMP_DST_ADD_4_LOWER:%.*]] = icmp sge ptr [[DST_ADD_4]], [[LOWER]]
-; CHECK-NEXT:    [[CMP_DST_ADD_4_UPPER:%.*]] = icmp slt ptr [[DST_ADD_4]], [[UPPER]]
 ; CHECK-NEXT:    [[RES_4:%.*]] = xor i1 [[RES_3]], [[CMP_DST_ADD_4_LOWER]]
 ; CHECK-NEXT:    [[RES_5:%.*]] = xor i1 [[RES_4]], true
 ; CHECK-NEXT:    [[DST_ADD_5:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 5
 ; CHECK-NEXT:    [[CMP_DST_ADD_5_LOWER:%.*]] = icmp sge ptr [[DST_ADD_5]], [[LOWER]]
 ; CHECK-NEXT:    [[CMP_DST_ADD_5_UPPER:%.*]] = icmp slt ptr [[DST_ADD_5]], [[UPPER]]
 ; CHECK-NEXT:    [[RES_6:%.*]] = xor i1 [[RES_5]], [[CMP_DST_ADD_5_LOWER]]
 ; CHECK-NEXT:    [[RES_7:%.*]] = xor i1 [[RES_6]], [[CMP_DST_ADD_5_UPPER]]
 ; CHECK-NEXT:    ret i1 [[RES_7]]

 define i1 @gep_constant_negative_index(ptr %dst, ptr %lower, ptr %upper) {
 ; CHECK-LABEL: @gep_constant_negative_index(
 ; CHECK-NEXT:    [[DST_SUB_4:%.*]] = getelementptr inbounds i8, ptr [[DST:%.*]], i64 -4
 ; CHECK-NEXT:    [[PRE_DST_LOWER:%.*]] = icmp sge ptr [[DST]], [[LOWER:%.*]]
 ; CHECK-NEXT:    [[PRE_DST_UPPER:%.*]] = icmp slt ptr [[DST_SUB_4]], [[UPPER:%.*]]
 ; CHECK-NEXT:    [[AND:%.*]] = and i1 [[PRE_DST_LOWER]], [[PRE_DST_UPPER]]
 ; CHECK-NEXT:    br i1 [[AND]], label [[THEN:%.*]], label [[ELSE:%.*]]
 ; CHECK:       then:
-; CHECK-NEXT:    [[CMP_DST_LOWER:%.*]] = icmp sge ptr [[DST]], [[LOWER]]
 ; CHECK-NEXT:    [[CMP_DST_UPPER:%.*]] = icmp slt ptr [[DST]], [[UPPER]]
 ; CHECK-NEXT:    [[RES_1:%.*]] = xor i1 true, [[CMP_DST_UPPER]]
 ; CHECK-NEXT:    [[DST_SUB_3:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 -3
 ; CHECK-NEXT:    [[CMP_DST_SUB_3_LOWER:%.*]] = icmp sge ptr [[DST_SUB_3]], [[LOWER]]
 ; CHECK-NEXT:    [[CMP_DST_SUB_3_UPPER:%.*]] = icmp slt ptr [[DST_SUB_3]], [[UPPER]]
 ; CHECK-NEXT:    [[RES_2:%.*]] = xor i1 [[RES_1]], [[CMP_DST_SUB_3_LOWER]]
 ; CHECK-NEXT:    [[RES_3:%.*]] = xor i1 [[RES_2]], [[CMP_DST_SUB_3_UPPER]]
 ; CHECK-NEXT:    [[CMP_DST_SUB_4_LOWER:%.*]] = icmp sge ptr [[DST_SUB_4]], [[LOWER]]
-; CHECK-NEXT:    [[CMP_DST_SUB_4_UPPER:%.*]] = icmp slt ptr [[DST_SUB_4]], [[UPPER]]
 ; CHECK-NEXT:    [[RES_4:%.*]] = xor i1 [[RES_3]], [[CMP_DST_SUB_4_LOWER]]
 ; CHECK-NEXT:    [[RES_5:%.*]] = xor i1 [[RES_4]], true
 ; CHECK-NEXT:    [[DST_SUB_5:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 -5
 ; CHECK-NEXT:    [[CMP_DST_SUB_5_LOWER:%.*]] = icmp sge ptr [[DST_SUB_5]], [[LOWER]]
 ; CHECK-NEXT:    [[CMP_DST_SUB_5_UPPER:%.*]] = icmp slt ptr [[DST_SUB_5]], [[UPPER]]
 ; CHECK-NEXT:    [[RES_6:%.*]] = xor i1 [[RES_5]], [[CMP_DST_SUB_5_LOWER]]
 ; CHECK-NEXT:    [[RES_7:%.*]] = xor i1 [[RES_6]], [[CMP_DST_SUB_5_UPPER]]
 ; CHECK-NEXT:    ret i1 [[RES_7]]

 ; CHECK-NEXT:    [[SRC_END:%.*]] = getelementptr inbounds i8, ptr [[SRC:%.*]], i16 [[N]]
 ; CHECK-NEXT:    [[CMP_SRC_START:%.*]] = icmp slt ptr [[SRC]], [[LOWER:%.*]]
 ; CHECK-NEXT:    [[CMP_SRC_END:%.*]] = icmp sge ptr [[SRC_END]], [[UPPER:%.*]]
 ; CHECK-NEXT:    [[OR_PRECOND_0:%.*]] = or i1 [[CMP_SRC_START]], [[CMP_SRC_END]]
 ; CHECK-NEXT:    br i1 [[OR_PRECOND_0]], label [[TRAP_BB]], label [[STEP_CHECK:%.*]]
 ; CHECK:       trap.bb:
 ; CHECK-NEXT:    ret i4 2
 ; CHECK:       step.check:
-; CHECK-NEXT:    [[STEP_SGE_0:%.*]] = icmp sge i16 [[STEP]], 0
 ; CHECK-NEXT:    [[STEP_SLT_N:%.*]] = icmp slt i16 [[STEP]], [[N]]
 ; CHECK-NEXT:    [[AND_2:%.*]] = and i1 true, [[STEP_SLT_N]]
 ; CHECK-NEXT:    br i1 [[AND_2]], label [[PTR_CHECK:%.*]], label [[EXIT:%.*]]
 ; CHECK:       ptr.check:
 ; CHECK-NEXT:    [[SRC_STEP:%.*]] = getelementptr inbounds i8, ptr [[SRC]], i16 1
 ; CHECK-NEXT:    [[CMP_STEP_START:%.*]] = icmp slt ptr [[SRC_STEP]], [[LOWER]]
 ; CHECK-NEXT:    [[CMP_STEP_END:%.*]] = icmp sge ptr [[SRC_STEP]], [[UPPER]]
 ; CHECK-NEXT:    [[OR_CHECK:%.*]] = or i1 [[CMP_STEP_START]], [[CMP_STEP_END]]

llvm/test/Transforms/ConstraintElimination/gep-arithmetic.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -passes=constraint-elimination -S %s | FileCheck %s
 
 declare void @llvm.assume(i1 noundef) #0
 
 define i1 @gep_constant_positive_index(ptr %dst, ptr %lower, ptr %upper) {
 ; CHECK-LABEL: @gep_constant_positive_index(
 ; CHECK-NEXT:    [[DST_ADD_4:%.*]] = getelementptr inbounds i8, ptr [[DST:%.*]], i64 4
 ; CHECK-NEXT:    [[PRE_DST_LOWER:%.*]] = icmp uge ptr [[DST]], [[LOWER:%.*]]
 ; CHECK-NEXT:    [[PRE_DST_UPPER:%.*]] = icmp ult ptr [[DST_ADD_4]], [[UPPER:%.*]]
 ; CHECK-NEXT:    [[AND:%.*]] = and i1 [[PRE_DST_LOWER]], [[PRE_DST_UPPER]]
 ; CHECK-NEXT:    br i1 [[AND]], label [[THEN:%.*]], label [[ELSE:%.*]]
 ; CHECK:       then:
-; CHECK-NEXT:    [[CMP_DST_LOWER:%.*]] = icmp uge ptr [[DST]], [[LOWER]]
-; CHECK-NEXT:    [[CMP_DST_UPPER:%.*]] = icmp ult ptr [[DST]], [[UPPER]]
 ; CHECK-NEXT:    [[RES_1:%.*]] = xor i1 true, true
 ; CHECK-NEXT:    [[DST_ADD_3:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 3
-; CHECK-NEXT:    [[CMP_DST_ADD_3_LOWER:%.*]] = icmp uge ptr [[DST_ADD_3]], [[LOWER]]
-; CHECK-NEXT:    [[CMP_DST_ADD_3_UPPER:%.*]] = icmp ult ptr [[DST_ADD_3]], [[UPPER]]
 ; CHECK-NEXT:    [[RES_2:%.*]] = xor i1 [[RES_1]], true
 ; CHECK-NEXT:    [[RES_3:%.*]] = xor i1 [[RES_2]], true
-; CHECK-NEXT:    [[CMP_DST_ADD_4_LOWER:%.*]] = icmp uge ptr [[DST_ADD_4]], [[LOWER]]
-; CHECK-NEXT:    [[CMP_DST_ADD_4_UPPER:%.*]] = icmp ult ptr [[DST_ADD_4]], [[UPPER]]
 ; CHECK-NEXT:    [[RES_4:%.*]] = xor i1 [[RES_3]], true
 ; CHECK-NEXT:    [[RES_5:%.*]] = xor i1 [[RES_4]], true
 ; CHECK-NEXT:    [[DST_ADD_5:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 5
-; CHECK-NEXT:    [[CMP_DST_ADD_5_LOWER:%.*]] = icmp uge ptr [[DST_ADD_5]], [[LOWER]]
 ; CHECK-NEXT:    [[CMP_DST_ADD_5_UPPER:%.*]] = icmp ult ptr [[DST_ADD_5]], [[UPPER]]
 ; CHECK-NEXT:    [[RES_6:%.*]] = xor i1 [[RES_5]], true
 ; CHECK-NEXT:    [[RES_7:%.*]] = xor i1 [[RES_6]], [[CMP_DST_ADD_5_UPPER]]
 ; CHECK-NEXT:    ret i1 [[RES_7]]
 ; CHECK:       else:
 ; CHECK-NEXT:    ret i1 false
 ;
   %dst.add.4 = getelementptr inbounds i8, ptr %dst, i64 4

 define i1 @gep_constant_negative_index(ptr %dst, ptr %lower, ptr %upper) {
 ; CHECK-LABEL: @gep_constant_negative_index(
 ; CHECK-NEXT:    [[DST_SUB_4:%.*]] = getelementptr inbounds i8, ptr [[DST:%.*]], i64 -4
 ; CHECK-NEXT:    [[PRE_DST_LOWER:%.*]] = icmp uge ptr [[DST]], [[LOWER:%.*]]
 ; CHECK-NEXT:    [[PRE_DST_UPPER:%.*]] = icmp ult ptr [[DST_SUB_4]], [[UPPER:%.*]]
 ; CHECK-NEXT:    [[AND:%.*]] = and i1 [[PRE_DST_LOWER]], [[PRE_DST_UPPER]]
 ; CHECK-NEXT:    br i1 [[AND]], label [[THEN:%.*]], label [[ELSE:%.*]]
 ; CHECK:       then:
-; CHECK-NEXT:    [[CMP_DST_LOWER:%.*]] = icmp uge ptr [[DST]], [[LOWER]]
 ; CHECK-NEXT:    [[CMP_DST_UPPER:%.*]] = icmp ult ptr [[DST]], [[UPPER]]
 ; CHECK-NEXT:    [[RES_1:%.*]] = xor i1 true, [[CMP_DST_UPPER]]
 ; CHECK-NEXT:    [[DST_SUB_3:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 -3
 ; CHECK-NEXT:    [[CMP_DST_SUB_3_LOWER:%.*]] = icmp uge ptr [[DST_SUB_3]], [[LOWER]]
 ; CHECK-NEXT:    [[CMP_DST_SUB_3_UPPER:%.*]] = icmp ult ptr [[DST_SUB_3]], [[UPPER]]
 ; CHECK-NEXT:    [[RES_2:%.*]] = xor i1 [[RES_1]], [[CMP_DST_SUB_3_LOWER]]
 ; CHECK-NEXT:    [[RES_3:%.*]] = xor i1 [[RES_2]], [[CMP_DST_SUB_3_UPPER]]
 ; CHECK-NEXT:    [[CMP_DST_SUB_4_LOWER:%.*]] = icmp uge ptr [[DST_SUB_4]], [[LOWER]]
-; CHECK-NEXT:    [[CMP_DST_SUB_4_UPPER:%.*]] = icmp ult ptr [[DST_SUB_4]], [[UPPER]]
 ; CHECK-NEXT:    [[RES_4:%.*]] = xor i1 [[RES_3]], [[CMP_DST_SUB_4_LOWER]]
 ; CHECK-NEXT:    [[RES_5:%.*]] = xor i1 [[RES_4]], true
 ; CHECK-NEXT:    [[DST_SUB_5:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 -5
 ; CHECK-NEXT:    [[CMP_DST_SUB_5_LOWER:%.*]] = icmp uge ptr [[DST_SUB_5]], [[LOWER]]
-; CHECK-NEXT:    [[CMP_DST_SUB_5_UPPER:%.*]] = icmp ult ptr [[DST_SUB_5]], [[UPPER]]
 ; CHECK-NEXT:    [[RES_6:%.*]] = xor i1 [[RES_5]], [[CMP_DST_SUB_5_LOWER]]
 ; CHECK-NEXT:    [[RES_7:%.*]] = xor i1 [[RES_6]], true
 ; CHECK-NEXT:    ret i1 [[RES_7]]
 ; CHECK:       else:
 ; CHECK-NEXT:    [[ELSE_CMP_DST_LOWER:%.*]] = icmp uge ptr [[DST]], [[LOWER]]
 ; CHECK-NEXT:    [[ELSE_CMP_DST_UPPER:%.*]] = icmp ult ptr [[DST]], [[UPPER]]
 ; CHECK-NEXT:    [[ELSE_RES_1:%.*]] = xor i1 [[ELSE_CMP_DST_LOWER]], [[ELSE_CMP_DST_UPPER]]
 ; CHECK-NEXT:    [[ELSE_DST_SUB_3:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 -3

 ; CHECK-NEXT:    br i1 [[OR_PRECOND_0]], label [[TRAP_BB]], label [[STEP_CHECK:%.*]]
 ; CHECK:       trap.bb:
 ; CHECK-NEXT:    ret i4 2
 ; CHECK:       step.check:
 ; CHECK-NEXT:    [[STEP_ULT_N:%.*]] = icmp ult i16 1, [[N]]
 ; CHECK-NEXT:    br i1 [[STEP_ULT_N]], label [[PTR_CHECK:%.*]], label [[EXIT:%.*]]
 ; CHECK:       ptr.check:
 ; CHECK-NEXT:    [[SRC_STEP:%.*]] = getelementptr inbounds i8, ptr [[SRC]], i16 1
-; CHECK-NEXT:    [[CMP_STEP_START:%.*]] = icmp ult ptr [[SRC_STEP]], [[LOWER]]
-; CHECK-NEXT:    [[CMP_STEP_END:%.*]] = icmp uge ptr [[SRC_STEP]], [[UPPER]]
 ; CHECK-NEXT:    [[OR_CHECK:%.*]] = or i1 false, false
 ; CHECK-NEXT:    br i1 [[OR_CHECK]], label [[TRAP_BB]], label [[EXIT]]
 ; CHECK:       exit:
 ; CHECK-NEXT:    ret i4 3
 ;
 entry:
   %N.pos = icmp sge i16 %N, 0
   br i1 %N.pos, label %entry.1, label %trap.bb

 ; CHECK-NEXT:    [[SRC_END:%.*]] = getelementptr inbounds i8, ptr [[SRC:%.*]], i16 [[N]]
 ; CHECK-NEXT:    [[CMP_SRC_START:%.*]] = icmp ult ptr [[SRC]], [[LOWER:%.*]]
 ; CHECK-NEXT:    [[CMP_SRC_END:%.*]] = icmp uge ptr [[SRC_END]], [[UPPER:%.*]]
 ; CHECK-NEXT:    [[OR_PRECOND_0:%.*]] = or i1 [[CMP_SRC_START]], [[CMP_SRC_END]]
 ; CHECK-NEXT:    br i1 [[OR_PRECOND_0]], label [[TRAP_BB]], label [[STEP_CHECK:%.*]]
 ; CHECK:       trap.bb:
 ; CHECK-NEXT:    ret i4 2
 ; CHECK:       step.check:
-; CHECK-NEXT:    [[STEP_UGE_0:%.*]] = icmp uge i16 [[STEP]], 0
 ; CHECK-NEXT:    [[STEP_ULT_N:%.*]] = icmp ult i16 [[STEP]], [[N]]
 ; CHECK-NEXT:    [[AND_2:%.*]] = and i1 true, [[STEP_ULT_N]]
 ; CHECK-NEXT:    br i1 [[AND_2]], label [[PTR_CHECK:%.*]], label [[EXIT:%.*]]
 ; CHECK:       ptr.check:
 ; CHECK-NEXT:    [[SRC_STEP:%.*]] = getelementptr inbounds i8, ptr [[SRC]], i16 1
-; CHECK-NEXT:    [[CMP_STEP_START:%.*]] = icmp ult ptr [[SRC_STEP]], [[LOWER]]
-; CHECK-NEXT:    [[CMP_STEP_END:%.*]] = icmp uge ptr [[SRC_STEP]], [[UPPER]]
 ; CHECK-NEXT:    [[OR_CHECK:%.*]] = or i1 false, false
 ; CHECK-NEXT:    br i1 [[OR_CHECK]], label [[TRAP_BB]], label [[EXIT]]
 ; CHECK:       exit:
 ; CHECK-NEXT:    ret i4 3
 ;
 entry:
   %N.pos = icmp sge i16 %N, 0
   %step.pos = icmp sge i16 %step, 0

 ; CHECK-NEXT:    ret i4 2
 ; CHECK:       step.check:
 ; CHECK-NEXT:    [[STEP_UGE_0:%.*]] = icmp uge i16 [[STEP:%.*]], 0
 ; CHECK-NEXT:    [[STEP_ULT_N:%.*]] = icmp ult i16 [[STEP]], [[N]]
 ; CHECK-NEXT:    [[AND_2:%.*]] = and i1 [[STEP_UGE_0]], [[STEP_ULT_N]]
 ; CHECK-NEXT:    br i1 [[AND_2]], label [[PTR_CHECK:%.*]], label [[EXIT:%.*]]
 ; CHECK:       ptr.check:
 ; CHECK-NEXT:    [[SRC_STEP:%.*]] = getelementptr inbounds i8, ptr [[SRC]], i16 1
-; CHECK-NEXT:    [[CMP_STEP_START:%.*]] = icmp ult ptr [[SRC_STEP]], [[LOWER]]
 ; CHECK-NEXT:    [[CMP_STEP_END:%.*]] = icmp uge ptr [[SRC_STEP]], [[UPPER]]
 ; CHECK-NEXT:    [[OR_CHECK:%.*]] = or i1 false, [[CMP_STEP_END]]
 ; CHECK-NEXT:    br i1 [[OR_CHECK]], label [[TRAP_BB]], label [[EXIT]]
 ; CHECK:       exit:
 ; CHECK-NEXT:    ret i4 3
 ;
 entry:
   %src.end = getelementptr inbounds i8, ptr %src, i16 %N

 ; CHECK-NEXT:    ret i4 2
 ; CHECK:       step.check:
 ; CHECK-NEXT:    [[STEP_POS:%.*]] = icmp uge i16 [[STEP:%.*]], 0
 ; CHECK-NEXT:    [[STEP_ULT_N:%.*]] = icmp ult i16 [[STEP]], [[N]]
 ; CHECK-NEXT:    [[AND_STEP:%.*]] = and i1 [[STEP_POS]], [[STEP_ULT_N]]
 ; CHECK-NEXT:    br i1 [[AND_STEP]], label [[PTR_CHECK:%.*]], label [[EXIT:%.*]]
 ; CHECK:       ptr.check:
 ; CHECK-NEXT:    [[SRC_STEP:%.*]] = getelementptr inbounds i8, ptr [[SRC]], i16 [[STEP]]
-; CHECK-NEXT:    [[CMP_STEP_START:%.*]] = icmp ult ptr [[SRC_STEP]], [[LOWER]]
-; CHECK-NEXT:    [[CMP_STEP_END:%.*]] = icmp uge ptr [[SRC_STEP]], [[UPPER]]
 ; CHECK-NEXT:    [[OR_CHECK:%.*]] = or i1 false, false
 ; CHECK-NEXT:    br i1 [[OR_CHECK]], label [[TRAP_BB]], label [[EXIT]]
 ; CHECK:       exit:
 ; CHECK-NEXT:    ret i4 3
 ;
 entry:
   %src.end = getelementptr inbounds i8, ptr %src, i16 %N
   %cmp.src.start = icmp ult ptr %src, %lower

llvm/test/Transforms/ConstraintElimination/gep-chains.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -passes=constraint-elimination -S %s | FileCheck %s
 
 declare void @llvm.assume(i1 noundef) #0
 
 define i1 @gep_add_1_uge_inbounds(ptr %dst, ptr %lower) {
 ; CHECK-LABEL: @gep_add_1_uge_inbounds(
 ; CHECK-NEXT:    [[PRE:%.*]] = icmp uge ptr [[DST:%.*]], [[LOWER:%.*]]
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[PRE]])
 ; CHECK-NEXT:    [[DST_ADD_3:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 3
 ; CHECK-NEXT:    [[DST_ADD_1:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 1
-; CHECK-NEXT:    [[CMP_ADD_1:%.*]] = icmp uge ptr [[DST_ADD_1]], [[LOWER]]
 ; CHECK-NEXT:    [[DST_ADD_2:%.*]] = getelementptr inbounds i8, ptr [[DST_ADD_1]], i64 1
-; CHECK-NEXT:    [[CMP_ADD_3:%.*]] = icmp uge ptr [[DST_ADD_3]], [[LOWER]]
 ; CHECK-NEXT:    [[RES_1:%.*]] = xor i1 true, true
 ; CHECK-NEXT:    [[DST_ADD_4:%.*]] = getelementptr inbounds i8, ptr [[DST_ADD_3]], i64 3
-; CHECK-NEXT:    [[CMP_ADD_4:%.*]] = icmp uge ptr [[DST_ADD_4]], [[LOWER]]
 ; CHECK-NEXT:    [[RES_2:%.*]] = xor i1 [[RES_1]], true
 ; CHECK-NEXT:    ret i1 [[RES_2]]
 ;
   %pre = icmp uge ptr %dst, %lower
   call void @llvm.assume(i1 %pre)
   %dst.add.3 = getelementptr inbounds i8, ptr %dst, i64 3
   %dst.add.1 = getelementptr inbounds i8, ptr %dst, i64 1
   %cmp.add.1 = icmp uge ptr %dst.add.1, %lower

 }
 
 define i1 @gep_add_1_uge_only_inner_inbounds(ptr %dst, ptr %lower) {
 ; CHECK-LABEL: @gep_add_1_uge_only_inner_inbounds(
 ; CHECK-NEXT:    [[PRE:%.*]] = icmp uge ptr [[DST:%.*]], [[LOWER:%.*]]
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[PRE]])
 ; CHECK-NEXT:    [[DST_ADD_3:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 3
 ; CHECK-NEXT:    [[DST_ADD_1:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 1
-; CHECK-NEXT:    [[CMP_ADD_1:%.*]] = icmp uge ptr [[DST_ADD_1]], [[LOWER]]
 ; CHECK-NEXT:    [[DST_ADD_2:%.*]] = getelementptr i8, ptr [[DST_ADD_1]], i64 1
-; CHECK-NEXT:    [[CMP_ADD_3:%.*]] = icmp uge ptr [[DST_ADD_3]], [[LOWER]]
 ; CHECK-NEXT:    [[RES_1:%.*]] = xor i1 true, true
 ; CHECK-NEXT:    [[DST_ADD_4:%.*]] = getelementptr i8, ptr [[DST_ADD_3]], i64 3
 ; CHECK-NEXT:    [[CMP_ADD_4:%.*]] = icmp uge ptr [[DST_ADD_4]], [[LOWER]]
 ; CHECK-NEXT:    [[RES_2:%.*]] = xor i1 [[RES_1]], [[CMP_ADD_4]]
 ; CHECK-NEXT:    ret i1 [[RES_2]]
 ;
   %pre = icmp uge ptr %dst, %lower
   call void @llvm.assume(i1 %pre)

 
 define i1 @gep_add_1_ult(ptr %dst, ptr %lower, ptr %upper) {
 ; CHECK-LABEL: @gep_add_1_ult(
 ; CHECK-NEXT:    [[END:%.*]] = getelementptr inbounds i8, ptr [[DST:%.*]], i64 4
 ; CHECK-NEXT:    [[PRE:%.*]] = icmp ult ptr [[END]], [[UPPER:%.*]]
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[PRE]])
 ; CHECK-NEXT:    [[DST_ADD_1:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 1
 ; CHECK-NEXT:    [[DST_ADD_3:%.*]] = getelementptr inbounds i8, ptr [[DST_ADD_1]], i64 2
-; CHECK-NEXT:    [[CMP_ADD_3:%.*]] = icmp ult ptr [[DST_ADD_3]], [[UPPER]]
 ; CHECK-NEXT:    [[DST_ADD_4:%.*]] = getelementptr inbounds i8, ptr [[DST_ADD_1]], i64 3
-; CHECK-NEXT:    [[CMP_ADD_4:%.*]] = icmp ult ptr [[DST_ADD_4]], [[UPPER]]
 ; CHECK-NEXT:    [[RES_1:%.*]] = xor i1 true, true
 ; CHECK-NEXT:    [[DST_ADD_5:%.*]] = getelementptr inbounds i8, ptr [[DST_ADD_1]], i64 4
 ; CHECK-NEXT:    [[CMP_ADD_5:%.*]] = icmp ult ptr [[DST_ADD_5]], [[UPPER]]
 ; CHECK-NEXT:    [[RES_2:%.*]] = xor i1 [[RES_1]], [[CMP_ADD_5]]
 ; CHECK-NEXT:    ret i1 [[RES_2]]
 ;
   %end = getelementptr inbounds i8, ptr %dst, i64 4
   %pre = icmp ult ptr %end, %upper

 ; CHECK-LABEL: @gep_add_ult_var_idx(
 ; CHECK-NEXT:    [[NOT_ZERO:%.*]] = icmp ne i8 [[IDX:%.*]], 0
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[NOT_ZERO]])
 ; CHECK-NEXT:    [[IDX_EXT:%.*]] = zext i8 [[IDX]] to i16
 ; CHECK-NEXT:    [[DST_ADD_IDX:%.*]] = getelementptr inbounds i8, ptr [[DST:%.*]], i16 [[IDX_EXT]]
 ; CHECK-NEXT:    [[PRE:%.*]] = icmp ult ptr [[DST_ADD_IDX]], [[UPPER:%.*]]
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[PRE]])
 ; CHECK-NEXT:    [[DST_ADD_1:%.*]] = getelementptr inbounds i8, ptr [[DST_ADD_IDX]], i64 1
-; CHECK-NEXT:    [[CMP_ADD_1:%.*]] = icmp ule ptr [[DST_ADD_1]], [[UPPER]]
 ; CHECK-NEXT:    [[DST_ADD_2:%.*]] = getelementptr inbounds i8, ptr [[DST_ADD_IDX]], i64 2
 ; CHECK-NEXT:    [[CMP_ADD_2:%.*]] = icmp ule ptr [[DST_ADD_2]], [[UPPER]]
 ; CHECK-NEXT:    [[RES_1:%.*]] = xor i1 true, [[CMP_ADD_2]]
 ; CHECK-NEXT:    ret i1 [[RES_1]]
 ;
   %not.zero = icmp ne i8 %idx, 0
   call void @llvm.assume(i1 %not.zero)
   %idx.ext = zext i8 %idx to i16

 ; CHECK-LABEL: @gep_add_ult_var_idx_sgt_1(
 ; CHECK-NEXT:    [[SGT_1:%.*]] = icmp sgt i8 [[IDX:%.*]], 1
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[SGT_1]])
 ; CHECK-NEXT:    [[IDX_EXT:%.*]] = zext i8 [[IDX]] to i16
 ; CHECK-NEXT:    [[DST_ADD_IDX:%.*]] = getelementptr inbounds i8, ptr [[DST:%.*]], i16 [[IDX_EXT]]
 ; CHECK-NEXT:    [[PRE:%.*]] = icmp ult ptr [[DST_ADD_IDX]], [[UPPER:%.*]]
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[PRE]])
 ; CHECK-NEXT:    [[DST_ADD_1:%.*]] = getelementptr inbounds i8, ptr [[DST_ADD_IDX]], i64 1
-; CHECK-NEXT:    [[CMP_ADD_1:%.*]] = icmp ule ptr [[DST_ADD_1]], [[UPPER]]
 ; CHECK-NEXT:    [[DST_ADD_2:%.*]] = getelementptr inbounds i8, ptr [[DST_ADD_IDX]], i64 2
 ; CHECK-NEXT:    [[CMP_ADD_2:%.*]] = icmp ule ptr [[DST_ADD_2]], [[UPPER]]
 ; CHECK-NEXT:    [[RES_1:%.*]] = xor i1 true, [[CMP_ADD_2]]
 ; CHECK-NEXT:    ret i1 [[RES_1]]
 ;
   %sgt.1 = icmp sgt i8 %idx, 1
   call void @llvm.assume(i1 %sgt.1)
   %idx.ext = zext i8 %idx to i16

 ; CHECK-NEXT:    [[DST_ADD_1:%.*]] = getelementptr inbounds i8, ptr [[DST_ADD_LEN]], i64 1
 ; CHECK-NEXT:    [[CMP_ADD_1:%.*]] = icmp ult ptr [[DST_ADD_1]], [[UPPER:%.*]]
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[CMP_ADD_1]])
 ; CHECK-NEXT:    [[CMP_IDX_ULT_LEN:%.*]] = icmp ult i8 [[IDX:%.*]], [[LEN]]
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[CMP_IDX_ULT_LEN]])
 ; CHECK-NEXT:    [[IDX_EXT:%.*]] = zext i8 [[IDX]] to i16
 ; CHECK-NEXT:    [[DST_ADD_IDX:%.*]] = getelementptr inbounds i8, ptr [[DST]], i16 [[IDX_EXT]]
 ; CHECK-NEXT:    [[DST_ADD_IDX_1:%.*]] = getelementptr inbounds i8, ptr [[DST_ADD_IDX]], i64 1
-; CHECK-NEXT:    [[CMP_IDX_1:%.*]] = icmp ult ptr [[DST_ADD_IDX_1]], [[UPPER]]
 ; CHECK-NEXT:    [[DST_ADD_IDX_2:%.*]] = getelementptr inbounds i8, ptr [[DST_ADD_IDX]], i64 2
-; CHECK-NEXT:    [[CMP_IDX_2:%.*]] = icmp ult ptr [[DST_ADD_IDX_2]], [[UPPER]]
 ; CHECK-NEXT:    [[RES_1:%.*]] = xor i1 true, true
 ; CHECK-NEXT:    [[DST_ADD_IDX_3:%.*]] = getelementptr inbounds i8, ptr [[DST_ADD_IDX]], i64 3
 ; CHECK-NEXT:    [[CMP_IDX_3:%.*]] = icmp ult ptr [[DST_ADD_IDX_3]], [[UPPER]]
 ; CHECK-NEXT:    [[RES_2:%.*]] = xor i1 [[RES_1]], [[CMP_IDX_3]]
 ; CHECK-NEXT:    ret i1 [[RES_2]]
 ;
   %not.zero = icmp ne i8 %len, 0
   call void @llvm.assume(i1 %not.zero)

llvm/test/Transforms/ConstraintElimination/gep-constexpr.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -passes=constraint-elimination -S %s | FileCheck %s
 
 declare void @llvm.assume(i1 noundef) #0
 
 @arr1 = common global [3 x i16] zeroinitializer, align 2
 
 define i1 @gep_constexpr_index_lt_upper(i32 noundef %i) {
 ; CHECK-LABEL: @gep_constexpr_index_lt_upper(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp ult i32 [[I:%.*]], 3
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[CMP]])
 ; CHECK-NEXT:    [[IDXPROM:%.*]] = zext i32 [[I]] to i64
 ; CHECK-NEXT:    [[UPPER:%.*]] = getelementptr inbounds i16, ptr @arr1, i64 [[IDXPROM]]
-; CHECK-NEXT:    [[C_1:%.*]] = icmp ult ptr [[UPPER]], getelementptr inbounds ([3 x i16], ptr @arr1, i64 1, i64 0)
 ; CHECK-NEXT:    ret i1 true
 ;
 entry:
   %cmp = icmp ult i32 %i, 3
   call void @llvm.assume(i1 %cmp)
   %idxprom = zext i32 %i to i64
   %upper = getelementptr inbounds i16, ptr @arr1, i64 %idxprom
   %c.1 = icmp ult ptr %upper, getelementptr inbounds ([3 x i16], ptr @arr1, i64 1, i64 0)

llvm/test/Transforms/ConstraintElimination/gep-sub.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -passes=constraint-elimination -S %s | FileCheck %s
 
 declare void @llvm.assume(i1 noundef)
 
 define i1 @gep_sub_1_uge_inbounds(ptr %dst, ptr %lower) {
 ; CHECK-LABEL: @gep_sub_1_uge_inbounds(
 ; CHECK-NEXT:    [[PRE:%.*]] = icmp uge ptr [[DST:%.*]], [[LOWER:%.*]]
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[PRE]])
 ; CHECK-NEXT:    [[DST_ADD_3:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 3
 ; CHECK-NEXT:    [[DST_SUB_1:%.*]] = getelementptr inbounds i8, ptr [[DST_ADD_3]], i64 -1
-; CHECK-NEXT:    [[CMP_SUB_1:%.*]] = icmp uge ptr [[DST_SUB_1]], [[LOWER]]
 ; CHECK-NEXT:    [[DST_SUB_3:%.*]] = getelementptr inbounds i8, ptr [[DST_ADD_3]], i64 -3
-; CHECK-NEXT:    [[CMP_SUB_3:%.*]] = icmp uge ptr [[DST_SUB_3]], [[LOWER]]
 ; CHECK-NEXT:    [[RES_1:%.*]] = xor i1 true, true
 ; CHECK-NEXT:    [[DST_SUB_4:%.*]] = getelementptr inbounds i8, ptr [[DST_ADD_3]], i64 -4
 ; CHECK-NEXT:    [[CMP_SUB_4:%.*]] = icmp uge ptr [[DST_SUB_4]], [[LOWER]]
 ; CHECK-NEXT:    [[RES_2:%.*]] = xor i1 [[RES_1]], [[CMP_SUB_4]]
 ; CHECK-NEXT:    ret i1 [[RES_2]]
 ;
   %pre = icmp uge ptr %dst, %lower
   call void @llvm.assume(i1 %pre)

 
 define i1 @gep_sub_1_ult(ptr %dst, ptr %upper) {
 ; CHECK-LABEL: @gep_sub_1_ult(
 ; CHECK-NEXT:    [[DST_ADD_4:%.*]] = getelementptr inbounds i8, ptr [[DST:%.*]], i64 4
 ; CHECK-NEXT:    [[PRE:%.*]] = icmp ult ptr [[DST_ADD_4]], [[UPPER:%.*]]
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[PRE]])
 ; CHECK-NEXT:    [[DST_ADD_3:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 3
 ; CHECK-NEXT:    [[DST_SUB_1:%.*]] = getelementptr inbounds i8, ptr [[DST_ADD_3]], i64 -1
-; CHECK-NEXT:    [[CMP_SUB_1:%.*]] = icmp ult ptr [[DST_SUB_1]], [[UPPER]]
 ; CHECK-NEXT:    [[DST_SUB_3:%.*]] = getelementptr inbounds i8, ptr [[DST_ADD_3]], i64 -3
-; CHECK-NEXT:    [[CMP_SUB_3:%.*]] = icmp ult ptr [[DST_SUB_3]], [[UPPER]]
 ; CHECK-NEXT:    [[RES_1:%.*]] = xor i1 true, true
 ; CHECK-NEXT:    ret i1 [[RES_1]]
 ;
   %dst.add.4 = getelementptr inbounds i8, ptr %dst, i64 4
   %pre = icmp ult ptr %dst.add.4, %upper
   call void @llvm.assume(i1 %pre)
   %dst.add.3 = getelementptr inbounds i8, ptr %dst, i64 3
   %dst.sub.1 = getelementptr inbounds i8, ptr %dst.add.3, i64 -1
   %cmp.sub.1 = icmp ult ptr %dst.sub.1, %upper
   %dst.sub.3 = getelementptr inbounds i8, ptr %dst.add.3, i64 -3
   %cmp.sub.3 = icmp ult ptr %dst.sub.3, %upper
   %res.1 = xor i1 %cmp.sub.1, %cmp.sub.3
   ret i1 %res.1
 }
 
 define i1 @gep_sub_ult_var_idx(ptr %dst, ptr %upper, i8 %idx) {
 ; CHECK-LABEL: @gep_sub_ult_var_idx(
 ; CHECK-NEXT:    [[NOT_ZERO:%.*]] = icmp ne i8 [[IDX:%.*]], 0
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[NOT_ZERO]])
 ; CHECK-NEXT:    [[IDX_EXT:%.*]] = zext i8 [[IDX]] to i16
 ; CHECK-NEXT:    [[DST_ADD_IDX:%.*]] = getelementptr inbounds i8, ptr [[DST:%.*]], i16 [[IDX_EXT]]
 ; CHECK-NEXT:    [[PRE:%.*]] = icmp ult ptr [[DST_ADD_IDX]], [[UPPER:%.*]]
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[PRE]])
 ; CHECK-NEXT:    [[DST_SUB_1:%.*]] = getelementptr inbounds i8, ptr [[DST_ADD_IDX]], i64 -1
-; CHECK-NEXT:    [[CMP_SUB_1:%.*]] = icmp ult ptr [[DST_SUB_1]], [[UPPER]]
 ; CHECK-NEXT:    [[DST_SUB_2:%.*]] = getelementptr inbounds i8, ptr [[DST_ADD_IDX]], i64 -2
 ; CHECK-NEXT:    [[CMP_SUB_2:%.*]] = icmp ult ptr [[DST_SUB_2]], [[UPPER]]
 ; CHECK-NEXT:    [[RES_1:%.*]] = xor i1 true, [[CMP_SUB_2]]
 ; CHECK-NEXT:    [[DST_SUB_1_SUB_1:%.*]] = getelementptr inbounds i8, ptr [[DST_SUB_1]], i64 -1
 ; CHECK-NEXT:    [[CMP_SUB_1_SUB_1:%.*]] = icmp ult ptr [[DST_SUB_1_SUB_1]], [[UPPER]]
 ; CHECK-NEXT:    [[CMP_SUB_1_SUB_1_EQ:%.*]] = icmp eq ptr [[DST_SUB_1_SUB_1]], [[DST_SUB_2]]
 ; CHECK-NEXT:    [[RES_2:%.*]] = xor i1 [[RES_1]], [[CMP_SUB_1_SUB_1]]
 ; CHECK-NEXT:    [[RES_3:%.*]] = xor i1 [[RES_2]], [[CMP_SUB_1_SUB_1_EQ]]

 ; CHECK-LABEL: @gep_sub_ult_var_idx_sgt_1(
 ; CHECK-NEXT:    [[SGT_1:%.*]] = icmp sgt i8 [[IDX:%.*]], 1
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[SGT_1]])
 ; CHECK-NEXT:    [[IDX_EXT:%.*]] = zext i8 [[IDX]] to i16
 ; CHECK-NEXT:    [[DST_ADD_IDX:%.*]] = getelementptr inbounds i8, ptr [[DST:%.*]], i16 [[IDX_EXT]]
 ; CHECK-NEXT:    [[PRE:%.*]] = icmp ult ptr [[DST_ADD_IDX]], [[UPPER:%.*]]
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[PRE]])
 ; CHECK-NEXT:    [[DST_SUB_1:%.*]] = getelementptr inbounds i8, ptr [[DST_ADD_IDX]], i64 -1
-; CHECK-NEXT:    [[CMP_SUB_1:%.*]] = icmp ult ptr [[DST_SUB_1]], [[UPPER]]
 ; CHECK-NEXT:    [[DST_SUB_2:%.*]] = getelementptr inbounds i8, ptr [[DST_ADD_IDX]], i64 -2
-; CHECK-NEXT:    [[CMP_SUB_2:%.*]] = icmp ult ptr [[DST_SUB_2]], [[UPPER]]
 ; CHECK-NEXT:    [[RES_1:%.*]] = xor i1 true, true
 ; CHECK-NEXT:    [[DST_SUB_3:%.*]] = getelementptr inbounds i8, ptr [[DST_ADD_IDX]], i64 -3
 ; CHECK-NEXT:    [[CMP_SUB_3:%.*]] = icmp ult ptr [[DST_SUB_3]], [[UPPER]]
 ; CHECK-NEXT:    [[RES_2:%.*]] = xor i1 [[RES_1]], [[CMP_SUB_3]]
 ; CHECK-NEXT:    ret i1 [[RES_2]]
 ;
   %sgt.1 = icmp sgt i8 %idx, 1
   call void @llvm.assume(i1 %sgt.1)

 ; CHECK-NEXT:    [[DST_ADD_LEN:%.*]] = getelementptr inbounds i8, ptr [[DST:%.*]], i16 [[LEN_EXT]]
 ; CHECK-NEXT:    [[DST_SUB_1:%.*]] = getelementptr inbounds i8, ptr [[DST_ADD_LEN]], i64 -1
 ; CHECK-NEXT:    [[CMP_SUB_1:%.*]] = icmp ult ptr [[DST_SUB_1]], [[UPPER:%.*]]
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[CMP_SUB_1]])
 ; CHECK-NEXT:    [[CMP_IDX_ULT_LEN:%.*]] = icmp ult i8 [[IDX:%.*]], [[LEN]]
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[CMP_IDX_ULT_LEN]])
 ; CHECK-NEXT:    [[IDX_EXT:%.*]] = zext i8 [[IDX]] to i16
 ; CHECK-NEXT:    [[DST_ADD_IDX:%.*]] = getelementptr inbounds i8, ptr [[DST]], i16 [[IDX_EXT]]
-; CHECK-NEXT:    [[CMP_IDX:%.*]] = icmp ult ptr [[DST_ADD_IDX]], [[UPPER]]
 ; CHECK-NEXT:    ret i1 true
 ;
   %not.zero = icmp ne i8 %len, 0
   call void @llvm.assume(i1 %not.zero)
   %len.ext = zext i8 %len to i16
   %dst.add.len = getelementptr inbounds i8, ptr %dst, i16 %len.ext
   %dst.sub.1 = getelementptr inbounds i8, ptr %dst.add.len, i64 -1
   %cmp.sub.1 = icmp ult ptr %dst.sub.1, %upper

 ; CHECK-NEXT:    [[DST_ADD_LEN:%.*]] = getelementptr inbounds i8, ptr [[DST:%.*]], i16 [[LEN_EXT]]
 ; CHECK-NEXT:    [[DST_SUB_1:%.*]] = getelementptr inbounds i8, ptr [[DST_ADD_LEN]], i64 -1
 ; CHECK-NEXT:    [[CMP_SUB_1:%.*]] = icmp ult ptr [[DST_SUB_1]], [[UPPER:%.*]]
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[CMP_SUB_1]])
 ; CHECK-NEXT:    [[CMP_IDX_ULT_LEN:%.*]] = icmp ult i8 [[IDX:%.*]], [[LEN]]
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[CMP_IDX_ULT_LEN]])
 ; CHECK-NEXT:    [[IDX_EXT:%.*]] = zext i8 [[IDX]] to i16
 ; CHECK-NEXT:    [[DST_ADD_IDX:%.*]] = getelementptr inbounds i8, ptr [[DST]], i16 [[IDX_EXT]]
-; CHECK-NEXT:    [[CMP_IDX:%.*]] = icmp ult ptr [[DST_ADD_IDX]], [[UPPER]]
 ; CHECK-NEXT:    ret i1 true
 ;
   %sge.2 = icmp sge i8 %len, 2
   call void @llvm.assume(i1 %sge.2)
   %len.ext = zext i8 %len to i16
   %dst.add.len = getelementptr inbounds i8, ptr %dst, i16 %len.ext
   %dst.sub.1 = getelementptr inbounds i8, ptr %dst.add.len, i64 -1
   %cmp.sub.1 = icmp ult ptr %dst.sub.1, %upper

 ; CHECK-NEXT:    [[DST_ADD_LEN:%.*]] = getelementptr inbounds i8, ptr [[DST:%.*]], i16 [[LEN_EXT]]
 ; CHECK-NEXT:    [[DST_SUB_1:%.*]] = getelementptr inbounds i8, ptr [[DST_ADD_LEN]], i64 -1
 ; CHECK-NEXT:    [[CMP_SUB_1:%.*]] = icmp ult ptr [[DST_SUB_1]], [[UPPER:%.*]]
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[CMP_SUB_1]])
 ; CHECK-NEXT:    [[CMP_IDX_ULT_LEN:%.*]] = icmp ult i8 [[IDX:%.*]], [[LEN]]
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[CMP_IDX_ULT_LEN]])
 ; CHECK-NEXT:    [[IDX_EXT:%.*]] = zext i8 [[IDX]] to i16
 ; CHECK-NEXT:    [[DST_ADD_IDX:%.*]] = getelementptr inbounds i8, ptr [[DST]], i16 [[IDX_EXT]]
-; CHECK-NEXT:    [[CMP_IDX:%.*]] = icmp ult ptr [[DST_ADD_IDX]], [[UPPER]]
 ; CHECK-NEXT:    ret i1 true
 ;
   %uge.2 = icmp uge i8 %len, 2
   call void @llvm.assume(i1 %uge.2)
   %len.ext = zext i8 %len to i16
   %dst.add.len = getelementptr inbounds i8, ptr %dst, i16 %len.ext
   %dst.sub.1 = getelementptr inbounds i8, ptr %dst.add.len, i64 -1
   %cmp.sub.1 = icmp ult ptr %dst.sub.1, %upper

 }
 
 define i1 @gep_i16_sub_1_uge_inbounds(ptr %dst, ptr %lower) {
 ; CHECK-LABEL: @gep_i16_sub_1_uge_inbounds(
 ; CHECK-NEXT:    [[PRE:%.*]] = icmp uge ptr [[DST:%.*]], [[LOWER:%.*]]
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[PRE]])
 ; CHECK-NEXT:    [[DST_ADD_3:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 3
 ; CHECK-NEXT:    [[DST_SUB_1:%.*]] = getelementptr inbounds i16, ptr [[DST_ADD_3]], i64 -1
-; CHECK-NEXT:    [[CMP_SUB_1:%.*]] = icmp ule ptr [[DST_SUB_1]], [[LOWER]]
 ; CHECK-NEXT:    [[DST_SUB_2:%.*]] = getelementptr inbounds i16, ptr [[DST_ADD_3]], i64 -2
 ; CHECK-NEXT:    [[CMP_SUB_2:%.*]] = icmp ule ptr [[DST_SUB_2]], [[DST]]
 ; CHECK-NEXT:    [[RES_1:%.*]] = xor i1 false, [[CMP_SUB_2]]
 ; CHECK-NEXT:    [[DST_SUB_3:%.*]] = getelementptr inbounds i16, ptr [[DST_ADD_3]], i64 -3
 ; CHECK-NEXT:    [[CMP_SUB_3:%.*]] = icmp ule ptr [[DST_SUB_3]], [[LOWER]]
 ; CHECK-NEXT:    [[RES_2:%.*]] = xor i1 [[RES_1]], [[CMP_SUB_3]]
 ; CHECK-NEXT:    ret i1 [[RES_2]]
 ;

llvm/test/Transforms/ConstraintElimination/geps-i32-pointer-indexes.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -passes=constraint-elimination -S %s | FileCheck %s
 
 target datalayout = "p:32:32:32"
 
 declare void @llvm.assume(i1)
 
 define i1 @gep_idx_implicit_truncate(ptr %dst, i64 %off) {
 ; CHECK-LABEL: @gep_idx_implicit_truncate(
 ; CHECK-NEXT:    [[POS:%.*]] = icmp sge i64 [[OFF:%.*]], 0
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[POS]])
 ; CHECK-NEXT:    [[GEP_OFF:%.*]] = getelementptr inbounds i8, ptr [[DST:%.*]], i64 [[OFF]]
-; CHECK-NEXT:    [[CMP:%.*]] = icmp ule ptr [[DST]], [[GEP_OFF]]
 ; CHECK-NEXT:    ret i1 true
 ;
   %pos = icmp sge i64 %off, 0
   call void @llvm.assume(i1 %pos)
   %gep.off = getelementptr inbounds i8, ptr %dst, i64 %off
   %cmp = icmp ule ptr %dst, %gep.off
   ret i1 %cmp
 }

llvm/test/Transforms/ConstraintElimination/geps-pointers-to-arrays.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -passes=constraint-elimination -S %s | FileCheck %s
 
 define void @pointer.to.array.test.ult.true.due.to.first.dimension(ptr %start, ptr %high) {
 ; CHECK-LABEL: @pointer.to.array.test.ult.true.due.to.first.dimension(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[ADD_PTR_I:%.*]] = getelementptr inbounds [10 x i8], ptr [[START:%.*]], i64 9, i64 3
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ule ptr [[ADD_PTR_I]], [[HIGH:%.*]]
 ; CHECK-NEXT:    br i1 [[C_1]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
 ; CHECK:       if.then:
 ; CHECK-NEXT:    [[START_0:%.*]] = getelementptr inbounds [10 x i8], ptr [[START]], i64 5, i64 0
-; CHECK-NEXT:    [[C_0:%.*]] = icmp ult ptr [[START_0]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    ret void
 ; CHECK:       if.end:
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %add.ptr.i = getelementptr inbounds [10 x i8], ptr %start, i64 9, i64 3
   %c.1 = icmp ule ptr %add.ptr.i, %high

 define void @pointer.to.array.test.ult.true.due.to.second.dimension(ptr %start, ptr %high) {
 ; CHECK-LABEL: @pointer.to.array.test.ult.true.due.to.second.dimension(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[ADD_PTR_I:%.*]] = getelementptr inbounds [10 x i8], ptr [[START:%.*]], i64 5, i64 1
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ule ptr [[ADD_PTR_I]], [[HIGH:%.*]]
 ; CHECK-NEXT:    br i1 [[C_1]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
 ; CHECK:       if.then:
 ; CHECK-NEXT:    [[START_0:%.*]] = getelementptr inbounds [10 x i8], ptr [[START]], i64 5, i64 0
-; CHECK-NEXT:    [[C_0:%.*]] = icmp ult ptr [[START_0]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    ret void
 ; CHECK:       if.end:
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %add.ptr.i = getelementptr inbounds [10 x i8], ptr %start, i64 5, i64 1
   %c.1 = icmp ule ptr %add.ptr.i, %high

llvm/test/Transforms/ConstraintElimination/geps-pointers-to-structs.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -passes=constraint-elimination -S %s | FileCheck %s
 
 %struct.1 = type { i32, i64, i8 }
 %struct.2 = type { i32, [20 x i64], i8 }
 
 define i1 @test.ult.true.due.to.first.dimension(ptr %start, ptr %high) {
 ; CHECK-LABEL: @test.ult.true.due.to.first.dimension(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[ADD_PTR:%.*]] = getelementptr inbounds [[STRUCT_1:%.*]], ptr [[START:%.*]], i64 6, i32 0
 ; CHECK-NEXT:    [[ADD_PTR_CAST:%.*]] = bitcast ptr [[ADD_PTR]] to ptr
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ule ptr [[ADD_PTR_CAST]], [[HIGH:%.*]]
 ; CHECK-NEXT:    br i1 [[C_1]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
 ; CHECK:       if.then:
 ; CHECK-NEXT:    [[START_0:%.*]] = getelementptr inbounds [[STRUCT_1]], ptr [[START]], i64 5, i32 0
 ; CHECK-NEXT:    [[START_0_CAST:%.*]] = bitcast ptr [[START_0]] to ptr
-; CHECK-NEXT:    [[C_0:%.*]] = icmp ult ptr [[START_0_CAST]], [[HIGH]]
 ; CHECK-NEXT:    ret i1 true
 ; CHECK:       if.end:
 ; CHECK-NEXT:    ret i1 true
 ;
 entry:
   %add.ptr = getelementptr inbounds %struct.1, ptr %start, i64 6, i32 0
   %add.ptr.cast = bitcast ptr %add.ptr to ptr
   %c.1 = icmp ule ptr %add.ptr.cast, %high

 ; CHECK-NEXT:    [[ADD_PTR:%.*]] = getelementptr inbounds [[STRUCT_1:%.*]], ptr [[START:%.*]], i64 [[IDX_EXT_PLUS_1_EXT]], i32 0
 ; CHECK-NEXT:    [[ADD_PTR_CAST:%.*]] = bitcast ptr [[ADD_PTR]] to ptr
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ule ptr [[ADD_PTR_CAST]], [[HIGH:%.*]]
 ; CHECK-NEXT:    br i1 [[C_1]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
 ; CHECK:       if.then:
 ; CHECK-NEXT:    [[IDX_EXT:%.*]] = zext i32 [[IDX]] to i64
 ; CHECK-NEXT:    [[START_0:%.*]] = getelementptr inbounds [[STRUCT_1]], ptr [[START]], i64 [[IDX_EXT]], i32 0
 ; CHECK-NEXT:    [[START_0_CAST:%.*]] = bitcast ptr [[START_0]] to ptr
-; CHECK-NEXT:    [[C_0:%.*]] = icmp ult ptr [[START_0_CAST]], [[HIGH]]
 ; CHECK-NEXT:    ret i1 true
 ; CHECK:       if.end:
 ; CHECK-NEXT:    ret i1 true
 ;
 entry:
   %idx.ext.plus.1 = add nuw nsw i32 %idx, 1
   %idx.ext.plus.1.ext = zext i32 %idx.ext.plus.1 to i64
   %add.ptr = getelementptr inbounds %struct.1, ptr %start, i64 %idx.ext.plus.1.ext, i32 0

 ; CHECK-NEXT:    [[ADD_PTR:%.*]] = getelementptr inbounds [[STRUCT_1:%.*]], ptr [[START:%.*]], i64 [[IDX_EXT_PLUS_1_EXT]], i32 0
 ; CHECK-NEXT:    [[ADD_PTR_CAST:%.*]] = bitcast ptr [[ADD_PTR]] to ptr
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ule ptr [[ADD_PTR_CAST]], [[HIGH:%.*]]
 ; CHECK-NEXT:    br i1 [[C_1]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
 ; CHECK:       if.then:
 ; CHECK-NEXT:    [[IDX_EXT:%.*]] = zext i32 [[IDX]] to i64
 ; CHECK-NEXT:    [[START_0:%.*]] = getelementptr inbounds [[STRUCT_1]], ptr [[START]], i64 [[IDX_EXT]], i32 1
 ; CHECK-NEXT:    [[START_0_CAST:%.*]] = bitcast ptr [[START_0]] to ptr
-; CHECK-NEXT:    [[C_0:%.*]] = icmp ult ptr [[START_0_CAST]], [[HIGH]]
 ; CHECK-NEXT:    ret i1 true
 ; CHECK:       if.end:
 ; CHECK-NEXT:    ret i1 true
 ;
 entry:
   %idx.ext.plus.1 = add nuw nsw i32 %idx, 1
   %idx.ext.plus.1.ext = zext i32 %idx.ext.plus.1 to i64
   %add.ptr = getelementptr inbounds %struct.1, ptr %start, i64 %idx.ext.plus.1.ext, i32 0

 ; CHECK-NEXT:    [[IDX_EXT_PLUS_1_EXT:%.*]] = zext i32 [[IDX_EXT_PLUS_1]] to i64
 ; CHECK-NEXT:    [[ADD_PTR:%.*]] = getelementptr inbounds [[STRUCT_1:%.*]], ptr [[START:%.*]], i64 [[IDX_EXT_PLUS_1_EXT]], i32 0
 ; CHECK-NEXT:    [[ADD_PTR_CAST:%.*]] = bitcast ptr [[ADD_PTR]] to ptr
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ule ptr [[ADD_PTR_CAST]], [[HIGH:%.*]]
 ; CHECK-NEXT:    br i1 [[C_1]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
 ; CHECK:       if.then:
 ; CHECK-NEXT:    [[IDX_EXT:%.*]] = zext i32 [[IDX]] to i64
 ; CHECK-NEXT:    [[START_0:%.*]] = getelementptr inbounds [[STRUCT_1]], ptr [[START]], i64 [[IDX_EXT]], i32 2
-; CHECK-NEXT:    [[C_0:%.*]] = icmp ult ptr [[START_0]], [[HIGH]]
 ; CHECK-NEXT:    ret i1 true
 ; CHECK:       if.end:
 ; CHECK-NEXT:    ret i1 true
 ;
 entry:
   %idx.ext.plus.1 = add nuw nsw i32 %idx, 1
   %idx.ext.plus.1.ext = zext i32 %idx.ext.plus.1 to i64
   %add.ptr = getelementptr inbounds %struct.1, ptr %start, i64 %idx.ext.plus.1.ext, i32 0

 ; CHECK-LABEL: @test.ult.true.due.to.second.dimension(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[ADD_PTR:%.*]] = getelementptr inbounds [[STRUCT_1:%.*]], ptr [[START:%.*]], i64 5, i32 2
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ule ptr [[ADD_PTR]], [[HIGH:%.*]]
 ; CHECK-NEXT:    br i1 [[C_1]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
 ; CHECK:       if.then:
 ; CHECK-NEXT:    [[START_0:%.*]] = getelementptr inbounds [[STRUCT_1]], ptr [[START]], i64 5, i32 1
 ; CHECK-NEXT:    [[START_0_CAST:%.*]] = bitcast ptr [[START_0]] to ptr
-; CHECK-NEXT:    [[C_0:%.*]] = icmp ult ptr [[START_0_CAST]], [[HIGH]]
 ; CHECK-NEXT:    ret i1 true
 ; CHECK:       if.end:
 ; CHECK-NEXT:    ret i1 true
 ;
 entry:
   %add.ptr = getelementptr inbounds %struct.1, ptr %start, i64 5, i32 2
   %c.1 = icmp ule ptr %add.ptr, %high
   br i1 %c.1, label %if.then, label %if.end

 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[ADD_PTR:%.*]] = getelementptr inbounds [[STRUCT_2:%.*]], ptr [[START:%.*]], i64 6, i32 1, i32 5
 ; CHECK-NEXT:    [[ADD_PTR_CAST:%.*]] = bitcast ptr [[ADD_PTR]] to ptr
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ule ptr [[ADD_PTR_CAST]], [[HIGH:%.*]]
 ; CHECK-NEXT:    br i1 [[C_1]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
 ; CHECK:       if.then:
 ; CHECK-NEXT:    [[START_0:%.*]] = getelementptr inbounds [[STRUCT_2]], ptr [[START]], i64 6, i32 0
 ; CHECK-NEXT:    [[START_0_CAST:%.*]] = bitcast ptr [[START_0]] to ptr
-; CHECK-NEXT:    [[C_0:%.*]] = icmp ult ptr [[START_0_CAST]], [[HIGH]]
 ; CHECK-NEXT:    ret i1 true
 ; CHECK:       if.end:
 ; CHECK-NEXT:    ret i1 true
 ;
 entry:
   %add.ptr = getelementptr inbounds %struct.2, ptr %start, i64 6, i32 1, i32 5
   %add.ptr.cast = bitcast ptr %add.ptr to ptr
   %c.1 = icmp ule ptr %add.ptr.cast, %high

 ; CHECK-NEXT:    [[ADD_PTR:%.*]] = getelementptr inbounds [[STRUCT_2:%.*]], ptr [[START:%.*]], i64 6, i32 1, i64 [[IDX_EXT_PLUS_1_EXT]]
 ; CHECK-NEXT:    [[ADD_PTR_CAST:%.*]] = bitcast ptr [[ADD_PTR]] to ptr
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ule ptr [[ADD_PTR_CAST]], [[HIGH:%.*]]
 ; CHECK-NEXT:    br i1 [[C_1]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
 ; CHECK:       if.then:
 ; CHECK-NEXT:    [[IDX_EXT:%.*]] = zext i32 [[IDX]] to i64
 ; CHECK-NEXT:    [[START_0:%.*]] = getelementptr inbounds [[STRUCT_2]], ptr [[START]], i64 6, i32 1, i64 [[IDX_EXT]]
 ; CHECK-NEXT:    [[START_0_CAST:%.*]] = bitcast ptr [[START_0]] to ptr
-; CHECK-NEXT:    [[C_0:%.*]] = icmp ult ptr [[START_0_CAST]], [[HIGH]]
 ; CHECK-NEXT:    ret i1 true
 ; CHECK:       if.end:
 ; CHECK-NEXT:    ret i1 true
 ;
 entry:
   %idx.ext.plus.1 = add nuw nsw i32 %idx, 1
   %idx.ext.plus.1.ext = zext i32 %idx.ext.plus.1 to i64
   %add.ptr = getelementptr inbounds %struct.2, ptr %start, i64 6, i32 1, i64 %idx.ext.plus.1.ext

llvm/test/Transforms/ConstraintElimination/geps-ptrvector.ll

;
   %gep = getelementptr inbounds i32, <2 x ptr> %vec, i64 0
   %cond = icmp ule <2 x ptr> %gep, zeroinitializer
   ret <2 x i1> %cond
 }
 
 define <2 x i1> @test.vectorgep.ult.true(<2 x ptr> %vec) {
 ; CHECK-LABEL: @test.vectorgep.ult.true(
 ; CHECK-NEXT:    [[GEP_1:%.*]] = getelementptr inbounds i32, <2 x ptr> [[VEC:%.*]], i64 1
-; CHECK-NEXT:    [[T_1:%.*]] = icmp ult <2 x ptr> [[VEC]], [[GEP_1]]
 ; CHECK-NEXT:    ret <2 x i1> <i1 true, i1 true>
 ;
   %gep.1 = getelementptr inbounds i32, <2 x ptr> %vec, i64 1
   %t.1 = icmp ult <2 x ptr> %vec, %gep.1
   ret <2 x i1> %t.1
 }
 
 define <2 x i1> @test.vectorgep.ult.false(<2 x ptr> %vec) {
 ; CHECK-LABEL: @test.vectorgep.ult.false(
 ; CHECK-NEXT:    [[GEP_1:%.*]] = getelementptr inbounds i32, <2 x ptr> [[VEC:%.*]], i64 1
-; CHECK-NEXT:    [[T_1:%.*]] = icmp ult <2 x ptr> [[GEP_1]], [[VEC]]
 ; CHECK-NEXT:    ret <2 x i1> zeroinitializer
 ;
   %gep.1 = getelementptr inbounds i32, <2 x ptr> %vec, i64 1
   %t.1 = icmp ult <2 x ptr> %gep.1, %vec
   ret <2 x i1> %t.1
 }
 
 
 define <vscale x 2 x i1> @test.scalable.vectorgep.ult.true(<vscale x 2 x ptr> %vec) {
 ; CHECK-LABEL: @test.scalable.vectorgep.ult.true(
 ; CHECK-NEXT:    [[GEP_1:%.*]] = getelementptr inbounds i32, <vscale x 2 x ptr> [[VEC:%.*]], i64 1
-; CHECK-NEXT:    [[T_1:%.*]] = icmp ult <vscale x 2 x ptr> [[VEC]], [[GEP_1]]
 ; CHECK-NEXT:    ret <vscale x 2 x i1> shufflevector (<vscale x 2 x i1> insertelement (<vscale x 2 x i1> poison, i1 true, i64 0), <vscale x 2 x i1> poison, <vscale x 2 x i32> zeroinitializer)
 ;
   %gep.1 = getelementptr inbounds i32, <vscale x 2 x ptr> %vec, i64 1
   %t.1 = icmp ult <vscale x 2 x ptr> %vec, %gep.1
   ret <vscale x 2 x i1> %t.1
 }
 
 define <vscale x 2 x i1> @test.scalable.vectorgep.ult.false(<vscale x 2 x ptr> %vec) {
 ; CHECK-LABEL: @test.scalable.vectorgep.ult.false(
 ; CHECK-NEXT:    [[GEP_1:%.*]] = getelementptr inbounds i32, <vscale x 2 x ptr> [[VEC:%.*]], i64 1
-; CHECK-NEXT:    [[T_1:%.*]] = icmp ult <vscale x 2 x ptr> [[GEP_1]], [[VEC]]
 ; CHECK-NEXT:    ret <vscale x 2 x i1> zeroinitializer
 ;
   %gep.1 = getelementptr inbounds i32, <vscale x 2 x ptr> %vec, i64 1
   %t.1 = icmp ult <vscale x 2 x ptr> %gep.1, %vec
   ret <vscale x 2 x i1> %t.1
 }

llvm/test/Transforms/ConstraintElimination/geps-unsigned-predicates.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -passes=constraint-elimination -S %s | FileCheck %s
 
 define i32 @test.ult(ptr readonly %src, ptr readnone %min, ptr readnone %max) {
 ; CHECK-LABEL: @test.ult(
 ; CHECK-NEXT:  check.0.min:
 ; CHECK-NEXT:    [[C_MIN_0:%.*]] = icmp ult ptr [[SRC:%.*]], [[MIN:%.*]]
 ; CHECK-NEXT:    br i1 [[C_MIN_0]], label [[TRAP:%.*]], label [[CHECK_0_MAX:%.*]]
 ; CHECK:       trap:
 ; CHECK-NEXT:    ret i32 10
 ; CHECK:       check.0.max:
 ; CHECK-NEXT:    [[C_MAX_0:%.*]] = icmp ult ptr [[SRC]], [[MAX:%.*]]
 ; CHECK-NEXT:    br i1 [[C_MAX_0]], label [[CHECK_3_MIN:%.*]], label [[TRAP]]
 ; CHECK:       check.3.min:
 ; CHECK-NEXT:    [[L0:%.*]] = load i32, ptr [[SRC]], align 4
 ; CHECK-NEXT:    [[ADD_PTR_I36:%.*]] = getelementptr inbounds i32, ptr [[SRC]], i64 3
-; CHECK-NEXT:    [[C_3_MIN:%.*]] = icmp ult ptr [[ADD_PTR_I36]], [[MIN]]
 ; CHECK-NEXT:    br i1 false, label [[TRAP]], label [[CHECK_3_MAX:%.*]]
 ; CHECK:       check.3.max:
 ; CHECK-NEXT:    [[C_3_MAX:%.*]] = icmp ult ptr [[ADD_PTR_I36]], [[MAX]]
 ; CHECK-NEXT:    br i1 [[C_3_MAX]], label [[CHECK_1_MIN:%.*]], label [[TRAP]]
 ; CHECK:       check.1.min:
 ; CHECK-NEXT:    [[L1:%.*]] = load i32, ptr [[ADD_PTR_I36]], align 4
 ; CHECK-NEXT:    [[ADD_PTR_I29:%.*]] = getelementptr inbounds i32, ptr [[SRC]], i64 1
-; CHECK-NEXT:    [[C_1_MIN:%.*]] = icmp ult ptr [[ADD_PTR_I29]], [[MIN]]
 ; CHECK-NEXT:    br i1 false, label [[TRAP]], label [[CHECK_1_MAX:%.*]]
 ; CHECK:       check.1.max:
-; CHECK-NEXT:    [[C_1_MAX:%.*]] = icmp ult ptr [[ADD_PTR_I29]], [[MAX]]
 ; CHECK-NEXT:    br i1 true, label [[CHECK_2_MIN:%.*]], label [[TRAP]]
 ; CHECK:       check.2.min:
 ; CHECK-NEXT:    [[L2:%.*]] = load i32, ptr [[ADD_PTR_I29]], align 4
 ; CHECK-NEXT:    [[ADD_PTR_I:%.*]] = getelementptr inbounds i32, ptr [[SRC]], i64 2
-; CHECK-NEXT:    [[C_2_MIN:%.*]] = icmp ult ptr [[ADD_PTR_I]], [[MIN]]
 ; CHECK-NEXT:    br i1 false, label [[TRAP]], label [[CHECK_2_MAX:%.*]]
 ; CHECK:       check.2.max:
-; CHECK-NEXT:    [[C_2_MAX:%.*]] = icmp ult ptr [[ADD_PTR_I]], [[MAX]]
 ; CHECK-NEXT:    br i1 true, label [[EXIT:%.*]], label [[TRAP]]
 ; CHECK:       exit:
 ; CHECK-NEXT:    [[L3:%.*]] = load i32, ptr [[ADD_PTR_I]], align 4
 ; CHECK-NEXT:    [[ADD:%.*]] = add nsw i32 [[L1]], [[L0]]
 ; CHECK-NEXT:    [[ADD8:%.*]] = add nsw i32 [[ADD]], [[L2]]
 ; CHECK-NEXT:    [[ADD9:%.*]] = add nsw i32 [[ADD8]], [[L3]]
 ; CHECK-NEXT:    ret i32 [[ADD9]]
 ;

 ; CHECK-LABEL: @test.not.uge.ult(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[ADD_PTR_I:%.*]] = getelementptr inbounds i8, ptr [[START:%.*]], i64 3
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp uge ptr [[ADD_PTR_I]], [[HIGH:%.*]]
 ; CHECK-NEXT:    br i1 [[C_1]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
 ; CHECK:       if.then:
 ; CHECK-NEXT:    ret void
 ; CHECK:       if.end:
-; CHECK-NEXT:    [[T_0:%.*]] = icmp ult ptr [[START]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    [[START_1:%.*]] = getelementptr inbounds i8, ptr [[START]], i64 1
-; CHECK-NEXT:    [[T_1:%.*]] = icmp ult ptr [[START_1]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    [[START_2:%.*]] = getelementptr inbounds i8, ptr [[START]], i64 2
-; CHECK-NEXT:    [[T_2:%.*]] = icmp ult ptr [[START_2]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    [[START_3:%.*]] = getelementptr inbounds i8, ptr [[START]], i64 3
-; CHECK-NEXT:    [[T_3:%.*]] = icmp ult ptr [[START_3]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    [[START_4:%.*]] = getelementptr inbounds i8, ptr [[START]], i64 4
 ; CHECK-NEXT:    [[C_4:%.*]] = icmp ult ptr [[START_4]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 [[C_4]])
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %add.ptr.i = getelementptr inbounds i8, ptr %start, i64 3

 ; CHECK-LABEL: @test.not.uge.ule(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[ADD_PTR_I:%.*]] = getelementptr inbounds i8, ptr [[START:%.*]], i64 3
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp uge ptr [[ADD_PTR_I]], [[HIGH:%.*]]
 ; CHECK-NEXT:    br i1 [[C_1]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
 ; CHECK:       if.then:
 ; CHECK-NEXT:    ret void
 ; CHECK:       if.end:
-; CHECK-NEXT:    [[T_0:%.*]] = icmp ule ptr [[START]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    [[START_1:%.*]] = getelementptr inbounds i8, ptr [[START]], i64 1
-; CHECK-NEXT:    [[T_1:%.*]] = icmp ule ptr [[START_1]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    [[START_2:%.*]] = getelementptr inbounds i8, ptr [[START]], i64 2
-; CHECK-NEXT:    [[T_2:%.*]] = icmp ule ptr [[START_2]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    [[START_3:%.*]] = getelementptr inbounds i8, ptr [[START]], i64 3
-; CHECK-NEXT:    [[T_3:%.*]] = icmp ule ptr [[START_3]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    [[START_4:%.*]] = getelementptr inbounds i8, ptr [[START]], i64 4
-; CHECK-NEXT:    [[T_4:%.*]] = icmp ule ptr [[START_4]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    [[START_5:%.*]] = getelementptr inbounds i8, ptr [[START]], i64 5
 ; CHECK-NEXT:    [[C_5:%.*]] = icmp ule ptr [[START_5]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 [[C_5]])
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %add.ptr.i = getelementptr inbounds i8, ptr %start, i64 3

 ; CHECK-LABEL: @test.not.uge.ugt(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[ADD_PTR_I:%.*]] = getelementptr inbounds i8, ptr [[START:%.*]], i64 3
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp uge ptr [[ADD_PTR_I]], [[HIGH:%.*]]
 ; CHECK-NEXT:    br i1 [[C_1]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
 ; CHECK:       if.then:
 ; CHECK-NEXT:    ret void
 ; CHECK:       if.end:
-; CHECK-NEXT:    [[F_0:%.*]] = icmp ugt ptr [[START]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 false)
 ; CHECK-NEXT:    [[START_1:%.*]] = getelementptr inbounds i8, ptr [[START]], i64 1
-; CHECK-NEXT:    [[F_1:%.*]] = icmp ugt ptr [[START_1]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 false)
 ; CHECK-NEXT:    [[START_2:%.*]] = getelementptr inbounds i8, ptr [[START]], i64 2
-; CHECK-NEXT:    [[F_2:%.*]] = icmp ugt ptr [[START_2]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 false)
 ; CHECK-NEXT:    [[START_3:%.*]] = getelementptr inbounds i8, ptr [[START]], i64 3
-; CHECK-NEXT:    [[F_3:%.*]] = icmp ugt ptr [[START_3]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 false)
 ; CHECK-NEXT:    [[START_4:%.*]] = getelementptr inbounds i8, ptr [[START]], i64 4
-; CHECK-NEXT:    [[F_4:%.*]] = icmp ugt ptr [[START_4]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 false)
 ; CHECK-NEXT:    [[START_5:%.*]] = getelementptr inbounds i8, ptr [[START]], i64 5
 ; CHECK-NEXT:    [[C_5:%.*]] = icmp ugt ptr [[START_5]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 [[C_5]])
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %add.ptr.i = getelementptr inbounds i8, ptr %start, i64 3

 ; CHECK-LABEL: @test.not.uge.uge(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[ADD_PTR_I:%.*]] = getelementptr inbounds i8, ptr [[START:%.*]], i64 3
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp uge ptr [[ADD_PTR_I]], [[HIGH:%.*]]
 ; CHECK-NEXT:    br i1 [[C_1]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
 ; CHECK:       if.then:
 ; CHECK-NEXT:    ret void
 ; CHECK:       if.end:
-; CHECK-NEXT:    [[F_0:%.*]] = icmp ugt ptr [[START]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 false)
 ; CHECK-NEXT:    [[START_1:%.*]] = getelementptr inbounds i8, ptr [[START]], i64 1
-; CHECK-NEXT:    [[F_1:%.*]] = icmp uge ptr [[START_1]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 false)
 ; CHECK-NEXT:    [[START_2:%.*]] = getelementptr inbounds i8, ptr [[START]], i64 2
-; CHECK-NEXT:    [[F_2:%.*]] = icmp uge ptr [[START_2]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 false)
 ; CHECK-NEXT:    [[START_3:%.*]] = getelementptr inbounds i8, ptr [[START]], i64 3
-; CHECK-NEXT:    [[F_3:%.*]] = icmp uge ptr [[START_3]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 false)
 ; CHECK-NEXT:    [[START_4:%.*]] = getelementptr inbounds i8, ptr [[START]], i64 4
 ; CHECK-NEXT:    [[C_4:%.*]] = icmp uge ptr [[START_4]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 [[C_4]])
 ; CHECK-NEXT:    [[START_5:%.*]] = getelementptr inbounds i8, ptr [[START]], i64 5
 ; CHECK-NEXT:    [[C_5:%.*]] = icmp uge ptr [[START_5]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 [[C_5]])
 ; CHECK-NEXT:    ret void

 ; CHECK:       trap:
 ; CHECK-NEXT:    ret void
 ; CHECK:       check.idx:
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp ult i8 [[IDX:%.*]], 5
 ; CHECK-NEXT:    br i1 [[CMP]], label [[CHECK_MAX:%.*]], label [[TRAP]]
 ; CHECK:       check.max:
 ; CHECK-NEXT:    [[IDX_SHL_1:%.*]] = shl nuw nsw i8 [[IDX]], 1
 ; CHECK-NEXT:    [[ADD_PTR_SHL_1:%.*]] = getelementptr inbounds i32, ptr [[SRC]], i8 [[IDX_SHL_1]]
-; CHECK-NEXT:    [[C_MAX_0:%.*]] = icmp ult ptr [[ADD_PTR_SHL_1]], [[MAX]]
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    [[IDX_SHL_2:%.*]] = shl nuw i8 [[IDX]], 2
 ; CHECK-NEXT:    [[ADD_PTR_SHL_2:%.*]] = getelementptr inbounds i32, ptr [[SRC]], i8 [[IDX_SHL_2]]
 ; CHECK-NEXT:    [[C_MAX_1:%.*]] = icmp ult ptr [[ADD_PTR_SHL_2]], [[MAX]]
 ; CHECK-NEXT:    call void @use(i1 [[C_MAX_1]])
 ; CHECK-NEXT:    [[IDX_SHL_NOT_NUW:%.*]] = shl i8 [[IDX]], 1
 ; CHECK-NEXT:    [[ADD_PTR_SHL_NOT_NUW:%.*]] = getelementptr inbounds i32, ptr [[SRC]], i8 [[IDX_SHL_NOT_NUW]]
 ; CHECK-NEXT:    [[C_MAX_2:%.*]] = icmp ult ptr [[ADD_PTR_SHL_NOT_NUW]], [[MAX]]

 ; CHECK-NEXT:    ret void
 ; CHECK:       check.idx:
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp ult i32 [[IDX:%.*]], 5
 ; CHECK-NEXT:    br i1 [[CMP]], label [[CHECK_MAX:%.*]], label [[TRAP]]
 ; CHECK:       check.max:
 ; CHECK-NEXT:    [[IDX_SHL:%.*]] = shl nuw i32 [[IDX]], 1
 ; CHECK-NEXT:    [[EXT_1:%.*]] = zext i32 [[IDX_SHL]] to i64
 ; CHECK-NEXT:    [[ADD_PTR_SHL:%.*]] = getelementptr inbounds i32, ptr [[SRC]], i64 [[EXT_1]]
-; CHECK-NEXT:    [[C_MAX_0:%.*]] = icmp ult ptr [[ADD_PTR_SHL]], [[MAX]]
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    [[IDX_SHL_NOT_NUW:%.*]] = shl i32 [[IDX]], 1
 ; CHECK-NEXT:    [[EXT_2:%.*]] = zext i32 [[IDX_SHL_NOT_NUW]] to i64
 ; CHECK-NEXT:    [[ADD_PTR_SHL_NOT_NUW:%.*]] = getelementptr inbounds i32, ptr [[SRC]], i64 [[EXT_2]]
 ; CHECK-NEXT:    [[C_MAX_1:%.*]] = icmp ult ptr [[ADD_PTR_SHL_NOT_NUW]], [[MAX]]
 ; CHECK-NEXT:    call void @use(i1 [[C_MAX_1]])
 ; CHECK-NEXT:    [[IDX_SHL_3:%.*]] = shl nuw i32 [[IDX]], 2
 ; CHECK-NEXT:    [[EXT_3:%.*]] = zext i32 [[IDX_SHL_3]] to i64

llvm/test/Transforms/ConstraintElimination/invoke.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -passes=constraint-elimination -S %s | FileCheck %s
 
 declare void @may_unwind()
 
 declare i32 @__gxx_personality_v0(...)
 
 define i1 @test_invoke_in_block_with_assume(i32 %x) personality ptr @__gxx_personality_v0 {
 ; CHECK-LABEL: @test_invoke_in_block_with_assume(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    call void @may_unwind()
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ult i32 [[X:%.*]], 10
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C_1]])
 ; CHECK-NEXT:    invoke void @may_unwind()
 ; CHECK-NEXT:    to label [[CONT:%.*]] unwind label [[LPAD:%.*]]
 ; CHECK:       cont:
-; CHECK-NEXT:    [[T_1:%.*]] = icmp ult i32 [[X]], 10
 ; CHECK-NEXT:    [[C_2:%.*]] = icmp ult i32 [[X]], 9
 ; CHECK-NEXT:    [[RES_1:%.*]] = xor i1 true, [[C_2]]
 ; CHECK-NEXT:    ret i1 [[RES_1]]
 ; CHECK:       lpad:
 ; CHECK-NEXT:    [[LP:%.*]] = landingpad { ptr, i32 }
 ; CHECK-NEXT:    filter [0 x ptr] zeroinitializer
-; CHECK-NEXT:    [[T_2:%.*]] = icmp ult i32 [[X]], 10
 ; CHECK-NEXT:    [[C_3:%.*]] = icmp ult i32 [[X]], 9
 ; CHECK-NEXT:    [[RES_2:%.*]] = xor i1 true, [[C_3]]
 ; CHECK-NEXT:    ret i1 [[RES_2]]
 ;
 entry:
   call void @may_unwind()
   %c.1 = icmp ult i32 %x, 10
   call void @llvm.assume(i1 %c.1)

llvm/test/Transforms/ConstraintElimination/large-constant-ints.ll

 define i1 @sub_decomp_i80(i80 %a) {
 ; CHECK-LABEL: @sub_decomp_i80(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[SUB:%.*]] = sub nuw i80 [[A:%.*]], 1973801615886922022913
 ; CHECK-NEXT:    [[C:%.*]] = icmp ult i80 [[SUB]], 1346612317380797267967
 ; CHECK-NEXT:    br i1 [[C]], label [[THEN:%.*]], label [[ELSE:%.*]]
 ; CHECK:       then:
 ; CHECK-NEXT:    [[SUB_1:%.*]] = sub nuw i80 [[A]], 1973801615886922022913
-; CHECK-NEXT:    [[C_1:%.*]] = icmp ult i80 [[SUB_1]], 1346612317380797267967
 ; CHECK-NEXT:    ret i1 true
 ; CHECK:       else:
 ; CHECK-NEXT:    ret i1 false
 ;
 entry:
   %sub = sub nuw i80 %a, 1973801615886922022913
   %c = icmp ult i80 %sub, 1346612317380797267967
   br i1 %c, label %then, label %else

 define i1 @gep_decomp_i80(ptr %a) {
 ; CHECK-LABEL: @gep_decomp_i80(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[GEP:%.*]] = getelementptr inbounds i8, ptr [[A:%.*]], i80 1973801615886922022913
 ; CHECK-NEXT:    [[C:%.*]] = icmp eq ptr [[GEP]], null
 ; CHECK-NEXT:    br i1 [[C]], label [[THEN:%.*]], label [[ELSE:%.*]]
 ; CHECK:       then:
 ; CHECK-NEXT:    [[GEP_1:%.*]] = getelementptr inbounds i8, ptr [[A]], i80 1973801615886922022913
-; CHECK-NEXT:    [[C_1:%.*]] = icmp eq ptr [[GEP_1]], null
 ; CHECK-NEXT:    ret i1 true
 ; CHECK:       else:
 ; CHECK-NEXT:    ret i1 false
 ;
 entry:
   %gep = getelementptr inbounds i8, ptr %a, i80 1973801615886922022913
   %c = icmp eq ptr %gep, null
   br i1 %c, label %then, label %else

 
 define i1 @gep_decomp_large_index_63_bits(ptr %a) {
 ; CHECK-LABEL: @gep_decomp_large_index_63_bits(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[GEP_1:%.*]] = getelementptr inbounds i64, ptr [[A:%.*]], i64 9223372036854775804
 ; CHECK-NEXT:    [[GEP_2:%.*]] = getelementptr inbounds i64, ptr [[A]], i64 9223372036854775805
 ; CHECK-NEXT:    [[NE:%.*]] = icmp ne ptr [[GEP_1]], [[GEP_2]]
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[NE]])
-; CHECK-NEXT:    [[CMP_ULE:%.*]] = icmp ule ptr [[GEP_1]], [[GEP_2]]
 ; CHECK-NEXT:    [[CMP_UGE:%.*]] = icmp uge ptr [[GEP_1]], [[GEP_2]]
 ; CHECK-NEXT:    [[RES:%.*]] = xor i1 true, true
 ; CHECK-NEXT:    ret i1 [[RES]]
 ;
 entry:
   %gep.1 = getelementptr inbounds i64, ptr %a, i64 9223372036854775804
   %gep.2 = getelementptr inbounds i64, ptr %a, i64 9223372036854775805
   %ne = icmp ne ptr %gep.1, %gep.2
   call void @llvm.assume(i1 %ne)
   %cmp.ule = icmp ule ptr %gep.1, %gep.2
   %cmp.uge = icmp uge ptr %gep.1, %gep.2
   %res = xor i1 %cmp.ule, %cmp.ule
   ret i1 %res
 }
 
 define i1 @gep_decomp_large_index_63_bits_chained_overflow(ptr %a) {
 ; CHECK-LABEL: @gep_decomp_large_index_63_bits_chained_overflow(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[GEP_1:%.*]] = getelementptr inbounds i64, ptr [[A:%.*]], i64 9223372036854775804
 ; CHECK-NEXT:    [[GEP_2:%.*]] = getelementptr inbounds ptr, ptr [[A]], i64 1152921504606846976
 ; CHECK-NEXT:    [[GEP_3:%.*]] = getelementptr inbounds i64, ptr [[GEP_2]], i64 1152921504606846976
 ; CHECK-NEXT:    [[NE:%.*]] = icmp ne ptr [[GEP_1]], [[GEP_3]]
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[NE]])
-; CHECK-NEXT:    [[CMP_ULE:%.*]] = icmp ule ptr [[GEP_1]], [[GEP_3]]
 ; CHECK-NEXT:    [[CMP_UGE:%.*]] = icmp uge ptr [[GEP_1]], [[GEP_3]]
 ; CHECK-NEXT:    [[RES:%.*]] = xor i1 true, true
 ; CHECK-NEXT:    ret i1 [[RES]]
 ;
 entry:
   %gep.1 = getelementptr inbounds i64, ptr %a, i64 9223372036854775804
   %gep.2 = getelementptr inbounds ptr, ptr %a, i64 1152921504606846976
   %gep.3 = getelementptr inbounds i64, ptr %gep.2, i64 1152921504606846976

 
 define i1 @gep_decomp_large_index_63_bits_overflow_struct(ptr %a) {
 ; CHECK-LABEL: @gep_decomp_large_index_63_bits_overflow_struct(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[GEP_1:%.*]] = getelementptr inbounds i64, ptr [[A:%.*]], i64 9223372036854775804
 ; CHECK-NEXT:    [[GEP_2:%.*]] = getelementptr inbounds [[STRUCT:%.*]], ptr [[A]], i64 8937376004704240, i32 1, i32 1
 ; CHECK-NEXT:    [[NE:%.*]] = icmp ne ptr [[GEP_1]], [[GEP_2]]
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[NE]])
-; CHECK-NEXT:    [[CMP_ULE:%.*]] = icmp ule ptr [[GEP_1]], [[GEP_2]]
 ; CHECK-NEXT:    [[CMP_UGE:%.*]] = icmp uge ptr [[GEP_1]], [[GEP_2]]
 ; CHECK-NEXT:    [[RES:%.*]] = xor i1 false, false
 ; CHECK-NEXT:    ret i1 [[RES]]
 ;
 entry:
   %gep.1 = getelementptr inbounds i64, ptr %a, i64 9223372036854775804
   %gep.2 = getelementptr inbounds %struct, ptr %a, i64 8937376004704240, i32 1, i32 1
   %ne = icmp ne ptr %gep.1, %gep.2
   call void @llvm.assume(i1 %ne)
   %cmp.ule = icmp ule ptr %gep.1, %gep.2
   %cmp.uge = icmp uge ptr %gep.1, %gep.2
   %res = xor i1 %cmp.ule, %cmp.ule
   ret i1 %res
 }
 
 declare void @llvm.assume(i1)

llvm/test/Transforms/ConstraintElimination/large-system-growth.ll

 ; CHECK-NEXT:    br i1 [[TMP30]], label [[EARLY_EXIT]], label [[BB32:%.*]]
 ; CHECK:       bb32:
 ; CHECK-NEXT:    [[TMP33:%.*]] = icmp ult ptr [[TMP29]], [[Z]]
 ; CHECK-NEXT:    br i1 [[TMP33]], label [[BB35:%.*]], label [[EARLY_EXIT]]
 ; CHECK:       bb35:
 ; CHECK-NEXT:    [[TMP36:%.*]] = icmp ult ptr [[Y]], [[Z]]
 ; CHECK-NEXT:    br i1 [[TMP36]], label [[EARLY_EXIT]], label [[BB38:%.*]]
 ; CHECK:       bb38:
-; CHECK-NEXT:    [[TMP41:%.*]] = icmp ult ptr [[Y]], [[Z]]
 ; CHECK-NEXT:    br i1 false, label [[EARLY_EXIT]], label [[BB43:%.*]]
 ; CHECK:       bb43:
 ; CHECK-NEXT:    [[TMP47:%.*]] = getelementptr inbounds i8, ptr [[W:%.*]], i64 [[X]]
 ; CHECK-NEXT:    [[TMP48:%.*]] = icmp ult ptr [[TMP47]], [[Y]]
 ; CHECK-NEXT:    br i1 [[TMP48]], label [[EARLY_EXIT]], label [[BB50:%.*]]
 ; CHECK:       bb50:
 ; CHECK-NEXT:    [[TMP52:%.*]] = getelementptr inbounds i8, ptr [[W]], i64 [[X]]
 ; CHECK-NEXT:    [[TMP53:%.*]] = icmp ult ptr [[TMP52]], [[Y]]
 ; CHECK-NEXT:    br i1 [[TMP53]], label [[EARLY_EXIT]], label [[BB55:%.*]]
 ; CHECK:       bb55:
 ; CHECK-NEXT:    [[TMP57:%.*]] = icmp ult ptr [[W]], [[Y]]
 ; CHECK-NEXT:    br i1 [[TMP57]], label [[BB59:%.*]], label [[EARLY_EXIT]]
 ; CHECK:       bb59:
-; CHECK-NEXT:    [[TMP60:%.*]] = icmp ult ptr [[W]], [[Y]]
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    ret void
 ;
   %tmp22 = getelementptr inbounds i8, ptr %y, i64 %x
   %tmp26 = icmp ult ptr %tmp22, %z
   br i1 %tmp26, label %bb28, label %early.exit
 
 early.exit:

llvm/test/Transforms/ConstraintElimination/loops-header-tested-base.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -passes=constraint-elimination -S %s | FileCheck %s
 
 declare void @use(i1)
 
 define void @loop_phi_pos_start_value(i32 %y, i1 %c, i32 %n) {
 ; CHECK-LABEL: @loop_phi_pos_start_value(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br i1 [[C:%.*]], label [[LOOP_HEADER:%.*]], label [[EXIT:%.*]]
 ; CHECK:       loop.header:
 ; CHECK-NEXT:    [[X:%.*]] = phi i32 [ 10, [[ENTRY:%.*]] ], [ [[X_NEXT:%.*]], [[LOOP_LATCH:%.*]] ]
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp slt i32 [[X]], [[N:%.*]]
 ; CHECK-NEXT:    br i1 [[C_1]], label [[LOOP_LATCH]], label [[EXIT]]
 ; CHECK:       loop.latch:
-; CHECK-NEXT:    [[F_1:%.*]] = icmp sle i32 [[X]], [[N]]
 ; CHECK-NEXT:    call void @use(i1 true)
-; CHECK-NEXT:    [[T_1:%.*]] = icmp sgt i32 [[X]], [[N]]
 ; CHECK-NEXT:    call void @use(i1 false)
 ; CHECK-NEXT:    [[T_2:%.*]] = icmp sge i32 [[X]], 10
 ; CHECK-NEXT:    call void @use(i1 [[T_2]])
 ; CHECK-NEXT:    [[C_2:%.*]] = icmp sle i32 [[X]], 9
 ; CHECK-NEXT:    call void @use(i1 [[C_2]])
 ; CHECK-NEXT:    [[C_3:%.*]] = icmp sgt i32 [[X]], 9
 ; CHECK-NEXT:    call void @use(i1 [[C_3]])
 ; CHECK-NEXT:    [[C_4:%.*]] = icmp sge i32 [[X]], 0

 ; CHECK-LABEL: @loop_phi_neg_start_value(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br i1 [[C:%.*]], label [[LOOP_HEADER:%.*]], label [[EXIT:%.*]]
 ; CHECK:       loop.header:
 ; CHECK-NEXT:    [[X:%.*]] = phi i32 [ -10, [[ENTRY:%.*]] ], [ [[X_NEXT:%.*]], [[LOOP_LATCH:%.*]] ]
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp slt i32 [[X]], [[N:%.*]]
 ; CHECK-NEXT:    br i1 [[C_1]], label [[LOOP_LATCH]], label [[EXIT]]
 ; CHECK:       loop.latch:
-; CHECK-NEXT:    [[F_1:%.*]] = icmp sle i32 [[X]], [[N]]
 ; CHECK-NEXT:    call void @use(i1 true)
-; CHECK-NEXT:    [[T_1:%.*]] = icmp sgt i32 [[X]], [[N]]
 ; CHECK-NEXT:    call void @use(i1 false)
 ; CHECK-NEXT:    [[T_2:%.*]] = icmp sge i32 [[X]], -10
 ; CHECK-NEXT:    call void @use(i1 [[T_2]])
 ; CHECK-NEXT:    [[C_2:%.*]] = icmp sle i32 [[X]], 9
 ; CHECK-NEXT:    call void @use(i1 [[C_2]])
 ; CHECK-NEXT:    [[C_3:%.*]] = icmp sgt i32 [[X]], 9
 ; CHECK-NEXT:    call void @use(i1 [[C_3]])
 ; CHECK-NEXT:    [[C_4:%.*]] = icmp sge i32 [[X]], 0

 ; CHECK-NEXT:    [[X:%.*]] = phi i32 [ [[N:%.*]], [[ENTRY:%.*]] ], [ [[X_NEXT:%.*]], [[LOOP_LATCH:%.*]] ]
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp sge i32 [[X]], 0
 ; CHECK-NEXT:    br i1 [[C_1]], label [[LOOP_LATCH]], label [[EXIT]]
 ; CHECK:       loop.latch:
 ; CHECK-NEXT:    [[F_1:%.*]] = icmp sle i32 [[X]], [[N]]
 ; CHECK-NEXT:    call void @use(i1 [[F_1]])
 ; CHECK-NEXT:    [[T_1:%.*]] = icmp sgt i32 [[X]], [[N]]
 ; CHECK-NEXT:    call void @use(i1 [[T_1]])
-; CHECK-NEXT:    [[T_2:%.*]] = icmp sge i32 [[X]], 0
 ; CHECK-NEXT:    call void @use(i1 true)
-; CHECK-NEXT:    [[T_3:%.*]] = icmp sge i32 [[X]], -1
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    [[C_2:%.*]] = icmp sle i32 [[X]], 9
 ; CHECK-NEXT:    call void @use(i1 [[C_2]])
 ; CHECK-NEXT:    [[C_3:%.*]] = icmp sgt i32 [[X]], 9
 ; CHECK-NEXT:    call void @use(i1 [[C_3]])
 ; CHECK-NEXT:    [[C_4:%.*]] = icmp sge i32 [[X]], 1
 ; CHECK-NEXT:    call void @use(i1 [[C_4]])
 ; CHECK-NEXT:    [[C_5:%.*]] = icmp sge i32 [[X]], 2

 ; CHECK-LABEL: @loop_latch_may_not_executed(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br i1 [[C:%.*]], label [[LOOP_HEADER:%.*]], label [[EXIT:%.*]]
 ; CHECK:       loop.header:
 ; CHECK-NEXT:    [[X:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[X_NEXT:%.*]], [[LOOP_LATCH:%.*]] ]
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ugt i32 [[X]], [[N:%.*]]
 ; CHECK-NEXT:    br i1 [[C_1]], label [[LOOP_LATCH]], label [[EXIT]]
 ; CHECK:       loop.latch:
-; CHECK-NEXT:    [[F_1:%.*]] = icmp ule i32 [[X]], [[N]]
 ; CHECK-NEXT:    call void @use(i1 false)
-; CHECK-NEXT:    [[T_1:%.*]] = icmp ugt i32 [[X]], [[N]]
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    [[C_2:%.*]] = icmp ule i32 [[X]], 9
 ; CHECK-NEXT:    call void @use(i1 [[C_2]])
 ; CHECK-NEXT:    [[C_3:%.*]] = icmp ugt i32 [[X]], 9
 ; CHECK-NEXT:    call void @use(i1 [[C_3]])
 ; CHECK-NEXT:    [[X_NEXT]] = add i32 [[X]], 1
 ; CHECK-NEXT:    br label [[LOOP_HEADER]]
 ; CHECK:       exit:

 ; CHECK-LABEL: @loop_latch_not_executed_constant_bound(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br i1 [[C:%.*]], label [[LOOP_HEADER:%.*]], label [[EXIT:%.*]]
 ; CHECK:       loop.header:
 ; CHECK-NEXT:    [[X:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[X_NEXT:%.*]], [[LOOP_LATCH:%.*]] ]
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ugt i32 [[X]], 10
 ; CHECK-NEXT:    br i1 [[C_1]], label [[LOOP_LATCH]], label [[EXIT]]
 ; CHECK:       loop.latch:
-; CHECK-NEXT:    [[T_1:%.*]] = icmp ule i32 [[X]], 10
 ; CHECK-NEXT:    call void @use(i1 false)
-; CHECK-NEXT:    [[F_1:%.*]] = icmp ugt i32 [[X]], 10
 ; CHECK-NEXT:    call void @use(i1 true)
-; CHECK-NEXT:    [[C_2:%.*]] = icmp ule i32 [[X]], 9
 ; CHECK-NEXT:    call void @use(i1 false)
-; CHECK-NEXT:    [[C_3:%.*]] = icmp ugt i32 [[X]], 9
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    [[X_NEXT]] = add i32 [[X]], 1
 ; CHECK-NEXT:    br label [[LOOP_HEADER]]
 ; CHECK:       exit:
 ; CHECK-NEXT:    [[C_4:%.*]] = icmp ugt i32 [[Y:%.*]], 10
 ; CHECK-NEXT:    call void @use(i1 [[C_4]])
 ; CHECK-NEXT:    ret void
 ;

 ; CHECK-NEXT:    call void @use(i1 [[T_3]])
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ult i32 [[IV]], [[N]]
 ; CHECK-NEXT:    call void @use(i1 [[C_1]])
 ; CHECK-NEXT:    [[C_2:%.*]] = icmp ugt i32 [[IV]], 1
 ; CHECK-NEXT:    call void @use(i1 [[C_2]])
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp ult i32 [[IV]], [[N]]
 ; CHECK-NEXT:    br i1 [[CMP]], label [[LOOP_LATCH]], label [[EXIT:%.*]]
 ; CHECK:       loop.latch:
-; CHECK-NEXT:    [[T_4:%.*]] = icmp ule i32 [[IV]], [[N]]
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    [[C_3:%.*]] = icmp ult i32 [[IV]], 2
 ; CHECK-NEXT:    call void @use(i1 [[C_3]])
 ; CHECK-NEXT:    [[C_4:%.*]] = icmp ugt i32 [[IV]], 1
 ; CHECK-NEXT:    call void @use(i1 [[C_4]])
 ; CHECK-NEXT:    [[IV_NEXT]] = add nuw nsw i32 [[IV]], 1
 ; CHECK-NEXT:    br label [[LOOP_HEADER]]
 ; CHECK:       exit:

 ; CHECK-NEXT:    call void @use(i1 [[T_3]])
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ult i32 [[IV]], 2
 ; CHECK-NEXT:    call void @use(i1 [[C_1]])
 ; CHECK-NEXT:    [[C_2:%.*]] = icmp ugt i32 [[IV]], 1
 ; CHECK-NEXT:    call void @use(i1 [[C_2]])
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp ult i32 [[IV]], 2
 ; CHECK-NEXT:    br i1 [[CMP]], label [[LOOP_LATCH]], label [[EXIT:%.*]]
 ; CHECK:       loop.latch:
-; CHECK-NEXT:    [[T_4:%.*]] = icmp ule i32 [[IV]], 2
 ; CHECK-NEXT:    call void @use(i1 true)
-; CHECK-NEXT:    [[C_3:%.*]] = icmp ult i32 [[IV]], 2
 ; CHECK-NEXT:    call void @use(i1 true)
-; CHECK-NEXT:    [[C_4:%.*]] = icmp ugt i32 [[IV]], 1
 ; CHECK-NEXT:    call void @use(i1 false)
 ; CHECK-NEXT:    [[IV_NEXT]] = add nuw nsw i32 [[IV]], 1
 ; CHECK-NEXT:    br label [[LOOP_HEADER]]
 ; CHECK:       exit:
 ; CHECK-NEXT:    ret void
 ;
 entry:
   br label %loop.header

llvm/test/Transforms/ConstraintElimination/loops-header-tested-pointer-cmps.ll

 ; CHECK-NEXT:    [[IDXPROM:%.*]] = zext i32 [[ADD]] to i64
 ; CHECK-NEXT:    [[SRC_IDX:%.*]] = getelementptr inbounds i32, ptr [[SRC]], i64 [[IDXPROM]]
 ; CHECK-NEXT:    [[CMP_SRC_IDX_UPPER:%.*]] = icmp ult ptr [[SRC_IDX]], [[SRC_UPPER]]
 ; CHECK-NEXT:    call void @use(i1 [[CMP_SRC_IDX_UPPER]])
 ; CHECK-NEXT:    br i1 [[CMP_SRC_IDX_UPPER]], label [[LOOP_LATCH:%.*]], label [[EXIT]]
 ; CHECK:       loop.latch:
 ; CHECK-NEXT:    [[DST_UPPER:%.*]] = getelementptr inbounds i32, ptr [[DST:%.*]], i64 [[TMP0]]
 ; CHECK-NEXT:    [[DST_IDX:%.*]] = getelementptr inbounds i32, ptr [[DST]], i64 [[IDXPROM]]
-; CHECK-NEXT:    [[CMP_DST_IDX_UPPER:%.*]] = icmp ult ptr [[DST_IDX]], [[DST_UPPER]]
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    br i1 true, label [[LOOP_LATCH_2]], label [[EXIT]]
 ; CHECK:       loop.latch.2:
 ; CHECK-NEXT:    br label [[LOOP_HEADER]]
 ; CHECK:       exit:
 ; CHECK-NEXT:    ret void
 ;
 entry:

llvm/test/Transforms/ConstraintElimination/loops-header-tested-pointer-iv.ll

 ; CHECK-NEXT:    [[IV:%.*]] = phi ptr [ [[START:%.*]], [[ENTRY:%.*]] ], [ [[IV_NEXT:%.*]], [[LOOP_LATCH:%.*]] ]
 ; CHECK-NEXT:    [[C_2:%.*]] = icmp ule ptr [[IV]], [[END]]
 ; CHECK-NEXT:    call void @use(i1 [[C_2]])
 ; CHECK-NEXT:    [[T_2:%.*]] = icmp uge ptr [[IV]], [[START]]
 ; CHECK-NEXT:    call void @use(i1 [[T_2]])
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ule ptr [[IV]], [[END]]
 ; CHECK-NEXT:    br i1 [[C_1]], label [[LOOP_LATCH]], label [[EXIT]]
 ; CHECK:       loop.latch:
-; CHECK-NEXT:    [[T_1:%.*]] = icmp ult ptr [[IV]], [[UPPER]]
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    [[IV_NEXT]] = getelementptr inbounds i8, ptr [[IV]], i8 1
 ; CHECK-NEXT:    br label [[LOOP_HEADER]]
 ; CHECK:       exit:
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %end.lt.upper = icmp ult ptr %end, %upper

 ; CHECK-NEXT:    [[IV:%.*]] = phi ptr [ null, [[ENTRY:%.*]] ], [ [[IV_NEXT:%.*]], [[LOOP_LATCH:%.*]] ]
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ule ptr [[IV]], [[END]]
 ; CHECK-NEXT:    call void @use(i1 [[C_1]])
 ; CHECK-NEXT:    [[C_2:%.*]] = icmp uge ptr [[IV]], null
 ; CHECK-NEXT:    call void @use(i1 [[C_2]])
 ; CHECK-NEXT:    [[C_3:%.*]] = icmp ule ptr [[IV]], [[END]]
 ; CHECK-NEXT:    br i1 [[C_3]], label [[LOOP_LATCH]], label [[EXIT]]
 ; CHECK:       loop.latch:
-; CHECK-NEXT:    [[C_4:%.*]] = icmp ult ptr [[IV]], [[UPPER]]
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    [[IV_NEXT]] = getelementptr inbounds i8, ptr [[IV]], i8 1
 ; CHECK-NEXT:    br label [[LOOP_HEADER]]
 ; CHECK:       exit:
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %end.lt.upper = icmp ult ptr %end, %upper

llvm/test/Transforms/ConstraintElimination/loops.ll

 ; CHECK-LABEL: @loop_header_dom(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br i1 [[C:%.*]], label [[LOOP_HEADER:%.*]], label [[EXIT:%.*]]
 ; CHECK:       loop.header:
 ; CHECK-NEXT:    [[X:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[X_NEXT:%.*]], [[LOOP_LATCH:%.*]] ]
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ule i32 [[X]], 10
 ; CHECK-NEXT:    br i1 [[C_1]], label [[LOOP_LATCH]], label [[EXIT]]
 ; CHECK:       loop.latch:
-; CHECK-NEXT:    [[T_1:%.*]] = icmp ule i32 [[X]], 10
 ; CHECK-NEXT:    call void @use(i1 true)
-; CHECK-NEXT:    [[F_1:%.*]] = icmp ugt i32 [[X]], 10
 ; CHECK-NEXT:    call void @use(i1 false)
 ; CHECK-NEXT:    [[C_2:%.*]] = icmp ule i32 [[X]], 9
 ; CHECK-NEXT:    call void @use(i1 [[C_2]])
 ; CHECK-NEXT:    [[C_3:%.*]] = icmp ugt i32 [[X]], 9
 ; CHECK-NEXT:    call void @use(i1 [[C_3]])
 ; CHECK-NEXT:    [[X_NEXT]] = add i32 [[X]], 1
 ; CHECK-NEXT:    br label [[LOOP_HEADER]]
 ; CHECK:       exit:

 ; CHECK-LABEL: @loop_header_dom_successors_flipped(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br i1 [[C:%.*]], label [[LOOP_HEADER:%.*]], label [[EXIT:%.*]]
 ; CHECK:       loop.header:
 ; CHECK-NEXT:    [[X:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[X_NEXT:%.*]], [[LOOP_LATCH:%.*]] ]
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ule i32 [[X]], 10
 ; CHECK-NEXT:    br i1 [[C_1]], label [[EXIT]], label [[LOOP_LATCH]]
 ; CHECK:       loop.latch:
-; CHECK-NEXT:    [[F_1:%.*]] = icmp ule i32 [[X]], 10
 ; CHECK-NEXT:    call void @use(i1 false)
-; CHECK-NEXT:    [[T_1:%.*]] = icmp ugt i32 [[X]], 10
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    [[C_2:%.*]] = icmp ugt i32 [[X]], 11
 ; CHECK-NEXT:    call void @use(i1 [[C_2]])
 ; CHECK-NEXT:    [[C_3:%.*]] = icmp ule i32 [[X]], 11
 ; CHECK-NEXT:    call void @use(i1 [[C_3]])
 ; CHECK-NEXT:    [[X_NEXT]] = add i32 [[X]], 1
 ; CHECK-NEXT:    br label [[LOOP_HEADER]]
 ; CHECK:       exit:

 ; CHECK-NEXT:    br i1 [[C:%.*]], label [[LOOP_HEADER:%.*]], label [[EXIT:%.*]]
 ; CHECK:       loop.header:
 ; CHECK-NEXT:    [[X:%.*]] = phi i32 [ [[START:%.*]], [[ENTRY:%.*]] ], [ [[X_NEXT:%.*]], [[LOOP_LATCH:%.*]] ]
 ; CHECK-NEXT:    [[X_1:%.*]] = icmp ule i32 [[X]], 10
 ; CHECK-NEXT:    [[Y_1:%.*]] = icmp ugt i32 [[Y:%.*]], 99
 ; CHECK-NEXT:    [[OR:%.*]] = or i1 [[X_1]], [[Y_1]]
 ; CHECK-NEXT:    br i1 [[OR]], label [[EXIT]], label [[LOOP_LATCH]]
 ; CHECK:       loop.latch:
-; CHECK-NEXT:    [[T_1:%.*]] = icmp ugt i32 [[X]], 10
 ; CHECK-NEXT:    call void @use(i1 true)
-; CHECK-NEXT:    [[F_1:%.*]] = icmp ule i32 [[X]], 10
 ; CHECK-NEXT:    call void @use(i1 false)
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ugt i32 [[X]], 11
 ; CHECK-NEXT:    call void @use(i1 [[C_1]])
 ; CHECK-NEXT:    [[C_2:%.*]] = icmp ule i32 [[X]], 11
 ; CHECK-NEXT:    call void @use(i1 [[C_2]])
-; CHECK-NEXT:    [[T_2:%.*]] = icmp ule i32 [[Y]], 99
 ; CHECK-NEXT:    call void @use(i1 true)
-; CHECK-NEXT:    [[F_2:%.*]] = icmp ugt i32 [[Y]], 99
 ; CHECK-NEXT:    call void @use(i1 false)
 ; CHECK-NEXT:    [[C_3:%.*]] = icmp ule i32 [[Y]], 98
 ; CHECK-NEXT:    call void @use(i1 [[C_3]])
 ; CHECK-NEXT:    [[C_4:%.*]] = icmp ule i32 [[Y]], 98
 ; CHECK-NEXT:    call void @use(i1 [[C_4]])
 ; CHECK-NEXT:    [[X_NEXT]] = add i32 [[X]], 1
 ; CHECK-NEXT:    br label [[LOOP_HEADER]]
 ; CHECK:       exit:

 ; CHECK-NEXT:    ret void
 ; CHECK:       loop.header:
 ; CHECK-NEXT:    [[X:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[X_NEXT:%.*]], [[LOOP_LATCH:%.*]] ]
 ; CHECK-NEXT:    [[X_1:%.*]] = icmp ule i32 [[X]], 10
 ; CHECK-NEXT:    [[Y_1:%.*]] = icmp ugt i32 [[Y]], 99
 ; CHECK-NEXT:    [[AND:%.*]] = and i1 [[X_1]], [[Y_1]]
 ; CHECK-NEXT:    br i1 [[AND]], label [[LOOP_LATCH]], label [[EXIT_1:%.*]]
 ; CHECK:       loop.latch:
-; CHECK-NEXT:    [[T_1:%.*]] = icmp ule i32 [[X]], 10
 ; CHECK-NEXT:    call void @use(i1 true)
-; CHECK-NEXT:    [[F_1:%.*]] = icmp ugt i32 [[X]], 10
 ; CHECK-NEXT:    call void @use(i1 false)
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ule i32 [[X]], 9
 ; CHECK-NEXT:    call void @use(i1 [[C_1]])
 ; CHECK-NEXT:    [[C_2:%.*]] = icmp ugt i32 [[X]], 9
 ; CHECK-NEXT:    call void @use(i1 [[C_2]])
-; CHECK-NEXT:    [[T_2:%.*]] = icmp ugt i32 [[Y]], 99
 ; CHECK-NEXT:    call void @use(i1 true)
-; CHECK-NEXT:    [[F_2:%.*]] = icmp ule i32 [[Y]], 99
 ; CHECK-NEXT:    call void @use(i1 false)
 ; CHECK-NEXT:    [[C_3:%.*]] = icmp ugt i32 [[Y]], 100
 ; CHECK-NEXT:    call void @use(i1 [[C_3]])
 ; CHECK-NEXT:    [[C_4:%.*]] = icmp ugt i32 [[Y]], 100
 ; CHECK-NEXT:    call void @use(i1 [[C_4]])
 ; CHECK-NEXT:    [[X_NEXT]] = add i32 [[X]], 1
 ; CHECK-NEXT:    br label [[LOOP_HEADER]]
 ; CHECK:       exit.1:

 ; CHECK-NEXT:    call void @use(i1 [[C_6]])
 ; CHECK-NEXT:    [[C_7:%.*]] = icmp ugt i32 [[Y]], 100
 ; CHECK-NEXT:    call void @use(i1 [[C_7]])
 ; CHECK-NEXT:    [[C_8:%.*]] = icmp ugt i32 [[Y]], 100
 ; CHECK-NEXT:    call void @use(i1 [[C_8]])
 ; CHECK-NEXT:    [[X_NEXT]] = add i32 [[X]], 1
 ; CHECK-NEXT:    br label [[LOOP_HEADER]]
 ; CHECK:       exit.1:
-; CHECK-NEXT:    [[T_1:%.*]] = icmp ugt i32 [[Y]], 10
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    ret void
 ;
 entry:
   br i1 %c, label %loop.header, label %exit
 
 exit:
   %c.9 = icmp ugt i32 %y, 10

llvm/test/Transforms/ConstraintElimination/max-row-limit.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -passes=constraint-elimination -S %s | FileCheck --check-prefixes=COMMON,SIMP %s
 ; RUN: opt -passes=constraint-elimination -constraint-elimination-max-rows=4 -S %s | FileCheck --check-prefixes=COMMON,SIMP %s
 ; RUN: opt -passes=constraint-elimination -constraint-elimination-max-rows=3 -S %s | FileCheck --check-prefixes=COMMON,NOSIMP %s
 
 
 define i1 @test_max_row_limit(i32 %l0, i32 %l1, i32 %l2, i32 %l3, i32 %l4) {
-; COMMON-LABEL: @test_max_row_limit(
-; COMMON-NEXT:  bb0:
-; COMMON-NEXT:    [[C0:%.*]] = icmp uge i32 [[L0:%.*]], 100
-; COMMON-NEXT:    br i1 [[C0]], label [[BB1:%.*]], label [[EXIT:%.*]]
-; COMMON:       bb1:
-; COMMON-NEXT:    [[C1:%.*]] = icmp uge i32 [[L1:%.*]], 100
-; COMMON-NEXT:    br i1 [[C1]], label [[BB2:%.*]], label [[EXIT]]
-; COMMON:       bb2:
-; COMMON-NEXT:    [[C2:%.*]] = icmp uge i32 [[L2:%.*]], 100
-; COMMON-NEXT:    br i1 [[C2]], label [[BB3:%.*]], label [[EXIT]]
-; COMMON:       bb3:
-; COMMON-NEXT:    [[C3:%.*]] = icmp uge i32 [[L3:%.*]], 100
-; COMMON-NEXT:    br i1 [[C3]], label [[BB4:%.*]], label [[EXIT]]
-; COMMON:       bb4:
-; COMMON-NEXT:    [[C4:%.*]] = icmp uge i32 [[L4:%.*]], 100
-; COMMON-NEXT:    br i1 [[C4]], label [[BB5:%.*]], label [[EXIT]]
-; COMMON:       bb5:
-; COMMON-NEXT:    [[C5:%.*]] = icmp uge i32 [[L4]], 100
-; SIMP-NEXT:      ret i1 true
+; SIMP-LABEL: @test_max_row_limit(
+; SIMP-NEXT:  bb0:
+; SIMP-NEXT:    [[C0:%.*]] = icmp uge i32 [[L0:%.*]], 100
+; SIMP-NEXT:    br i1 [[C0]], label [[BB1:%.*]], label [[EXIT:%.*]]
+; SIMP:       bb1:
+; SIMP-NEXT:    [[C1:%.*]] = icmp uge i32 [[L1:%.*]], 100
+; SIMP-NEXT:    br i1 [[C1]], label [[BB2:%.*]], label [[EXIT]]
+; SIMP:       bb2:
+; SIMP-NEXT:    [[C2:%.*]] = icmp uge i32 [[L2:%.*]], 100
+; SIMP-NEXT:    br i1 [[C2]], label [[BB3:%.*]], label [[EXIT]]
+; SIMP:       bb3:
+; SIMP-NEXT:    [[C3:%.*]] = icmp uge i32 [[L3:%.*]], 100
+; SIMP-NEXT:    br i1 [[C3]], label [[BB4:%.*]], label [[EXIT]]
+; SIMP:       bb4:
+; SIMP-NEXT:    [[C4:%.*]] = icmp uge i32 [[L4:%.*]], 100
+; SIMP-NEXT:    br i1 [[C4]], label [[BB5:%.*]], label [[EXIT]]
+; SIMP:       bb5:
+; SIMP-NEXT:    ret i1 true
+; SIMP:       exit:
+; SIMP-NEXT:    ret i1 false
+;
+; NOSIMP-LABEL: @test_max_row_limit(
+; NOSIMP-NEXT:  bb0:
+; NOSIMP-NEXT:    [[C0:%.*]] = icmp uge i32 [[L0:%.*]], 100
+; NOSIMP-NEXT:    br i1 [[C0]], label [[BB1:%.*]], label [[EXIT:%.*]]
+; NOSIMP:       bb1:
+; NOSIMP-NEXT:    [[C1:%.*]] = icmp uge i32 [[L1:%.*]], 100
+; NOSIMP-NEXT:    br i1 [[C1]], label [[BB2:%.*]], label [[EXIT]]
+; NOSIMP:       bb2:
+; NOSIMP-NEXT:    [[C2:%.*]] = icmp uge i32 [[L2:%.*]], 100
+; NOSIMP-NEXT:    br i1 [[C2]], label [[BB3:%.*]], label [[EXIT]]
+; NOSIMP:       bb3:
+; NOSIMP-NEXT:    [[C3:%.*]] = icmp uge i32 [[L3:%.*]], 100
+; NOSIMP-NEXT:    br i1 [[C3]], label [[BB4:%.*]], label [[EXIT]]
+; NOSIMP:       bb4:
+; NOSIMP-NEXT:    [[C4:%.*]] = icmp uge i32 [[L4:%.*]], 100
+; NOSIMP-NEXT:    br i1 [[C4]], label [[BB5:%.*]], label [[EXIT]]
+; NOSIMP:       bb5:
+; NOSIMP-NEXT:    [[C5:%.*]] = icmp uge i32 [[L4]], 100
 ; NOSIMP-NEXT:    ret i1 [[C5]]
-; COMMON:       exit:
-; COMMON-NEXT:    ret i1 false
+; NOSIMP:       exit:
+; NOSIMP-NEXT:    ret i1 false
 ;
 bb0:
   %c0 = icmp uge i32 %l0, 100
   br i1 %c0, label %bb1, label %exit
 
 bb1:
   %c1 = icmp uge i32 %l1, 100
   br i1 %c1, label %bb2, label %exit

 
 bb5:
   %c5 = icmp uge i32 %l4, 100
   ret i1 %c5
 
 exit:
   ret i1 false
 }
+;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line:
+; COMMON: {{.*}}

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 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

 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]], 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

 
 define i1 @umin_ult(i32 %x, i32 %y) {
 ; 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 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

 define i1 @umin_ule(i32 %x, i32 %y) {
 ; 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]], 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

 
 define i1 @smax_sgt(i32 %x, i32 %y) {
 ; 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 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

 define i1 @smax_sge(i32 %x, i32 %y) {
 ; 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]], 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

 
 define i1 @smin_slt(i32 %x, i32 %y) {
 ; 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 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

 define i1 @smin_sle(i32 %x, i32 %y) {
 ; 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]], 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

 define i1 @umax_uge_ugt_with_add_nuw(i32 %x, i32 %y) {
 ; 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 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

 
 define i1 @umax_ugt_ugt_both(i32 %x, i32 %y, i32 %z) {
 ; 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 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
 
 if:
   %cmp2 = icmp ugt i32 %z, %x
   %cmp3 = icmp ugt i32 %z, %y
   %and = xor i1 %cmp2, %cmp3
   ret i1 %and
 
 end:
   ret i1 false
 }
 
 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 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

llvm/test/Transforms/ConstraintElimination/mixed-signed-unsigned-predicates.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -passes=constraint-elimination -S %s | FileCheck %s
 
 define i1 @test_add_nuw(i8 %start, i8 %low, i8 %high) {
 ; CHECK-LABEL: @test_add_nuw(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[ADD_PTR_I:%.*]] = add nuw i8 [[START:%.*]], 3
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp uge i8 [[ADD_PTR_I]], [[HIGH:%.*]]
 ; CHECK-NEXT:    br i1 [[C_1]], label [[IF_THEN:%.*]], label [[IF_ELSE:%.*]]
 ; CHECK:       if.then:
 ; CHECK-NEXT:    [[UC_3:%.*]] = icmp ugt i8 [[START]], [[HIGH]]
 ; CHECK-NEXT:    [[START_1_1:%.*]] = add nuw i8 [[START]], 1
 ; CHECK-NEXT:    [[UC_4:%.*]] = icmp uge i8 [[START_1_1]], [[HIGH]]
 ; CHECK-NEXT:    [[RES_11:%.*]] = xor i1 [[UC_3]], [[UC_4]]
 ; CHECK-NEXT:    [[START_3_1:%.*]] = add nuw i8 [[START]], 3
-; CHECK-NEXT:    [[T_0:%.*]] = icmp uge i8 [[START_3_1]], [[HIGH]]
 ; CHECK-NEXT:    [[RES_12:%.*]] = xor i1 [[RES_11]], true
 ; CHECK-NEXT:    [[UC_5:%.*]] = icmp ugt i8 [[START_3_1]], [[HIGH]]
 ; CHECK-NEXT:    [[RES_13:%.*]] = xor i1 [[RES_12]], [[UC_5]]
 ; CHECK-NEXT:    [[SC_8:%.*]] = icmp sge i8 [[START_1_1]], [[HIGH]]
 ; CHECK-NEXT:    [[RES_14:%.*]] = xor i1 [[RES_13]], [[SC_8]]
 ; CHECK-NEXT:    [[SC_9:%.*]] = icmp sge i8 [[START_3_1]], [[HIGH]]
 ; CHECK-NEXT:    [[RES_15:%.*]] = xor i1 [[RES_14]], [[SC_9]]
 ; CHECK-NEXT:    ret i1 [[RES_15]]
 ; CHECK:       if.else:
-; CHECK-NEXT:    [[F_0:%.*]] = icmp ugt i8 [[START]], [[HIGH]]
 ; CHECK-NEXT:    [[START_1:%.*]] = add nuw i8 [[START]], 1
-; CHECK-NEXT:    [[F_1:%.*]] = icmp uge i8 [[START_1]], [[HIGH]]
 ; CHECK-NEXT:    [[RES_0:%.*]] = xor i1 false, false
 ; CHECK-NEXT:    [[SC_1:%.*]] = icmp sgt i8 [[START]], [[HIGH]]
 ; CHECK-NEXT:    [[RES_1:%.*]] = xor i1 [[RES_0]], [[SC_1]]
 ; CHECK-NEXT:    [[SC_2:%.*]] = icmp sge i8 [[START_1]], [[HIGH]]
 ; CHECK-NEXT:    [[RES_2:%.*]] = xor i1 [[RES_1]], [[SC_2]]
 ; CHECK-NEXT:    [[START_2:%.*]] = add nuw i8 [[START]], 2
-; CHECK-NEXT:    [[F_2:%.*]] = icmp uge i8 [[START_2]], [[HIGH]]
 ; CHECK-NEXT:    [[RES_3:%.*]] = xor i1 [[RES_2]], false
 ; CHECK-NEXT:    [[SC_3:%.*]] = icmp sge i8 [[START_2]], [[HIGH]]
 ; CHECK-NEXT:    [[RES_4:%.*]] = xor i1 [[RES_3]], [[SC_3]]
 ; CHECK-NEXT:    [[SC_4:%.*]] = icmp sle i8 [[START_2]], [[START_1]]
 ; CHECK-NEXT:    [[RES_5:%.*]] = xor i1 [[RES_4]], [[SC_4]]
 ; CHECK-NEXT:    [[START_3:%.*]] = add nuw i8 [[START]], 3
-; CHECK-NEXT:    [[F_3:%.*]] = icmp uge i8 [[START_3]], [[HIGH]]
 ; CHECK-NEXT:    [[RES_6:%.*]] = xor i1 [[RES_5]], false
 ; CHECK-NEXT:    [[SC_5:%.*]] = icmp sge i8 [[START_3]], [[START_1]]
 ; CHECK-NEXT:    [[RES_7:%.*]] = xor i1 [[RES_6]], [[SC_5]]
 ; CHECK-NEXT:    [[START_4:%.*]] = add nuw i8 [[START]], 4
 ; CHECK-NEXT:    [[UC_2:%.*]] = icmp uge i8 [[START_4]], [[HIGH]]
 ; CHECK-NEXT:    [[RES_8:%.*]] = xor i1 [[RES_7]], [[UC_2]]
 ; CHECK-NEXT:    [[SC_6:%.*]] = icmp sge i8 [[START_4]], [[START_1]]
 ; CHECK-NEXT:    [[RES_9:%.*]] = xor i1 [[RES_8]], [[SC_6]]

 ; CHECK-NEXT:    [[SC_9:%.*]] = icmp sge i8 [[START_3_1]], [[HIGH]]
 ; CHECK-NEXT:    [[RES_15:%.*]] = xor i1 [[RES_14]], [[SC_9]]
 ; CHECK-NEXT:    ret i1 [[RES_15]]
 ; CHECK:       if.else:
 ; CHECK-NEXT:    [[F_0:%.*]] = icmp ugt i8 [[START]], [[HIGH]]
 ; CHECK-NEXT:    [[START_1:%.*]] = add nuw i8 [[START]], 1
 ; CHECK-NEXT:    [[F_1:%.*]] = icmp uge i8 [[START_1]], [[HIGH]]
 ; CHECK-NEXT:    [[RES_0:%.*]] = xor i1 [[F_0]], [[F_1]]
-; CHECK-NEXT:    [[SC_1:%.*]] = icmp sgt i8 [[START]], [[HIGH]]
 ; CHECK-NEXT:    [[RES_1:%.*]] = xor i1 [[RES_0]], false
 ; CHECK-NEXT:    [[SC_2:%.*]] = icmp sge i8 [[START_1]], [[HIGH]]
 ; CHECK-NEXT:    [[RES_2:%.*]] = xor i1 [[RES_1]], [[SC_2]]
 ; CHECK-NEXT:    [[START_2:%.*]] = add nuw i8 [[START]], 2
 ; CHECK-NEXT:    [[F_2:%.*]] = icmp uge i8 [[START_2]], [[HIGH]]
 ; CHECK-NEXT:    [[RES_3:%.*]] = xor i1 [[RES_2]], [[F_2]]
 ; CHECK-NEXT:    [[SC_3:%.*]] = icmp sge i8 [[START_2]], [[HIGH]]
 ; CHECK-NEXT:    [[RES_4:%.*]] = xor i1 [[RES_3]], [[SC_3]]

 
 define i1 @test_sub_nuw(i8 %start, i8 %low, i8 %high) {
 ; CHECK-LABEL: @test_sub_nuw(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[ADD_PTR_I:%.*]] = sub nuw i8 [[START:%.*]], 3
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp uge i8 [[ADD_PTR_I]], [[HIGH:%.*]]
 ; CHECK-NEXT:    br i1 [[C_1]], label [[IF_THEN:%.*]], label [[IF_ELSE:%.*]]
 ; CHECK:       if.then:
-; CHECK-NEXT:    [[UC_3:%.*]] = icmp ugt i8 [[START]], [[HIGH]]
 ; CHECK-NEXT:    [[START_1_1:%.*]] = sub nuw i8 [[START]], 1
-; CHECK-NEXT:    [[UC_4:%.*]] = icmp uge i8 [[START_1_1]], [[HIGH]]
 ; CHECK-NEXT:    [[RES_11:%.*]] = xor i1 true, true
 ; CHECK-NEXT:    [[START_3_1:%.*]] = add nuw i8 [[START]], 3
-; CHECK-NEXT:    [[T_0:%.*]] = icmp uge i8 [[START_3_1]], [[HIGH]]
 ; CHECK-NEXT:    [[RES_12:%.*]] = xor i1 [[RES_11]], true
-; CHECK-NEXT:    [[UC_5:%.*]] = icmp ugt i8 [[START_3_1]], [[HIGH]]
 ; CHECK-NEXT:    [[RES_13:%.*]] = xor i1 [[RES_12]], true
 ; CHECK-NEXT:    [[SC_8:%.*]] = icmp sge i8 [[START_1_1]], [[HIGH]]
 ; CHECK-NEXT:    [[RES_14:%.*]] = xor i1 [[RES_13]], [[SC_8]]
 ; CHECK-NEXT:    [[SC_9:%.*]] = icmp sge i8 [[START_3_1]], [[HIGH]]
 ; CHECK-NEXT:    [[RES_15:%.*]] = xor i1 [[RES_14]], [[SC_9]]
 ; CHECK-NEXT:    ret i1 [[RES_15]]
 ; CHECK:       if.else:
 ; CHECK-NEXT:    [[F_0:%.*]] = icmp ugt i8 [[START]], [[HIGH]]
 ; CHECK-NEXT:    [[START_1:%.*]] = sub nuw i8 [[START]], 1
 ; CHECK-NEXT:    [[F_1:%.*]] = icmp uge i8 [[START_1]], [[HIGH]]
 ; CHECK-NEXT:    [[RES_0:%.*]] = xor i1 [[F_0]], [[F_1]]
 ; CHECK-NEXT:    [[SC_1:%.*]] = icmp sgt i8 [[START]], [[HIGH]]
 ; CHECK-NEXT:    [[RES_1:%.*]] = xor i1 [[RES_0]], [[SC_1]]
 ; CHECK-NEXT:    [[SC_2:%.*]] = icmp sge i8 [[START_1]], [[HIGH]]
 ; CHECK-NEXT:    [[RES_2:%.*]] = xor i1 [[RES_1]], [[SC_2]]
 ; CHECK-NEXT:    [[START_2:%.*]] = sub nuw i8 [[START]], 2
 ; CHECK-NEXT:    [[F_2:%.*]] = icmp uge i8 [[START_2]], [[HIGH]]
 ; CHECK-NEXT:    [[RES_3:%.*]] = xor i1 [[RES_2]], [[F_2]]
 ; CHECK-NEXT:    [[SC_3:%.*]] = icmp sge i8 [[START_2]], [[HIGH]]
 ; CHECK-NEXT:    [[RES_4:%.*]] = xor i1 [[RES_3]], [[SC_3]]
 ; CHECK-NEXT:    [[SC_4:%.*]] = icmp sle i8 [[START_2]], [[START_1]]
 ; CHECK-NEXT:    [[RES_5:%.*]] = xor i1 [[RES_4]], [[SC_4]]
 ; CHECK-NEXT:    [[START_3:%.*]] = sub nuw i8 [[START]], 3
-; CHECK-NEXT:    [[F_3:%.*]] = icmp uge i8 [[START_3]], [[HIGH]]
 ; CHECK-NEXT:    [[RES_6:%.*]] = xor i1 [[RES_5]], false
 ; CHECK-NEXT:    [[SC_5:%.*]] = icmp sge i8 [[START_3]], [[START_1]]
 ; CHECK-NEXT:    [[RES_7:%.*]] = xor i1 [[RES_6]], [[SC_5]]
 ; CHECK-NEXT:    [[START_4:%.*]] = sub nuw i8 [[START]], 4
-; CHECK-NEXT:    [[UC_2:%.*]] = icmp uge i8 [[START_4]], [[HIGH]]
 ; CHECK-NEXT:    [[RES_8:%.*]] = xor i1 [[RES_7]], false
 ; CHECK-NEXT:    [[SC_6:%.*]] = icmp sge i8 [[START_4]], [[START_1]]
 ; CHECK-NEXT:    [[RES_9:%.*]] = xor i1 [[RES_8]], [[SC_6]]
 ; CHECK-NEXT:    [[SC_7:%.*]] = icmp sge i8 [[START_4]], [[HIGH]]
 ; CHECK-NEXT:    [[RES_10:%.*]] = xor i1 [[RES_9]], [[SC_7]]
 ; CHECK-NEXT:    ret i1 [[RES_10]]
 ;
 entry:

 ; CHECK-LABEL: @test_and_ule_sge(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ule i32 [[X:%.*]], [[Y:%.*]]
 ; CHECK-NEXT:    [[C_2:%.*]] = icmp sle i32 [[Y]], [[Z:%.*]]
 ; CHECK-NEXT:    [[AND:%.*]] = and i1 [[C_1]], [[C_2]]
 ; CHECK-NEXT:    br i1 [[AND]], label [[THEN:%.*]], label [[ELSE:%.*]]
 ; CHECK:       then:
 ; CHECK-NEXT:    [[UC_1:%.*]] = icmp ule i32 [[X]], [[Z]]
-; CHECK-NEXT:    [[UC_2:%.*]] = icmp ule i32 [[X]], [[Y]]
 ; CHECK-NEXT:    [[RES_1:%.*]] = xor i1 [[UC_1]], true
 ; CHECK-NEXT:    [[UC_3:%.*]] = icmp ule i32 [[Y]], [[Z]]
 ; CHECK-NEXT:    [[RES_2:%.*]] = xor i1 [[RES_1]], [[UC_3]]
 ; CHECK-NEXT:    [[UC_4:%.*]] = icmp ule i32 [[X]], [[A:%.*]]
 ; CHECK-NEXT:    [[RES_4:%.*]] = xor i1 [[RES_2]], [[UC_4]]
 ; CHECK-NEXT:    [[SC_1:%.*]] = icmp sle i32 [[X]], [[Z]]
 ; CHECK-NEXT:    [[RES_5:%.*]] = xor i1 [[RES_4]], [[SC_1]]
 ; CHECK-NEXT:    [[SC_2:%.*]] = icmp sle i32 [[X]], [[Y]]
 ; CHECK-NEXT:    [[RES_6:%.*]] = xor i1 [[RES_5]], [[SC_2]]
-; CHECK-NEXT:    [[SC_3:%.*]] = icmp sle i32 [[Y]], [[Z]]
 ; CHECK-NEXT:    [[RES_7:%.*]] = xor i1 [[RES_6]], true
 ; CHECK-NEXT:    [[SC_4:%.*]] = icmp sle i32 [[X]], [[A]]
 ; CHECK-NEXT:    [[RES_8:%.*]] = xor i1 [[RES_7]], [[SC_4]]
 ; CHECK-NEXT:    ret i1 [[RES_8]]
 ; CHECK:       else:
 ; CHECK-NEXT:    [[UC_5:%.*]] = icmp ule i32 [[X]], [[Z]]
 ; CHECK-NEXT:    [[UC_6:%.*]] = icmp ule i32 [[X]], [[A]]
 ; CHECK-NEXT:    [[RES_9:%.*]] = xor i1 [[UC_5]], [[UC_6]]

llvm/test/Transforms/ConstraintElimination/mul-nsw.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -passes=constraint-elimination -S %s | FileCheck %s
 
 declare void @use(i1)
 declare void @llvm.assume(i1)
 
 define void @slt_mul_nsw_3_known_positive_1(i8 %start, i8 %high) {
 ; CHECK-LABEL: @slt_mul_nsw_3_known_positive_1(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[MUL_3:%.*]] = mul nsw i8 [[START:%.*]], 3
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp slt i8 [[MUL_3]], [[HIGH:%.*]]
 ; CHECK-NEXT:    [[C_2:%.*]] = icmp sgt i8 [[START]], 0
 ; CHECK-NEXT:    [[AND:%.*]] = and i1 [[C_1]], [[C_2]]
 ; CHECK-NEXT:    br i1 [[AND]], label [[THEN:%.*]], label [[ELSE:%.*]]
 ; CHECK:       then:
-; CHECK-NEXT:    [[T_0:%.*]] = icmp slt i8 [[START]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    [[START_1:%.*]] = mul nsw i8 [[START]], 1
-; CHECK-NEXT:    [[T_1:%.*]] = icmp slt i8 [[START_1]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    [[START_2:%.*]] = mul nsw i8 [[START]], 2
-; CHECK-NEXT:    [[T_2:%.*]] = icmp slt i8 [[START_2]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    [[START_3:%.*]] = mul nsw i8 [[START]], 3
-; CHECK-NEXT:    [[T_3:%.*]] = icmp slt i8 [[START_3]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    [[START_4:%.*]] = mul nsw i8 [[START]], 4
 ; CHECK-NEXT:    [[C_3:%.*]] = icmp slt i8 [[START_4]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 [[C_3]])
 ; CHECK-NEXT:    ret void
 ; CHECK:       else:
 ; CHECK-NEXT:    ret void
 ;

 ; CHECK-LABEL: @slt_mul_nsw_neg_3_known_negative_1(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[MUL_3:%.*]] = mul nsw i8 [[START:%.*]], -3
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp slt i8 [[MUL_3]], [[HIGH:%.*]]
 ; CHECK-NEXT:    [[C_2:%.*]] = icmp slt i8 [[START]], 0
 ; CHECK-NEXT:    [[AND:%.*]] = and i1 [[C_1]], [[C_2]]
 ; CHECK-NEXT:    br i1 [[AND]], label [[THEN:%.*]], label [[ELSE:%.*]]
 ; CHECK:       then:
-; CHECK-NEXT:    [[T_0:%.*]] = icmp slt i8 [[START]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    [[START_1:%.*]] = mul nsw i8 [[START]], -1
-; CHECK-NEXT:    [[T_1:%.*]] = icmp slt i8 [[START_1]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    [[START_2:%.*]] = mul nsw i8 [[START]], -2
-; CHECK-NEXT:    [[T_2:%.*]] = icmp slt i8 [[START_2]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    [[START_3:%.*]] = mul nsw i8 [[START]], -3
-; CHECK-NEXT:    [[T_3:%.*]] = icmp slt i8 [[START_3]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    [[START_4:%.*]] = mul nsw i8 [[START]], -4
 ; CHECK-NEXT:    [[C_3:%.*]] = icmp slt i8 [[START_4]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 [[C_3]])
 ; CHECK-NEXT:    ret void
 ; CHECK:       else:
 ; CHECK-NEXT:    ret void
 ;

 ; CHECK-NEXT:    call void @use(i1 [[C_3]])
 ; CHECK-NEXT:    [[START_1:%.*]] = mul nsw i8 [[START]], 1
 ; CHECK-NEXT:    [[C_4:%.*]] = icmp slt i8 [[START_1]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 [[C_4]])
 ; CHECK-NEXT:    [[START_2:%.*]] = mul nsw i8 [[START]], 2
 ; CHECK-NEXT:    [[C_5:%.*]] = icmp slt i8 [[START_2]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 [[C_5]])
 ; CHECK-NEXT:    [[START_3:%.*]] = mul nsw i8 [[START]], 3
-; CHECK-NEXT:    [[T_0:%.*]] = icmp slt i8 [[START_3]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    [[START_4:%.*]] = mul nsw i8 [[START]], 4
-; CHECK-NEXT:    [[T_1:%.*]] = icmp slt i8 [[START_4]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    ret void
 ; CHECK:       else:
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %mul.3  = mul nsw i8 %start, 3
   %c.1 = icmp slt i8 %mul.3, %high

 ; CHECK-NEXT:    call void @use(i1 [[C_3]])
 ; CHECK-NEXT:    [[START_1:%.*]] = mul nsw i8 [[START]], -1
 ; CHECK-NEXT:    [[C_4:%.*]] = icmp slt i8 [[START_1]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 [[C_4]])
 ; CHECK-NEXT:    [[START_2:%.*]] = mul nsw i8 [[START]], -2
 ; CHECK-NEXT:    [[C_5:%.*]] = icmp slt i8 [[START_2]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 [[C_5]])
 ; CHECK-NEXT:    [[START_3:%.*]] = mul nsw i8 [[START]], -3
-; CHECK-NEXT:    [[T_0:%.*]] = icmp slt i8 [[START_3]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    [[START_4:%.*]] = mul nsw i8 [[START]], -4
-; CHECK-NEXT:    [[T_1:%.*]] = icmp slt i8 [[START_4]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    ret void
 ; CHECK:       else:
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %mul.3  = mul nsw i8 %start, -3
   %c.1 = icmp slt i8 %mul.3, %high

 ; CHECK-LABEL: @slt_mul_nsw_3_known_nonnegative_1(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[MUL_3:%.*]] = mul nsw i8 [[START:%.*]], 3
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp slt i8 [[MUL_3]], [[HIGH:%.*]]
 ; CHECK-NEXT:    [[C_2:%.*]] = icmp sge i8 [[START]], 0
 ; CHECK-NEXT:    [[AND:%.*]] = and i1 [[C_1]], [[C_2]]
 ; CHECK-NEXT:    br i1 [[AND]], label [[THEN:%.*]], label [[ELSE:%.*]]
 ; CHECK:       then:
-; CHECK-NEXT:    [[T_0:%.*]] = icmp slt i8 [[START]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    [[START_1:%.*]] = mul nsw i8 [[START]], 1
-; CHECK-NEXT:    [[T_1:%.*]] = icmp slt i8 [[START_1]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    [[START_2:%.*]] = mul nsw i8 [[START]], 2
-; CHECK-NEXT:    [[T_2:%.*]] = icmp slt i8 [[START_2]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    [[START_3:%.*]] = mul nsw i8 [[START]], 3
-; CHECK-NEXT:    [[T_3:%.*]] = icmp slt i8 [[START_3]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    [[START_4:%.*]] = mul nsw i8 [[START]], 4
 ; CHECK-NEXT:    [[C_3:%.*]] = icmp slt i8 [[START_4]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 [[C_3]])
 ; CHECK-NEXT:    ret void
 ; CHECK:       else:
 ; CHECK-NEXT:    ret void
 ;

llvm/test/Transforms/ConstraintElimination/mul.ll

 define i1 @test_mul_const_nuw_unsigned_3(i8 %start, i8 %high) {
 ; CHECK-LABEL: @test_mul_const_nuw_unsigned_3(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[START_MUL_4:%.*]] = mul nuw i8 [[START:%.*]], 4
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ult i8 [[START_MUL_4]], [[HIGH:%.*]]
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C_1]])
 ; CHECK-NEXT:    [[START_MUL_2:%.*]] = mul nuw i8 [[START]], 2
 ; CHECK-NEXT:    [[START_ADD_1:%.*]] = add nuw i8 [[START]], [[START]]
-; CHECK-NEXT:    [[T:%.*]] = icmp ule i8 [[START_ADD_1]], [[START_MUL_2]]
 ; CHECK-NEXT:    ret i1 true
 ;
 entry:
   %start.mul.4 = mul nuw i8 %start, 4
   %c.1 = icmp ult i8 %start.mul.4, %high
   call void @llvm.assume(i1 %c.1)
 
   %start.mul.2 = mul nuw i8 %start, 2
   %start.add.1 = add nuw i8 %start, %start
   %t = icmp ule i8 %start.add.1, %start.mul.2
   ret i1 %t
 }
 
 
 define i1 @test_mul_const_nuw_unsigned_4(i8 %start, i8 %high) {
 ; CHECK-LABEL: @test_mul_const_nuw_unsigned_4(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[START_MUL_4:%.*]] = mul nuw i8 [[START:%.*]], 4
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ult i8 [[START_MUL_4]], [[HIGH:%.*]]
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C_1]])
 ; CHECK-NEXT:    [[START_MUL_2:%.*]] = mul nuw i8 [[START]], 2
 ; CHECK-NEXT:    [[START_ADD_1:%.*]] = add nuw i8 [[START]], [[START]]
-; CHECK-NEXT:    [[F:%.*]] = icmp ult i8 [[START_ADD_1]], [[START_MUL_2]]
 ; CHECK-NEXT:    ret i1 false
 ;
 entry:
   %start.mul.4 = mul nuw i8 %start, 4
   %c.1 = icmp ult i8 %start.mul.4, %high
   call void @llvm.assume(i1 %c.1)
 
   %start.mul.2 = mul nuw i8 %start, 2
   %start.add.1 = add nuw i8 %start, %start
   %f = icmp ult i8 %start.add.1, %start.mul.2
   ret i1 %f
 }
 
 
 define i1 @test_mul_const_nuw_unsigned_5(i8 %start, i8 %high) {
 ; CHECK-LABEL: @test_mul_const_nuw_unsigned_5(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[START_MUL_4:%.*]] = mul nuw i8 [[START:%.*]], 4
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ult i8 [[START_MUL_4]], [[HIGH:%.*]]
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C_1]])
 ; CHECK-NEXT:    [[START_ADD_1:%.*]] = add nuw i8 [[START]], [[START]]
 ; CHECK-NEXT:    [[START_ADD_2:%.*]] = add nuw i8 [[START_ADD_1]], [[START_ADD_1]]
-; CHECK-NEXT:    [[T_4:%.*]] = icmp ule i8 [[START_ADD_2]], [[START_MUL_4]]
 ; CHECK-NEXT:    ret i1 true
 ;
 entry:
   %start.mul.4 = mul nuw i8 %start, 4
   %c.1 = icmp ult i8 %start.mul.4, %high
   call void @llvm.assume(i1 %c.1)
 
   %start.add.1 = add nuw i8 %start, %start
   %start.add.2 = add nuw i8 %start.add.1, %start.add.1
   %t.4 = icmp ule i8 %start.add.2, %start.mul.4
   ret i1 %t.4
 }
 
 define i1 @test_mul_const_nuw_unsigned_6(i8 %start, i8 %high) {
 ; CHECK-LABEL: @test_mul_const_nuw_unsigned_6(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[START_MUL_4:%.*]] = mul nuw i8 [[START:%.*]], 4
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ult i8 [[START_MUL_4]], [[HIGH:%.*]]
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C_1]])
 ; CHECK-NEXT:    [[START_ADD_1:%.*]] = add nuw i8 [[START]], [[START]]
 ; CHECK-NEXT:    [[START_ADD_2:%.*]] = add nuw i8 [[START_ADD_1]], [[START_ADD_1]]
-; CHECK-NEXT:    [[F_2:%.*]] = icmp ult i8 [[START_ADD_2]], [[START_MUL_4]]
 ; CHECK-NEXT:    ret i1 false
 ;
 entry:
   %start.mul.4 = mul nuw i8 %start, 4
   %c.1 = icmp ult i8 %start.mul.4, %high
   call void @llvm.assume(i1 %c.1)
 
   %start.add.1 = add nuw i8 %start, %start
   %start.add.2 = add nuw i8 %start.add.1, %start.add.1
   %f.2 = icmp ult i8 %start.add.2, %start.mul.4
   ret i1 %f.2
 }
 
 define i1 @test_mul_const_nuw_unsigned_7(i8 %start, i8 %high) {
 ; CHECK-LABEL: @test_mul_const_nuw_unsigned_7(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[START_MUL_4:%.*]] = mul nuw i8 [[START:%.*]], 4
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ult i8 [[START_MUL_4]], [[HIGH:%.*]]
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C_1]])
 ; CHECK-NEXT:    [[START_MUL_2:%.*]] = mul nuw i8 [[START]], 2
 ; CHECK-NEXT:    [[START_ADD_1:%.*]] = add nuw i8 [[START]], [[START]]
 ; CHECK-NEXT:    [[START_ADD_2:%.*]] = add nuw i8 [[START_ADD_1]], [[START_ADD_1]]
 ; CHECK-NEXT:    [[START_ADD_2_1:%.*]] = add nuw i8 [[START_ADD_2]], 1
-; CHECK-NEXT:    [[F_3:%.*]] = icmp ule i8 [[START_ADD_2_1]], [[START_MUL_4]]
 ; CHECK-NEXT:    ret i1 false
 ;
 entry:
   %start.mul.4 = mul nuw i8 %start, 4
   %c.1 = icmp ult i8 %start.mul.4, %high
   call void @llvm.assume(i1 %c.1)
 
   %start.mul.2 = mul nuw i8 %start, 2

 
 define i1 @test_mul_const_nuw_unsigned_10(i8 %start, i8 %high) {
 ; CHECK-LABEL: @test_mul_const_nuw_unsigned_10(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[START_MUL_5:%.*]] = mul nuw i8 [[START:%.*]], 5
 ; CHECK-NEXT:    [[C_0:%.*]] = icmp ult i8 [[START]], [[START_MUL_5]]
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C_0]])
 ; CHECK-NEXT:    [[START_MUL_3:%.*]] = mul nuw i8 [[START]], 3
-; CHECK-NEXT:    [[T_1:%.*]] = icmp ule i8 [[START_MUL_3]], [[START_MUL_5]]
 ; CHECK-NEXT:    ret i1 true
 ;
 entry:
   %start.mul.5 = mul nuw i8 %start, 5
   %c.0 = icmp ult i8 %start, %start.mul.5
   call void @llvm.assume(i1 %c.0)
 
   %start.mul.3 = mul nuw i8 %start, 3
   %t.1 = icmp ule i8 %start.mul.3, %start.mul.5
   ret i1 %t.1
 }
 
 define i1 @test_mul_const_nuw_unsigned_11(i8 %start, i8 %high) {
 ; CHECK-LABEL: @test_mul_const_nuw_unsigned_11(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[START_MUL_5:%.*]] = mul nuw i8 [[START:%.*]], 5
 ; CHECK-NEXT:    [[C_0:%.*]] = icmp ult i8 [[START]], [[START_MUL_5]]
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C_0]])
 ; CHECK-NEXT:    [[START_MUL_3:%.*]] = mul nuw i8 [[START]], 3
-; CHECK-NEXT:    [[C_1:%.*]] = icmp ule i8 [[START_MUL_5]], [[START_MUL_3]]
 ; CHECK-NEXT:    ret i1 false
 ;
 entry:
   %start.mul.5 = mul nuw i8 %start, 5
   %c.0 = icmp ult i8 %start, %start.mul.5
   call void @llvm.assume(i1 %c.0)
 
   %start.mul.3 = mul nuw i8 %start, 3
   %c.1 = icmp ule i8 %start.mul.5, %start.mul.3
   ret i1 %c.1
 }
 
 define i1 @test_mul_const_nuw_unsigned_12(i8 %start) {
 ; CHECK-LABEL: @test_mul_const_nuw_unsigned_12(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[START_MUL_3:%.*]] = mul nuw i8 [[START:%.*]], 3
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ult i8 [[START]], [[START_MUL_3]]
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C_1]])
 ; CHECK-NEXT:    [[START_MUL_5:%.*]] = mul nuw i8 [[START]], 5
-; CHECK-NEXT:    [[T_1:%.*]] = icmp ule i8 [[START_MUL_3]], [[START_MUL_5]]
 ; CHECK-NEXT:    ret i1 true
 ;
 entry:
   %start.mul.3 = mul nuw i8 %start, 3
   %c.1 = icmp ult i8 %start, %start.mul.3
   call void @llvm.assume(i1 %c.1)
 
   %start.mul.5 = mul nuw i8 %start, 5
   %t.1 = icmp ule i8 %start.mul.3, %start.mul.5
   ret i1 %t.1
 }
 
 define i1 @test_mul_const_nuw_unsigned_13(i8 %start) {
 ; CHECK-LABEL: @test_mul_const_nuw_unsigned_13(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[START_MUL_3:%.*]] = mul nuw i8 [[START:%.*]], 3
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ult i8 [[START]], [[START_MUL_3]]
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C_1]])
 ; CHECK-NEXT:    [[START_MUL_5:%.*]] = mul nuw i8 [[START]], 5
-; CHECK-NEXT:    [[F_1:%.*]] = icmp ule i8 [[START_MUL_5]], [[START_MUL_3]]
 ; CHECK-NEXT:    ret i1 false
 ;
 entry:
   %start.mul.3 = mul nuw i8 %start, 3
   %c.1 = icmp ult i8 %start, %start.mul.3
   call void @llvm.assume(i1 %c.1)
 
   %start.mul.5 = mul nuw i8 %start, 5

 ; CHECK-LABEL: @test_mul_add_const_nuw_unsigned_3(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[ADD:%.*]] = add nuw i8 [[START:%.*]], 3
 ; CHECK-NEXT:    [[START_MUL_4:%.*]] = mul nuw i8 [[ADD]], 4
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ult i8 [[START_MUL_4]], [[HIGH:%.*]]
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C_1]])
 ; CHECK-NEXT:    [[START_ADD_1:%.*]] = add nuw i8 [[START]], [[START]]
 ; CHECK-NEXT:    [[START_ADD_2:%.*]] = add nuw i8 [[START_ADD_1]], [[START_ADD_1]]
-; CHECK-NEXT:    [[T_3:%.*]] = icmp ule i8 [[START_ADD_2]], [[START_MUL_4]]
 ; CHECK-NEXT:    ret i1 true
 ;
 entry:
   %add = add nuw i8 %start, 3
   %start.mul.4 = mul nuw i8 %add, 4
   %c.1 = icmp ult i8 %start.mul.4, %high
   call void @llvm.assume(i1 %c.1)
 
   %start.add.1 = add nuw i8 %start, %start
   %start.add.2 = add nuw i8 %start.add.1, %start.add.1
   %t.3 = icmp ule i8 %start.add.2, %start.mul.4
   ret i1 %t.3
 }
 
 define i1 @test_mul_add_const_nuw_unsigned_4(i8 %start, i8 %high) {
 ; CHECK-LABEL: @test_mul_add_const_nuw_unsigned_4(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[ADD:%.*]] = add nuw i8 [[START:%.*]], 3
 ; CHECK-NEXT:    [[START_MUL_4:%.*]] = mul nuw i8 [[ADD]], 4
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ult i8 [[START_MUL_4]], [[HIGH:%.*]]
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C_1]])
 ; CHECK-NEXT:    [[START_MUL_2:%.*]] = mul nuw i8 [[START]], 2
 ; CHECK-NEXT:    [[START_ADD_1:%.*]] = add nuw i8 [[START]], [[START]]
 ; CHECK-NEXT:    [[START_ADD_2:%.*]] = add nuw i8 [[START_ADD_1]], [[START_ADD_1]]
-; CHECK-NEXT:    [[T_4:%.*]] = icmp ult i8 [[START_ADD_2]], [[START_MUL_4]]
 ; CHECK-NEXT:    ret i1 true
 ;
 entry:
   %add = add nuw i8 %start, 3
   %start.mul.4 = mul nuw i8 %add, 4
   %c.1 = icmp ult i8 %start.mul.4, %high
   call void @llvm.assume(i1 %c.1)
 

 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[ADD:%.*]] = add nuw i8 [[START:%.*]], 3
 ; CHECK-NEXT:    [[START_MUL_4:%.*]] = mul nuw i8 [[ADD]], 4
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ult i8 [[START_MUL_4]], [[HIGH:%.*]]
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C_1]])
 ; CHECK-NEXT:    [[START_ADD_1:%.*]] = add nuw i8 [[START]], [[START]]
 ; CHECK-NEXT:    [[START_ADD_2:%.*]] = add nuw i8 [[START_ADD_1]], [[START_ADD_1]]
 ; CHECK-NEXT:    [[START_ADD_2_12:%.*]] = add nuw i8 [[START_ADD_2]], 12
-; CHECK-NEXT:    [[T_5:%.*]] = icmp ule i8 [[START_ADD_2_12]], [[START_MUL_4]]
 ; CHECK-NEXT:    ret i1 true
 ;
 entry:
   %add = add nuw i8 %start, 3
   %start.mul.4 = mul nuw i8 %add, 4
   %c.1 = icmp ult i8 %start.mul.4, %high
   call void @llvm.assume(i1 %c.1)
 

 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[ADD:%.*]] = add nuw i8 [[START:%.*]], 3
 ; CHECK-NEXT:    [[START_MUL_4:%.*]] = mul nuw i8 [[ADD]], 4
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ult i8 [[START_MUL_4]], [[HIGH:%.*]]
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C_1]])
 ; CHECK-NEXT:    [[START_ADD_1:%.*]] = add nuw i8 [[START]], [[START]]
 ; CHECK-NEXT:    [[START_ADD_2:%.*]] = add nuw i8 [[START_ADD_1]], [[START_ADD_1]]
 ; CHECK-NEXT:    [[START_ADD_2_13:%.*]] = add nuw i8 [[START_ADD_2]], 13
-; CHECK-NEXT:    [[F_1:%.*]] = icmp ule i8 [[START_ADD_2_13]], [[START_MUL_4]]
 ; CHECK-NEXT:    ret i1 false
 ;
 entry:
   %add = add nuw i8 %start, 3
   %start.mul.4 = mul nuw i8 %add, 4
   %c.1 = icmp ult i8 %start.mul.4, %high
   call void @llvm.assume(i1 %c.1)
 

llvm/test/Transforms/ConstraintElimination/ne.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --check-attributes
 ; RUN: opt -passes=constraint-elimination -S %s | FileCheck %s
 
 declare void @llvm.assume(i1)
 
 define i1 @test_eq_ne_0(i8 %a, i8 %b) {
 ; CHECK-LABEL: @test_eq_ne_0(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i8 [[A:%.*]], 0
 ; CHECK-NEXT:    br i1 [[CMP]], label [[THEN:%.*]], label [[ELSE:%.*]]
 ; CHECK:       then:
-; CHECK-NEXT:    [[F_1:%.*]] = icmp ne i8 [[A]], 0
-; CHECK-NEXT:    [[C_1:%.*]] = icmp ne i8 [[A]], 1
 ; CHECK-NEXT:    [[C_2:%.*]] = icmp ne i8 [[A]], [[B:%.*]]
 ; CHECK-NEXT:    [[RES_1:%.*]] = xor i1 false, true
 ; CHECK-NEXT:    [[RES_2:%.*]] = xor i1 [[RES_1]], [[C_2]]
 ; CHECK-NEXT:    ret i1 [[RES_2]]
 ; CHECK:       else:
-; CHECK-NEXT:    [[T_1:%.*]] = icmp ne i8 [[A]], 0
 ; CHECK-NEXT:    [[C_3:%.*]] = icmp ne i8 [[A]], 1
 ; CHECK-NEXT:    [[C_4:%.*]] = icmp ne i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[RES_3:%.*]] = xor i1 true, [[C_3]]
 ; CHECK-NEXT:    [[RES_4:%.*]] = xor i1 [[RES_3]], [[C_4]]
 ; CHECK-NEXT:    ret i1 [[RES_4]]
 ;
 entry:
   %cmp = icmp eq i8 %a, 0

 }
 
 define i1 @test_ne_eq_0(i8 %a, i8 %b) {
 ; CHECK-LABEL: @test_ne_eq_0(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp ne i8 [[A:%.*]], 0
 ; CHECK-NEXT:    br i1 [[CMP]], label [[THEN:%.*]], label [[ELSE:%.*]]
 ; CHECK:       then:
-; CHECK-NEXT:    [[T_1:%.*]] = icmp ne i8 [[A]], 0
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ne i8 [[A]], 1
 ; CHECK-NEXT:    [[RES_1:%.*]] = xor i1 true, [[C_1]]
 ; CHECK-NEXT:    [[C_2:%.*]] = icmp ne i8 [[A]], [[B:%.*]]
 ; CHECK-NEXT:    [[RES_2:%.*]] = xor i1 [[RES_1]], [[C_2]]
 ; CHECK-NEXT:    [[C_3:%.*]] = icmp eq i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[RES_3:%.*]] = xor i1 [[RES_2]], [[C_3]]
-; CHECK-NEXT:    [[C_4:%.*]] = icmp eq i8 [[A]], 0
 ; CHECK-NEXT:    [[RES_4:%.*]] = xor i1 [[RES_3]], false
-; CHECK-NEXT:    [[T_2:%.*]] = icmp ugt i8 [[A]], 0
 ; CHECK-NEXT:    [[RES_5:%.*]] = xor i1 [[RES_4]], true
-; CHECK-NEXT:    [[T_3:%.*]] = icmp uge i8 [[A]], 1
 ; CHECK-NEXT:    [[RES_6:%.*]] = xor i1 [[RES_5]], true
 ; CHECK-NEXT:    [[C_5:%.*]] = icmp ugt i8 [[A]], 1
 ; CHECK-NEXT:    [[RES_7:%.*]] = xor i1 [[RES_6]], [[C_5]]
 ; CHECK-NEXT:    [[C_6:%.*]] = icmp sgt i8 [[A]], 0
 ; CHECK-NEXT:    [[RES_8:%.*]] = xor i1 [[RES_7]], [[C_6]]
 ; CHECK-NEXT:    ret i1 [[RES_8]]
 ; CHECK:       else:
-; CHECK-NEXT:    [[F_1:%.*]] = icmp ne i8 [[A]], 0
-; CHECK-NEXT:    [[C_7:%.*]] = icmp ne i8 [[A]], 1
 ; CHECK-NEXT:    [[RES_9:%.*]] = xor i1 false, true
 ; CHECK-NEXT:    [[C_8:%.*]] = icmp ne i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[RES_10:%.*]] = xor i1 [[RES_9]], [[C_8]]
 ; CHECK-NEXT:    [[C_9:%.*]] = icmp eq i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[RES_11:%.*]] = xor i1 [[RES_10]], [[C_9]]
-; CHECK-NEXT:    [[C_10:%.*]] = icmp eq i8 [[A]], 0
 ; CHECK-NEXT:    [[RES_12:%.*]] = xor i1 [[RES_11]], true
-; CHECK-NEXT:    [[F_2:%.*]] = icmp ugt i8 [[A]], 0
 ; CHECK-NEXT:    [[RES_13:%.*]] = xor i1 [[RES_12]], false
-; CHECK-NEXT:    [[F_3:%.*]] = icmp uge i8 [[A]], 1
 ; CHECK-NEXT:    [[RES_14:%.*]] = xor i1 [[RES_13]], false
-; CHECK-NEXT:    [[C_11:%.*]] = icmp ugt i8 [[A]], 1
 ; CHECK-NEXT:    [[RES_15:%.*]] = xor i1 [[RES_14]], false
 ; CHECK-NEXT:    [[C_12:%.*]] = icmp sgt i8 [[A]], 0
 ; CHECK-NEXT:    [[RES_16:%.*]] = xor i1 [[RES_15]], [[C_12]]
 ; CHECK-NEXT:    ret i1 [[RES_16]]
 ;
 entry:
   %cmp = icmp ne i8 %a, 0
   br i1 %cmp, label %then, label %else

 }
 
 define i1 @test_eq_ne_1(i8 %a, i8 %b) {
 ; CHECK-LABEL: @test_eq_ne_1(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i8 [[A:%.*]], 1
 ; CHECK-NEXT:    br i1 [[CMP]], label [[THEN:%.*]], label [[ELSE:%.*]]
 ; CHECK:       then:
-; CHECK-NEXT:    [[F_1:%.*]] = icmp ne i8 [[A]], 0
-; CHECK-NEXT:    [[C_1:%.*]] = icmp ne i8 [[A]], 1
 ; CHECK-NEXT:    [[C_2:%.*]] = icmp ne i8 [[A]], [[B:%.*]]
 ; CHECK-NEXT:    [[RES_1:%.*]] = xor i1 true, false
 ; CHECK-NEXT:    [[RES_2:%.*]] = xor i1 [[RES_1]], [[C_2]]
 ; CHECK-NEXT:    ret i1 [[RES_2]]
 ; CHECK:       else:
 ; CHECK-NEXT:    [[T_1:%.*]] = icmp ne i8 [[A]], 0
 ; CHECK-NEXT:    [[C_3:%.*]] = icmp ne i8 [[A]], 1
 ; CHECK-NEXT:    [[C_4:%.*]] = icmp ne i8 [[A]], [[B]]

 ; CHECK-NEXT:    [[C_6:%.*]] = icmp uge i8 [[A]], 1
 ; CHECK-NEXT:    [[RES_6:%.*]] = xor i1 [[RES_5]], [[C_6]]
 ; CHECK-NEXT:    [[C_7:%.*]] = icmp ugt i8 [[A]], 1
 ; CHECK-NEXT:    [[RES_7:%.*]] = xor i1 [[RES_6]], [[C_5]]
 ; CHECK-NEXT:    [[C_8:%.*]] = icmp sgt i8 [[A]], 0
 ; CHECK-NEXT:    [[RES_8:%.*]] = xor i1 [[RES_7]], [[C_6]]
 ; CHECK-NEXT:    ret i1 [[RES_8]]
 ; CHECK:       else:
-; CHECK-NEXT:    [[T_2:%.*]] = icmp ne i8 [[A]], 0
-; CHECK-NEXT:    [[C_9:%.*]] = icmp ne i8 [[A]], 1
 ; CHECK-NEXT:    [[RES_9:%.*]] = xor i1 true, false
 ; CHECK-NEXT:    [[C_10:%.*]] = icmp ne i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[RES_10:%.*]] = xor i1 [[RES_9]], [[C_10]]
 ; CHECK-NEXT:    [[C_11:%.*]] = icmp eq i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[RES_11:%.*]] = xor i1 [[RES_10]], [[C_11]]
-; CHECK-NEXT:    [[F_1:%.*]] = icmp eq i8 [[A]], 0
 ; CHECK-NEXT:    [[RES_12:%.*]] = xor i1 [[RES_11]], false
-; CHECK-NEXT:    [[T_3:%.*]] = icmp ugt i8 [[A]], 0
 ; CHECK-NEXT:    [[RES_13:%.*]] = xor i1 [[RES_12]], true
-; CHECK-NEXT:    [[T_4:%.*]] = icmp uge i8 [[A]], 1
 ; CHECK-NEXT:    [[RES_14:%.*]] = xor i1 [[RES_13]], true
-; CHECK-NEXT:    [[F_2:%.*]] = icmp ugt i8 [[A]], 1
 ; CHECK-NEXT:    [[RES_15:%.*]] = xor i1 [[RES_14]], false
 ; CHECK-NEXT:    [[C_12:%.*]] = icmp sgt i8 [[A]], 0
 ; CHECK-NEXT:    [[RES_16:%.*]] = xor i1 [[RES_15]], [[C_12]]
 ; CHECK-NEXT:    ret i1 [[RES_16]]
 ;
 entry:
   %cmp = icmp ne i8 %a, 1
   br i1 %cmp, label %then, label %else
else:
   ret i1 %res.16
 }
 
 define i1 @assume_b_plus_1_ult_a(i64 %a, i64 %b) {
 ; CHECK-LABEL: @assume_b_plus_1_ult_a(
 ; CHECK-NEXT:    [[TMP1:%.*]] = add nuw i64 [[B:%.*]], 1
 ; CHECK-NEXT:    [[TMP2:%.*]] = icmp ult i64 [[TMP1]], [[A:%.*]]
 ; CHECK-NEXT:    tail call void @llvm.assume(i1 [[TMP2]])
-; CHECK-NEXT:    [[TMP3:%.*]] = icmp ne i64 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 true
 ;
   %1 = add nuw i64 %b, 1
   %2 = icmp ult i64 %1, %a
   tail call void @llvm.assume(i1 %2)
   %3 = icmp ne i64 %a, %b
   ret i1 %3
 }
 
 define i1 @assume_a_gt_b_and_b_ge_c(i64 %a, i64 %b, i64 %c) {
 ; CHECK-LABEL: @assume_a_gt_b_and_b_ge_c(
 ; CHECK-NEXT:    [[TMP1:%.*]] = icmp ugt i64 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    tail call void @llvm.assume(i1 [[TMP1]])
 ; CHECK-NEXT:    [[TMP2:%.*]] = icmp uge i64 [[B]], [[C:%.*]]
 ; CHECK-NEXT:    tail call void @llvm.assume(i1 [[TMP2]])
-; CHECK-NEXT:    [[TMP3:%.*]] = icmp ne i64 [[A]], [[C]]
 ; CHECK-NEXT:    ret i1 true
 ;
   %1 = icmp ugt i64 %a, %b
   tail call void @llvm.assume(i1 %1)
   %2 = icmp uge i64 %b, %c
   tail call void @llvm.assume(i1 %2)
   %3 = icmp ne i64 %a, %c
   ret i1 %3

llvm/test/Transforms/ConstraintElimination/or.ll

 ; CHECK-NEXT:    br i1 [[OR]], label [[BB1:%.*]], label [[EXIT:%.*]]
 ; CHECK:       bb1:
 ; CHECK-NEXT:    [[C_3:%.*]] = icmp ule i4 [[X]], [[Z]]
 ; CHECK-NEXT:    call void @use(i1 [[C_3]])
 ; CHECK-NEXT:    [[C_4:%.*]] = icmp ule i4 [[X]], [[A:%.*]]
 ; CHECK-NEXT:    call void @use(i1 [[C_4]])
 ; CHECK-NEXT:    ret void
 ; CHECK:       exit:
-; CHECK-NEXT:    [[F_1:%.*]] = icmp ule i4 [[X]], [[Z]]
 ; CHECK-NEXT:    call void @use(i1 false)
 ; CHECK-NEXT:    [[C_5:%.*]] = icmp ule i4 [[X]], [[A]]
 ; CHECK-NEXT:    call void @use(i1 [[C_5]])
-; CHECK-NEXT:    [[T_1:%.*]] = icmp ugt i4 [[Y]], [[Z]]
 ; CHECK-NEXT:    call void @use(i1 true)
-; CHECK-NEXT:    [[T_2:%.*]] = icmp ugt i4 [[X]], [[Y]]
 ; CHECK-NEXT:    call void @use(i1 true)
-; CHECK-NEXT:    [[T_3:%.*]] = icmp ugt i4 [[X]], [[Z]]
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %c.1 = icmp ule i4 %x, %y
   %c.2 = icmp ule i4 %y, %z
   %or = or i1 %c.1, %c.2
   br i1 %or, label %bb1, label %exit

 ; CHECK-NEXT:    br i1 [[OR]], label [[BB1:%.*]], label [[EXIT:%.*]]
 ; CHECK:       bb1:
 ; CHECK-NEXT:    [[C_3:%.*]] = icmp ule i4 [[X]], [[Z]]
 ; CHECK-NEXT:    call void @use(i1 [[C_3]])
 ; CHECK-NEXT:    [[C_4:%.*]] = icmp ule i4 [[X]], [[A:%.*]]
 ; CHECK-NEXT:    call void @use(i1 [[C_4]])
 ; CHECK-NEXT:    ret void
 ; CHECK:       exit:
-; CHECK-NEXT:    [[F_1:%.*]] = icmp ule i4 [[X]], [[Z]]
 ; CHECK-NEXT:    call void @use(i1 false)
 ; CHECK-NEXT:    [[C_5:%.*]] = icmp ule i4 [[X]], [[A]]
 ; CHECK-NEXT:    call void @use(i1 [[C_5]])
-; CHECK-NEXT:    [[T_1:%.*]] = icmp ugt i4 [[Y]], [[Z]]
 ; CHECK-NEXT:    call void @use(i1 true)
-; CHECK-NEXT:    [[T_2:%.*]] = icmp ugt i4 [[X]], [[Y]]
 ; CHECK-NEXT:    call void @use(i1 true)
-; CHECK-NEXT:    [[T_3:%.*]] = icmp ugt i4 [[X]], [[Z]]
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %c.1 = icmp ule i4 %x, %y
   %c.2 = icmp ule i4 %y, %z
   %or = select i1 %c.1, i1 true, i1 %c.2
   br i1 %or, label %bb1, label %exit

 ; CHECK:       bb1:
 ; CHECK-NEXT:    [[C_5:%.*]] = icmp ule i4 [[X]], [[Z]]
 ; CHECK-NEXT:    [[C_6:%.*]] = icmp ule i4 [[X]], [[A]]
 ; CHECK-NEXT:    [[RES_1:%.*]] = xor i1 [[C_5]], [[C_6]]
 ; CHECK-NEXT:    [[C_7:%.*]] = icmp ule i4 2, [[X]]
 ; CHECK-NEXT:    [[RES_2:%.*]] = xor i1 [[RES_1]], [[C_7]]
 ; CHECK-NEXT:    ret i1 [[RES_2]]
 ; CHECK:       exit:
-; CHECK-NEXT:    [[F_1:%.*]] = icmp ule i4 [[X]], [[Z]]
-; CHECK-NEXT:    [[F_2:%.*]] = icmp ule i4 2, [[X]]
 ; CHECK-NEXT:    [[RES_3:%.*]] = xor i1 false, false
-; CHECK-NEXT:    [[T_1:%.*]] = icmp ugt i4 [[Y]], [[Z]]
 ; CHECK-NEXT:    [[RES_4:%.*]] = xor i1 [[RES_3]], true
-; CHECK-NEXT:    [[T_2:%.*]] = icmp ugt i4 [[X]], [[Y]]
 ; CHECK-NEXT:    [[RES_5:%.*]] = xor i1 [[RES_4]], true
-; CHECK-NEXT:    [[T_3:%.*]] = icmp ugt i4 [[X]], [[Z]]
 ; CHECK-NEXT:    [[RES_6:%.*]] = xor i1 [[RES_5]], true
-; CHECK-NEXT:    [[T_4:%.*]] = icmp ugt i4 2, [[A]]
 ; CHECK-NEXT:    [[RES_7:%.*]] = xor i1 [[RES_6]], true
 ; CHECK-NEXT:    [[C_8:%.*]] = icmp ule i4 [[X]], [[A]]
 ; CHECK-NEXT:    [[RES_8:%.*]] = xor i1 [[RES_7]], [[C_8]]
 ; CHECK-NEXT:    [[C_9:%.*]] = icmp ule i4 [[X]], [[B:%.*]]
 ; CHECK-NEXT:    [[RES_9:%.*]] = xor i1 [[RES_8]], [[C_9]]
 ; CHECK-NEXT:    ret i1 [[RES_9]]
 ;
 entry:

 ; CHECK:       bb1:
 ; CHECK-NEXT:    [[C_5:%.*]] = icmp ule i4 [[X]], [[Z]]
 ; CHECK-NEXT:    [[C_6:%.*]] = icmp ule i4 [[X]], [[A]]
 ; CHECK-NEXT:    [[RES_1:%.*]] = xor i1 [[C_5]], [[C_6]]
 ; CHECK-NEXT:    [[C_7:%.*]] = icmp ule i4 2, [[X]]
 ; CHECK-NEXT:    [[RES_2:%.*]] = xor i1 [[RES_1]], [[C_7]]
 ; CHECK-NEXT:    ret i1 [[RES_2]]
 ; CHECK:       exit:
-; CHECK-NEXT:    [[F_1:%.*]] = icmp ule i4 [[X]], [[Z]]
-; CHECK-NEXT:    [[F_2:%.*]] = icmp ule i4 2, [[X]]
 ; CHECK-NEXT:    [[RES_3:%.*]] = xor i1 false, false
-; CHECK-NEXT:    [[T_1:%.*]] = icmp ugt i4 [[Y]], [[Z]]
 ; CHECK-NEXT:    [[RES_4:%.*]] = xor i1 [[RES_3]], true
-; CHECK-NEXT:    [[T_2:%.*]] = icmp ugt i4 [[X]], [[Y]]
 ; CHECK-NEXT:    [[RES_5:%.*]] = xor i1 [[RES_4]], true
-; CHECK-NEXT:    [[T_3:%.*]] = icmp ugt i4 [[X]], [[Z]]
 ; CHECK-NEXT:    [[RES_6:%.*]] = xor i1 [[RES_5]], true
-; CHECK-NEXT:    [[T_4:%.*]] = icmp ugt i4 2, [[A]]
 ; CHECK-NEXT:    [[RES_7:%.*]] = xor i1 [[RES_6]], true
 ; CHECK-NEXT:    [[C_8:%.*]] = icmp ule i4 [[X]], [[A]]
 ; CHECK-NEXT:    [[RES_8:%.*]] = xor i1 [[RES_7]], [[C_8]]
 ; CHECK-NEXT:    [[C_9:%.*]] = icmp ule i4 [[X]], [[B:%.*]]
 ; CHECK-NEXT:    [[RES_9:%.*]] = xor i1 [[RES_8]], [[C_9]]
 ; CHECK-NEXT:    ret i1 [[RES_9]]
 ;
 entry:

 ; CHECK:       bb1:
 ; CHECK-NEXT:    [[C_5:%.*]] = icmp ule i4 [[X]], [[Z]]
 ; CHECK-NEXT:    [[C_6:%.*]] = icmp ule i4 [[X]], [[A:%.*]]
 ; CHECK-NEXT:    [[RES_1:%.*]] = xor i1 [[C_5]], [[C_6]]
 ; CHECK-NEXT:    [[C_7:%.*]] = icmp ule i4 2, [[X]]
 ; CHECK-NEXT:    [[RES_2:%.*]] = xor i1 [[RES_1]], [[C_7]]
 ; CHECK-NEXT:    ret i1 [[RES_2]]
 ; CHECK:       exit:
-; CHECK-NEXT:    [[F_1:%.*]] = icmp ule i4 [[X]], [[Z]]
-; CHECK-NEXT:    [[T_1:%.*]] = icmp ugt i4 [[Y]], [[Z]]
 ; CHECK-NEXT:    [[RES_3:%.*]] = xor i1 false, true
-; CHECK-NEXT:    [[T_2:%.*]] = icmp ugt i4 [[X]], [[Y]]
 ; CHECK-NEXT:    [[RES_4:%.*]] = xor i1 [[RES_3]], true
-; CHECK-NEXT:    [[T_3:%.*]] = icmp ugt i4 [[X]], [[Z]]
 ; CHECK-NEXT:    [[RES_5:%.*]] = xor i1 [[RES_4]], true
 ; CHECK-NEXT:    [[C_8:%.*]] = icmp ule i4 [[X]], [[A]]
 ; CHECK-NEXT:    [[RES_6:%.*]] = xor i1 [[RES_5]], [[C_8]]
 ; CHECK-NEXT:    ret i1 [[RES_6]]
 ;
 entry:
   %c.1 = icmp ule i4 %x, %y
   %c.2 = icmp ule i4 %y, %z

 ; CHECK:       bb1:
 ; CHECK-NEXT:    [[C_5:%.*]] = icmp ule i4 [[X]], [[Z]]
 ; CHECK-NEXT:    [[C_6:%.*]] = icmp ule i4 [[X]], [[A]]
 ; CHECK-NEXT:    [[RES_1:%.*]] = xor i1 [[C_5]], [[C_6]]
 ; CHECK-NEXT:    [[C_7:%.*]] = icmp ule i4 2, [[X]]
 ; CHECK-NEXT:    [[RES_2:%.*]] = xor i1 [[RES_1]], [[C_7]]
 ; CHECK-NEXT:    ret i1 [[RES_2]]
 ; CHECK:       exit:
-; CHECK-NEXT:    [[F_1:%.*]] = icmp ule i4 [[X]], [[Z]]
-; CHECK-NEXT:    [[T_1:%.*]] = icmp ugt i4 [[Y]], [[Z]]
 ; CHECK-NEXT:    [[RES_3:%.*]] = xor i1 false, true
-; CHECK-NEXT:    [[T_2:%.*]] = icmp ugt i4 [[X]], [[Y]]
 ; CHECK-NEXT:    [[RES_4:%.*]] = xor i1 [[RES_3]], true
-; CHECK-NEXT:    [[T_3:%.*]] = icmp ugt i4 [[X]], [[Z]]
 ; CHECK-NEXT:    [[RES_5:%.*]] = xor i1 [[RES_4]], true
 ; CHECK-NEXT:    [[C_8:%.*]] = icmp ule i4 [[X]], [[A]]
 ; CHECK-NEXT:    [[RES_6:%.*]] = xor i1 [[RES_5]], [[C_8]]
 ; CHECK-NEXT:    [[C_9:%.*]] = icmp ule i4 [[X]], [[B:%.*]]
 ; CHECK-NEXT:    [[RES_7:%.*]] = xor i1 [[RES_6]], [[C_9]]
 ; CHECK-NEXT:    [[C_10:%.*]] = icmp ule i4 2, [[X]]
 ; CHECK-NEXT:    [[RES_8:%.*]] = xor i1 [[RES_7]], [[C_10]]
 ; CHECK-NEXT:    [[C_11:%.*]] = icmp ugt i4 2, [[A]]

 ; CHECK-NEXT:    [[I_1:%.*]] = or i8 [[START]], 1
 ; CHECK-NEXT:    [[F_1:%.*]] = icmp ult i8 [[I_1]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 [[F_1]])
 ; CHECK-NEXT:    [[I_2:%.*]] = or i8 [[START]], 2
 ; CHECK-NEXT:    [[F_2:%.*]] = icmp ult i8 [[I_2]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 [[F_2]])
 ; CHECK-NEXT:    ret void
 ; CHECK:       end:
-; CHECK-NEXT:    [[T_0:%.*]] = icmp ult i8 [[START]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    [[START_1:%.*]] = or i8 [[START]], 1
-; CHECK-NEXT:    [[T_1:%.*]] = icmp ult i8 [[START_1]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    [[START_2:%.*]] = or i8 [[START]], 2
-; CHECK-NEXT:    [[T_2:%.*]] = icmp ult i8 [[START_2]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    [[START_3:%.*]] = or i8 [[START]], 3
-; CHECK-NEXT:    [[T_3:%.*]] = icmp ult i8 [[START_3]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    [[START_4:%.*]] = or i8 [[START]], 4
 ; CHECK-NEXT:    [[C_4:%.*]] = icmp ult i8 [[START_4]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 [[C_4]])
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %start = shl nuw nsw i8 %init_val, 2

 ; CHECK-NEXT:    [[I_1:%.*]] = or i8 [[START]], 1
 ; CHECK-NEXT:    [[F_1:%.*]] = icmp ule i8 [[I_1]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 [[F_1]])
 ; CHECK-NEXT:    [[I_2:%.*]] = or i8 [[START]], 2
 ; CHECK-NEXT:    [[F_2:%.*]] = icmp ule i8 [[I_2]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 [[F_2]])
 ; CHECK-NEXT:    ret void
 ; CHECK:       end:
-; CHECK-NEXT:    [[T_0:%.*]] = icmp ule i8 [[START]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    [[START_1:%.*]] = or i8 [[START]], 1
-; CHECK-NEXT:    [[T_1:%.*]] = icmp ule i8 [[START_1]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    [[START_2:%.*]] = or i8 [[START]], 2
-; CHECK-NEXT:    [[T_2:%.*]] = icmp ule i8 [[START_2]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    [[START_3:%.*]] = or i8 [[START]], 3
-; CHECK-NEXT:    [[T_3:%.*]] = icmp ule i8 [[START_3]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    [[START_4:%.*]] = or i8 [[START]], 4
 ; CHECK-NEXT:    [[T_4:%.*]] = icmp ule i8 [[START_4]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 [[T_4]])
 ; CHECK-NEXT:    [[START_5:%.*]] = or i8 [[START]], 5
 ; CHECK-NEXT:    [[C_5:%.*]] = icmp ule i8 [[START_5]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 [[C_5]])
 ; CHECK-NEXT:    ret void

 ; CHECK-NEXT:    [[I_1:%.*]] = or i8 [[START]], 1
 ; CHECK-NEXT:    [[T_1:%.*]] = icmp ugt i8 [[I_1]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 [[T_1]])
 ; CHECK-NEXT:    [[I_2:%.*]] = or i8 [[START]], 2
 ; CHECK-NEXT:    [[T_2:%.*]] = icmp ugt i8 [[I_2]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 [[T_2]])
 ; CHECK-NEXT:    ret void
 ; CHECK:       end:
-; CHECK-NEXT:    [[F_0:%.*]] = icmp ugt i8 [[START]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 false)
 ; CHECK-NEXT:    [[START_1:%.*]] = or i8 [[START]], 1
-; CHECK-NEXT:    [[F_1:%.*]] = icmp ugt i8 [[START_1]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 false)
 ; CHECK-NEXT:    [[START_2:%.*]] = or i8 [[START]], 2
-; CHECK-NEXT:    [[F_2:%.*]] = icmp ugt i8 [[START_2]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 false)
 ; CHECK-NEXT:    [[START_3:%.*]] = or i8 [[START]], 3
-; CHECK-NEXT:    [[F_3:%.*]] = icmp ugt i8 [[START_3]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 false)
 ; CHECK-NEXT:    [[START_4:%.*]] = or i8 [[START]], 4
 ; CHECK-NEXT:    [[F_4:%.*]] = icmp ugt i8 [[START_4]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 [[F_4]])
 ; CHECK-NEXT:    [[START_5:%.*]] = or i8 [[START]], 5
 ; CHECK-NEXT:    [[C_5:%.*]] = icmp ugt i8 [[START_5]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 [[C_5]])
 ; CHECK-NEXT:    ret void

 ; CHECK-NEXT:    [[I_1:%.*]] = or i8 [[START]], 1
 ; CHECK-NEXT:    [[T_1:%.*]] = icmp uge i8 [[I_1]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 [[T_1]])
 ; CHECK-NEXT:    [[I_2:%.*]] = or i8 [[START]], 2
 ; CHECK-NEXT:    [[T_2:%.*]] = icmp uge i8 [[I_2]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 [[T_2]])
 ; CHECK-NEXT:    ret void
 ; CHECK:       end:
-; CHECK-NEXT:    [[F_0:%.*]] = icmp ugt i8 [[START]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 false)
 ; CHECK-NEXT:    [[START_1:%.*]] = or i8 [[START]], 1
-; CHECK-NEXT:    [[F_1:%.*]] = icmp uge i8 [[START_1]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 false)
 ; CHECK-NEXT:    [[START_2:%.*]] = or i8 [[START]], 2
-; CHECK-NEXT:    [[F_2:%.*]] = icmp uge i8 [[START_2]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 false)
 ; CHECK-NEXT:    [[START_3:%.*]] = or i8 [[START]], 3
-; CHECK-NEXT:    [[F_3:%.*]] = icmp uge i8 [[START_3]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 false)
 ; CHECK-NEXT:    [[START_4:%.*]] = or i8 [[START]], 4
 ; CHECK-NEXT:    [[C_4:%.*]] = icmp uge i8 [[START_4]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 [[C_4]])
 ; CHECK-NEXT:    [[START_5:%.*]] = or i8 [[START]], 5
 ; CHECK-NEXT:    [[C_5:%.*]] = icmp uge i8 [[START_5]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 [[C_5]])
 ; CHECK-NEXT:    ret void

llvm/test/Transforms/ConstraintElimination/pointercast.ll

 ; CHECK-NEXT:    [[GEP_3_C:%.*]] = getelementptr i32, ptr [[GEP_3]], i32 0
 ; CHECK-NEXT:    [[C_MIN_0:%.*]] = icmp ult ptr [[SRC_C]], [[MIN_C]]
 ; CHECK-NEXT:    [[C_MAX_3:%.*]] = icmp ugt ptr [[GEP_3_C]], [[MAX:%.*]]
 ; CHECK-NEXT:    [[OR:%.*]] = or i1 [[C_MIN_0]], [[C_MAX_3]]
 ; CHECK-NEXT:    br i1 [[OR]], label [[TRAP:%.*]], label [[CHECKS:%.*]]
 ; CHECK:       trap:
 ; CHECK-NEXT:    ret i1 false
 ; CHECK:       checks:
-; CHECK-NEXT:    [[C_3_MIN:%.*]] = icmp ult ptr [[GEP_3]], [[MIN]]
 ; CHECK-NEXT:    [[C_3_MAX:%.*]] = icmp ult ptr [[GEP_3]], [[MAX]]
 ; CHECK-NEXT:    [[RES_1:%.*]] = xor i1 false, [[C_3_MAX]]
 ; CHECK-NEXT:    [[GEP_1:%.*]] = getelementptr inbounds i32, ptr [[SRC]], i64 1
-; CHECK-NEXT:    [[C_1_MIN:%.*]] = icmp ult ptr [[GEP_1]], [[MIN]]
-; CHECK-NEXT:    [[C_1_MAX:%.*]] = icmp ult ptr [[GEP_1]], [[MAX]]
 ; CHECK-NEXT:    [[RES_2:%.*]] = xor i1 false, true
 ; CHECK-NEXT:    [[GEP_2:%.*]] = getelementptr inbounds i32, ptr [[SRC]], i64 2
-; CHECK-NEXT:    [[C_2_MIN:%.*]] = icmp ult ptr [[GEP_2]], [[MIN]]
-; CHECK-NEXT:    [[C_2_MAX:%.*]] = icmp ult ptr [[GEP_2]], [[MAX]]
 ; CHECK-NEXT:    [[RES_3:%.*]] = xor i1 false, true
 ; CHECK-NEXT:    [[GEP_4:%.*]] = getelementptr inbounds i32, ptr [[SRC]], i64 4
-; CHECK-NEXT:    [[C_4_MIN:%.*]] = icmp ult ptr [[GEP_4]], [[MIN]]
 ; CHECK-NEXT:    [[C_4_MAX:%.*]] = icmp ult ptr [[GEP_4]], [[MAX]]
 ; CHECK-NEXT:    [[RES_4:%.*]] = xor i1 false, [[C_4_MAX]]
 ; CHECK-NEXT:    [[RES_5:%.*]] = xor i1 [[RES_1]], [[RES_2]]
 ; CHECK-NEXT:    [[RES_6:%.*]] = xor i1 [[RES_5]], [[RES_3]]
 ; CHECK-NEXT:    [[RES_7:%.*]] = xor i1 [[RES_6]], [[RES_4]]
 ; CHECK-NEXT:    ret i1 [[RES_7]]
 ;
 check.0.min:

llvm/test/Transforms/ConstraintElimination/range_checks.ll

 ; CHECK-NEXT:    br label [[LOOP:%.*]]
 ; CHECK:       loop:
 ; CHECK-NEXT:    [[IV:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[IV_NEXT:%.*]], [[BACKEDGE:%.*]] ]
 ; CHECK-NEXT:    [[ELEM_PTR:%.*]] = getelementptr i32, ptr [[P:%.*]], i32 [[IV]]
 ; CHECK-NEXT:    [[IDX:%.*]] = load i32, ptr [[ELEM_PTR]], align 4
 ; CHECK-NEXT:    [[IN_BOUNDS:%.*]] = icmp ult i32 [[IDX]], [[MIN_LENGTH:%.*]]
 ; CHECK-NEXT:    br i1 [[IN_BOUNDS]], label [[RANGE_CHECK_BLOCK:%.*]], label [[OUT_OF_BOUNDS:%.*]]
 ; CHECK:       range_check_block:
-; CHECK-NEXT:    [[RANGE_CHECK:%.*]] = icmp ult i32 [[IDX]], [[MIN_LENGTH]]
 ; CHECK-NEXT:    br i1 true, label [[BACKEDGE]], label [[RANGE_CHECK_FAILED:%.*]]
 ; CHECK:       backedge:
 ; CHECK-NEXT:    [[ARR_PTR:%.*]] = getelementptr i32, ptr [[ARRAY:%.*]], i32 [[IDX]]
 ; CHECK-NEXT:    store i32 [[IV]], ptr [[ARR_PTR]], align 4
 ; CHECK-NEXT:    [[IV_NEXT]] = add i32 [[IV]], 1
 ; CHECK-NEXT:    [[LOOP_COND:%.*]] = call i1 @cond()
 ; CHECK-NEXT:    br i1 [[LOOP_COND]], label [[LOOP]], label [[EXIT:%.*]]
 ; CHECK:       exit:

 ; CHECK-NEXT:    br i1 [[LENGTH_CHECK]], label [[LOOP:%.*]], label [[FAILED:%.*]]
 ; CHECK:       loop:
 ; CHECK-NEXT:    [[IV:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[IV_NEXT:%.*]], [[BACKEDGE:%.*]] ]
 ; CHECK-NEXT:    [[ELEM_PTR:%.*]] = getelementptr i32, ptr [[P:%.*]], i32 [[IV]]
 ; CHECK-NEXT:    [[IDX:%.*]] = load i32, ptr [[ELEM_PTR]], align 4
 ; CHECK-NEXT:    [[IN_BOUNDS:%.*]] = icmp ult i32 [[IDX]], [[MIN_LENGTH]]
 ; CHECK-NEXT:    br i1 [[IN_BOUNDS]], label [[RANGE_CHECK_BLOCK:%.*]], label [[OUT_OF_BOUNDS:%.*]]
 ; CHECK:       range_check_block:
-; CHECK-NEXT:    [[RANGE_CHECK:%.*]] = icmp ult i32 [[IDX]], [[LENGTH]]
 ; CHECK-NEXT:    br i1 true, label [[BACKEDGE]], label [[RANGE_CHECK_FAILED:%.*]]
 ; CHECK:       backedge:
 ; CHECK-NEXT:    [[ARR_PTR:%.*]] = getelementptr i32, ptr [[ARRAY:%.*]], i32 [[IDX]]
 ; CHECK-NEXT:    store i32 [[IV]], ptr [[ARR_PTR]], align 4
 ; CHECK-NEXT:    [[IV_NEXT]] = add i32 [[IV]], 1
 ; CHECK-NEXT:    [[LOOP_COND:%.*]] = call i1 @cond()
 ; CHECK-NEXT:    br i1 [[LOOP_COND]], label [[LOOP]], label [[EXIT:%.*]]
 ; CHECK:       exit:

llvm/test/Transforms/ConstraintElimination/sge.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -passes=constraint-elimination -S %s | FileCheck %s
 
 declare void @use(i1)
 
 define void @test_1_variable_constraint(i32 %x, i32 %y, i32 %z) {
 ; CHECK-LABEL: @test_1_variable_constraint(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp sge i32 [[X:%.*]], [[Y:%.*]]
 ; CHECK-NEXT:    br i1 [[C_1]], label [[BB1:%.*]], label [[BB2:%.*]]
 ; CHECK:       bb1:
-; CHECK-NEXT:    [[T_1:%.*]] = icmp sge i32 [[X]], [[Y]]
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    [[C_2:%.*]] = icmp sge i32 [[X]], 10
 ; CHECK-NEXT:    call void @use(i1 [[C_2]])
 ; CHECK-NEXT:    [[C_3:%.*]] = icmp sge i32 [[Y]], [[X]]
 ; CHECK-NEXT:    call void @use(i1 [[C_3]])
 ; CHECK-NEXT:    [[C_4:%.*]] = icmp sge i32 10, [[X]]
 ; CHECK-NEXT:    call void @use(i1 [[C_4]])
 ; CHECK-NEXT:    ret void
 ; CHECK:       bb2:
-; CHECK-NEXT:    [[T_2:%.*]] = icmp sge i32 [[Y]], [[X]]
 ; CHECK-NEXT:    call void @use(i1 true)
-; CHECK-NEXT:    [[F_1:%.*]] = icmp sge i32 [[X]], [[Y]]
 ; CHECK-NEXT:    call void @use(i1 false)
 ; CHECK-NEXT:    [[C_5:%.*]] = icmp sge i32 [[X]], 10
 ; CHECK-NEXT:    call void @use(i1 [[C_5]])
 ; CHECK-NEXT:    [[C_6:%.*]] = icmp sge i32 10, [[X]]
 ; CHECK-NEXT:    call void @use(i1 [[C_6]])
 ; CHECK-NEXT:    ret void
 ;
 entry:

 }
 
 define void @test_1_constant_constraint(i32 %x) {
 ; CHECK-LABEL: @test_1_constant_constraint(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp sge i32 [[X:%.*]], 10
 ; CHECK-NEXT:    br i1 [[C_1]], label [[BB1:%.*]], label [[BB2:%.*]]
 ; CHECK:       bb1:
-; CHECK-NEXT:    [[T_1:%.*]] = icmp sge i32 [[X]], 10
 ; CHECK-NEXT:    call void @use(i1 true)
-; CHECK-NEXT:    [[T_2:%.*]] = icmp sge i32 [[X]], 9
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    [[C_2:%.*]] = icmp sge i32 [[X]], 11
 ; CHECK-NEXT:    call void @use(i1 [[C_2]])
 ; CHECK-NEXT:    [[C_4:%.*]] = icmp sge i32 10, [[X]]
 ; CHECK-NEXT:    call void @use(i1 [[C_4]])
 ; CHECK-NEXT:    ret void
 ; CHECK:       bb2:
-; CHECK-NEXT:    [[T_3:%.*]] = icmp sge i32 11, [[X]]
 ; CHECK-NEXT:    call void @use(i1 true)
-; CHECK-NEXT:    [[F_1:%.*]] = icmp sge i32 [[X]], 10
 ; CHECK-NEXT:    call void @use(i1 false)
-; CHECK-NEXT:    [[F_1_1:%.*]] = icmp sge i32 [[X]], 10
 ; CHECK-NEXT:    call void @use(i1 false)
 ; CHECK-NEXT:    [[C_5:%.*]] = icmp sge i32 [[X]], 9
 ; CHECK-NEXT:    call void @use(i1 [[C_5]])
 ; CHECK-NEXT:    [[C_6:%.*]] = icmp sge i32 1, [[X]]
 ; CHECK-NEXT:    call void @use(i1 [[C_6]])
 ; CHECK-NEXT:    ret void
 ;
 entry:

 ; CHECK-LABEL: @test1(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp sge i32 [[X:%.*]], [[Y:%.*]]
 ; CHECK-NEXT:    br i1 [[C_1]], label [[BB1:%.*]], label [[EXIT:%.*]]
 ; CHECK:       bb1:
 ; CHECK-NEXT:    [[C_2:%.*]] = icmp sge i32 [[Y]], [[Z:%.*]]
 ; CHECK-NEXT:    br i1 [[C_2]], label [[BB2:%.*]], label [[EXIT]]
 ; CHECK:       bb2:
-; CHECK-NEXT:    [[C_3:%.*]] = icmp sge i32 [[X]], [[Z]]
 ; CHECK-NEXT:    br i1 true, label [[BB3:%.*]], label [[EXIT]]
 ; CHECK:       bb3:
 ; CHECK-NEXT:    ret i32 10
 ; CHECK:       exit:
 ; CHECK-NEXT:    ret i32 20
 ;
 entry:
   %c.1 = icmp sge i32 %x, %y

 ; CHECK-LABEL: @test4(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp sge i32 [[X:%.*]], [[Y:%.*]]
 ; CHECK-NEXT:    br i1 [[C_1]], label [[BB1:%.*]], label [[EXIT:%.*]]
 ; CHECK:       bb1:
 ; CHECK-NEXT:    [[C_2:%.*]] = icmp sge i32 [[Y]], [[Z:%.*]]
 ; CHECK-NEXT:    br i1 [[C_2]], label [[BB2:%.*]], label [[EXIT]]
 ; CHECK:       bb2:
-; CHECK-NEXT:    [[T_1:%.*]] = icmp sge i32 [[X]], [[Z]]
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    [[U_1:%.*]] = icmp eq i32 [[X]], [[Z]]
 ; CHECK-NEXT:    call void @use(i1 [[U_1]])
 ; CHECK-NEXT:    ret i32 10
 ; CHECK:       exit:
 ; CHECK-NEXT:    ret i32 20
 ;
 entry:

 }
 
 define i1 @sge_sgt(i32 %x, i32 %y, i32 %z) {
 ; CHECK-LABEL: @sge_sgt(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp sgt i32 [[X:%.*]], -1
 ; CHECK-NEXT:    br i1 [[C_1]], label [[THEN:%.*]], label [[ELSE:%.*]]
 ; CHECK:       then:
-; CHECK-NEXT:    [[T_1:%.*]] = icmp sge i32 [[X]], 0
 ; CHECK-NEXT:    ret i1 true
 ; CHECK:       else:
-; CHECK-NEXT:    [[F_1:%.*]] = icmp sge i32 [[X]], 0
 ; CHECK-NEXT:    ret i1 false
 ;
 entry:
   %c.1 = icmp sgt i32 %x, -1
   br i1 %c.1, label %then, label %else
 
 then:
   %t.1 = icmp sge i32 %x, 0
   ret i1 %t.1
 
 else:
   %f.1 = icmp sge i32 %x, 0
   ret i1 %f.1
 }

llvm/test/Transforms/ConstraintElimination/shl.ll

 
 define i1 @test_shl_const_nuw_unsigned_10(i8 %start, i8 %high) {
 ; CHECK-LABEL: @test_shl_const_nuw_unsigned_10(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[START_SHL_5:%.*]] = shl nuw i8 [[START:%.*]], 5
 ; CHECK-NEXT:    [[C_0:%.*]] = icmp ult i8 [[START]], [[START_SHL_5]]
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C_0]])
 ; CHECK-NEXT:    [[START_SHL_3:%.*]] = shl nuw i8 [[START]], 3
-; CHECK-NEXT:    [[T_1:%.*]] = icmp ule i8 [[START_SHL_3]], [[START_SHL_5]]
 ; CHECK-NEXT:    ret i1 true
 ;
 entry:
   %start.shl.5 = shl nuw i8 %start, 5
   %c.0 = icmp ult i8 %start, %start.shl.5
   call void @llvm.assume(i1 %c.0)
 
   %start.shl.3 = shl nuw i8 %start, 3
   %t.1 = icmp ule i8 %start.shl.3, %start.shl.5
   ret i1 %t.1
 }
 
 define i1 @test_shl_const_nuw_unsigned_11(i8 %start, i8 %high) {
 ; CHECK-LABEL: @test_shl_const_nuw_unsigned_11(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[START_SHL_5:%.*]] = shl nuw i8 [[START:%.*]], 5
 ; CHECK-NEXT:    [[C_0:%.*]] = icmp ult i8 [[START]], [[START_SHL_5]]
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C_0]])
 ; CHECK-NEXT:    [[START_SHL_3:%.*]] = shl nuw i8 [[START]], 3
-; CHECK-NEXT:    [[C_1:%.*]] = icmp ule i8 [[START_SHL_5]], [[START_SHL_3]]
 ; CHECK-NEXT:    ret i1 false
 ;
 entry:
   %start.shl.5 = shl nuw i8 %start, 5
   %c.0 = icmp ult i8 %start, %start.shl.5
   call void @llvm.assume(i1 %c.0)
 
   %start.shl.3 = shl nuw i8 %start, 3
   %c.1 = icmp ule i8 %start.shl.5, %start.shl.3
   ret i1 %c.1
 }
 
 define i1 @test_shl_const_nuw_unsigned_12(i8 %start) {
 ; CHECK-LABEL: @test_shl_const_nuw_unsigned_12(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[START_SHL_3:%.*]] = shl nuw i8 [[START:%.*]], 3
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ult i8 [[START]], [[START_SHL_3]]
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C_1]])
 ; CHECK-NEXT:    [[START_SHL_5:%.*]] = shl nuw i8 [[START]], 5
-; CHECK-NEXT:    [[T_1:%.*]] = icmp ule i8 [[START_SHL_3]], [[START_SHL_5]]
 ; CHECK-NEXT:    ret i1 true
 ;
 entry:
   %start.shl.3 = shl nuw i8 %start, 3
   %c.1 = icmp ult i8 %start, %start.shl.3
   call void @llvm.assume(i1 %c.1)
 
   %start.shl.5 = shl nuw i8 %start, 5
entry:
   %shl.cmp = icmp uge i256 %shl.ub, 0
   ret i1 %shl.cmp
 }
 
 define i1 @shl_55() {
 ; CHECK-LABEL: @shl_55(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[SHL_UB:%.*]] = shl nuw nsw i256 1, 55
-; CHECK-NEXT:    [[SHL_CMP:%.*]] = icmp uge i256 [[SHL_UB]], 1
 ; CHECK-NEXT:    ret i1 true
 ;
 entry:
   %shl.ub = shl nuw nsw i256 1, 55
   %shl.cmp = icmp uge i256 %shl.ub, 1
   ret i1 %shl.cmp
 }

llvm/test/Transforms/ConstraintElimination/signed-query-unsigned-system.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -passes=constraint-elimination -S %s | FileCheck %s
 
 declare void @llvm.assume(i1)
 
 define i1 @sge_0_unsigned_a_ne_0(i8 %a) {
 ; CHECK-LABEL: @sge_0_unsigned_a_ne_0(
 ; CHECK-NEXT:    [[A_NE_0:%.*]] = icmp ne i8 [[A:%.*]], 0
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[A_NE_0]])
 ; CHECK-NEXT:    [[EXT:%.*]] = zext i8 [[A]] to i16
-; CHECK-NEXT:    [[T:%.*]] = icmp sge i16 [[EXT]], 0
 ; CHECK-NEXT:    ret i1 true
 ;
   %a.ne.0 = icmp ne i8 %a, 0
   call void @llvm.assume(i1 %a.ne.0)
   %ext = zext i8 %a to i16
   %t = icmp sge i16 %ext, 0
   ret i1 %t
 }
 
 define i1 @sgt_0_unsigned_a_ne_0(i8 %a) {
 ; CHECK-LABEL: @sgt_0_unsigned_a_ne_0(
 ; CHECK-NEXT:    [[A_NE_0:%.*]] = icmp ne i8 [[A:%.*]], 0
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[A_NE_0]])
 ; CHECK-NEXT:    [[EXT:%.*]] = zext i8 [[A]] to i16
-; CHECK-NEXT:    [[T:%.*]] = icmp sgt i16 [[EXT]], 0
 ; CHECK-NEXT:    ret i1 true
 ;
   %a.ne.0 = icmp ne i8 %a, 0
   call void @llvm.assume(i1 %a.ne.0)
   %ext = zext i8 %a to i16
   %t = icmp sgt i16 %ext, 0
   ret i1 %t
 }
 
 define i1 @sgt_0_unsigned_a_sgt_0(i8 %a) {
 ; CHECK-LABEL: @sgt_0_unsigned_a_sgt_0(
 ; CHECK-NEXT:    [[A_SGT_0:%.*]] = icmp sgt i8 [[A:%.*]], 0
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[A_SGT_0]])
 ; CHECK-NEXT:    [[EXT:%.*]] = zext i8 [[A]] to i16
-; CHECK-NEXT:    [[T:%.*]] = icmp sgt i16 [[EXT]], 0
 ; CHECK-NEXT:    ret i1 true
 ;
   %a.sgt.0 = icmp sgt i8 %a, 0
   call void @llvm.assume(i1 %a.sgt.0)
   %ext = zext i8 %a to i16
   %t = icmp sgt i16 %ext, 0
   ret i1 %t
 }
 
 define i1 @sge_0_unsigned_a_sge_0(i8 %a) {
 ; CHECK-LABEL: @sge_0_unsigned_a_sge_0(
 ; CHECK-NEXT:    [[A_SGE_0:%.*]] = icmp sge i8 [[A:%.*]], 0
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[A_SGE_0]])
 ; CHECK-NEXT:    [[EXT:%.*]] = zext i8 [[A]] to i16
-; CHECK-NEXT:    [[T:%.*]] = icmp sge i16 [[EXT]], 0
 ; CHECK-NEXT:    ret i1 true
 ;
   %a.sge.0 = icmp sge i8 %a, 0
   call void @llvm.assume(i1 %a.sge.0)
   %ext = zext i8 %a to i16
   %t = icmp sge i16 %ext, 0
   ret i1 %t
 }
 
 define i1 @sgt_0_unsigned_a_ugt_0(i8 %a) {
 ; CHECK-LABEL: @sgt_0_unsigned_a_ugt_0(
 ; CHECK-NEXT:    [[A_UGT_0:%.*]] = icmp ugt i8 [[A:%.*]], 0
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[A_UGT_0]])
 ; CHECK-NEXT:    [[EXT:%.*]] = zext i8 [[A]] to i16
-; CHECK-NEXT:    [[T:%.*]] = icmp sgt i16 [[EXT]], 0
 ; CHECK-NEXT:    ret i1 true
 ;
   %a.ugt.0 = icmp ugt i8 %a, 0
   call void @llvm.assume(i1 %a.ugt.0)
   %ext = zext i8 %a to i16
   %t = icmp sgt i16 %ext, 0
   ret i1 %t
 }
;
   ret i1 %cmp
 }
 
 define i1 @sgt_1_unsigned_a_ugt_1(i8 %a) {
 ; CHECK-LABEL: @sgt_1_unsigned_a_ugt_1(
 ; CHECK-NEXT:    [[A_UGT_1:%.*]] = icmp ugt i8 [[A:%.*]], 1
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[A_UGT_1]])
 ; CHECK-NEXT:    [[EXT:%.*]] = zext i8 [[A]] to i16
-; CHECK-NEXT:    [[T:%.*]] = icmp sgt i16 [[EXT]], 1
 ; CHECK-NEXT:    ret i1 true
 ;
   %a.ugt.1 = icmp ugt i8 %a, 1
   call void @llvm.assume(i1 %a.ugt.1)
   %ext = zext i8 %a to i16
   %t = icmp sgt i16 %ext, 1
   ret i1 %t
 }
;
   ret i1 %cmp
 }
 
 define i1 @sgt_0_unsigned_a_ugt_neg_10(i8 %a) {
 ; CHECK-LABEL: @sgt_0_unsigned_a_ugt_neg_10(
 ; CHECK-NEXT:    [[A_UGT_0:%.*]] = icmp ugt i8 [[A:%.*]], 10
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[A_UGT_0]])
 ; CHECK-NEXT:    [[EXT:%.*]] = zext i8 [[A]] to i16
-; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt i16 [[EXT]], 0
 ; CHECK-NEXT:    ret i1 true
 ;
   %a.ugt.0 = icmp ugt i8 %a, 10
   call void @llvm.assume(i1 %a.ugt.0)
   %ext = zext i8 %a to i16
   %cmp = icmp sgt i16 %ext, 0
   ret i1 %cmp
 }
 
 define i1 @sge_neg_1_sge_0_known(i8 %a) {
 ; CHECK-LABEL: @sge_neg_1_sge_0_known(
 ; CHECK-NEXT:    [[EXT:%.*]] = zext i8 [[A:%.*]] to i16
 ; CHECK-NEXT:    [[A_NE_0:%.*]] = icmp sge i16 [[EXT]], 0
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[A_NE_0]])
-; CHECK-NEXT:    [[T:%.*]] = icmp sge i16 [[EXT]], -1
 ; CHECK-NEXT:    ret i1 true
 ;
   %ext = zext i8 %a to i16
   %a.ne.0 = icmp sge i16 %ext, 0
   call void @llvm.assume(i1 %a.ne.0)
   %t = icmp sge i16 %ext, -1
   ret i1 %t
 }

llvm/test/Transforms/ConstraintElimination/sub-nuw.ll

 ; CHECK-NEXT:    call void @use(i1 [[T_0]])
 ; CHECK-NEXT:    [[START_1:%.*]] = sub nuw i8 [[START]], 1
 ; CHECK-NEXT:    [[T_1:%.*]] = icmp ult i8 [[START_1]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 [[T_1]])
 ; CHECK-NEXT:    [[START_2:%.*]] = sub nuw i8 [[START]], 2
 ; CHECK-NEXT:    [[T_2:%.*]] = icmp ult i8 [[START_2]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 [[T_2]])
 ; CHECK-NEXT:    [[START_3:%.*]] = sub nuw i8 [[START]], 3
-; CHECK-NEXT:    [[T_3:%.*]] = icmp ult i8 [[START_3]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    [[START_4:%.*]] = sub nuw i8 [[START]], 4
-; CHECK-NEXT:    [[C_4:%.*]] = icmp ult i8 [[START_4]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %sub.ptr.i = sub nuw i8 %start, 3
   %c.1 = icmp uge i8 %sub.ptr.i, %high
   br i1 %c.1, label %if.then, label %if.end
 

 ; CHECK-NEXT:    ret void
 ; CHECK:       if.end:
 ; CHECK-NEXT:    [[T_0:%.*]] = icmp ule i8 [[START]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 [[T_0]])
 ; CHECK-NEXT:    [[START_1:%.*]] = sub nuw i8 [[START]], 1
 ; CHECK-NEXT:    [[T_1:%.*]] = icmp ule i8 [[START_1]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 [[T_1]])
 ; CHECK-NEXT:    [[START_2:%.*]] = sub nuw i8 [[START]], 2
-; CHECK-NEXT:    [[T_2:%.*]] = icmp ule i8 [[START_2]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    [[START_3:%.*]] = sub nuw i8 [[START]], 3
-; CHECK-NEXT:    [[T_3:%.*]] = icmp ule i8 [[START_3]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    [[START_4:%.*]] = sub nuw i8 [[START]], 4
-; CHECK-NEXT:    [[T_4:%.*]] = icmp ule i8 [[START_4]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    [[START_5:%.*]] = sub nuw i8 [[START]], 5
-; CHECK-NEXT:    [[C_5:%.*]] = icmp ule i8 [[START_5]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %sub.ptr.i = sub nuw i8 %start, 3
   %c.1 = icmp uge i8 %sub.ptr.i, %high
   br i1 %c.1, label %if.then, label %if.end
 

 ; CHECK-NEXT:    ret void
 ; CHECK:       if.end:
 ; CHECK-NEXT:    [[F_0:%.*]] = icmp ugt i8 [[START]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 [[F_0]])
 ; CHECK-NEXT:    [[START_1:%.*]] = sub nuw i8 [[START]], 1
 ; CHECK-NEXT:    [[F_1:%.*]] = icmp ugt i8 [[START_1]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 [[F_1]])
 ; CHECK-NEXT:    [[START_2:%.*]] = sub nuw i8 [[START]], 2
-; CHECK-NEXT:    [[F_2:%.*]] = icmp ugt i8 [[START_2]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 false)
 ; CHECK-NEXT:    [[START_3:%.*]] = sub nuw i8 [[START]], 3
-; CHECK-NEXT:    [[F_3:%.*]] = icmp ugt i8 [[START_3]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 false)
 ; CHECK-NEXT:    [[START_4:%.*]] = sub nuw i8 [[START]], 4
-; CHECK-NEXT:    [[F_4:%.*]] = icmp ugt i8 [[START_4]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 false)
 ; CHECK-NEXT:    [[START_5:%.*]] = sub nuw i8 [[START]], 5
-; CHECK-NEXT:    [[C_5:%.*]] = icmp ugt i8 [[START_5]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 false)
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %sub.ptr.i = sub nuw i8 %start, 3
   %c.1 = icmp uge i8 %sub.ptr.i, %high
   br i1 %c.1, label %if.then, label %if.end
 

 ; CHECK-NEXT:    call void @use(i1 [[F_0]])
 ; CHECK-NEXT:    [[START_1:%.*]] = sub nuw i8 [[START]], 1
 ; CHECK-NEXT:    [[F_1:%.*]] = icmp uge i8 [[START_1]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 [[F_1]])
 ; CHECK-NEXT:    [[START_2:%.*]] = sub nuw i8 [[START]], 2
 ; CHECK-NEXT:    [[F_2:%.*]] = icmp uge i8 [[START_2]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 [[F_2]])
 ; CHECK-NEXT:    [[START_3:%.*]] = sub nuw i8 [[START]], 3
-; CHECK-NEXT:    [[F_3:%.*]] = icmp uge i8 [[START_3]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 false)
 ; CHECK-NEXT:    [[START_4:%.*]] = sub nuw i8 [[START]], 4
-; CHECK-NEXT:    [[C_4:%.*]] = icmp uge i8 [[START_4]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 false)
 ; CHECK-NEXT:    [[START_5:%.*]] = sub nuw i8 [[START]], 5
-; CHECK-NEXT:    [[C_5:%.*]] = icmp uge i8 [[START_5]], [[HIGH]]
 ; CHECK-NEXT:    call void @use(i1 false)
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %sub.ptr.i = sub nuw i8 %start, 3
   %c.1 = icmp uge i8 %sub.ptr.i, %high
   br i1 %c.1, label %if.then, label %if.end
 

 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[NEG2:%.*]] = sub nuw i16 [[A:%.*]], 305
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ugt i16 0, [[NEG2]]
 ; CHECK-NEXT:    br i1 [[C_1]], label [[EXIT_1:%.*]], label [[EXIT_2:%.*]]
 ; CHECK:       exit.1:
 ; CHECK-NEXT:    [[C_2:%.*]] = icmp ugt i16 [[A]], 0
 ; CHECK-NEXT:    ret i1 [[C_2]]
 ; CHECK:       exit.2:
-; CHECK-NEXT:    [[C_3:%.*]] = icmp ugt i16 [[A]], 0
 ; CHECK-NEXT:    ret i1 true
 ;
 entry:
   %neg2 = sub nuw i16 %a, 305
   %c.1 = icmp ugt i16 0, %neg2
   br i1 %c.1, label %exit.1, label %exit.2
 
 exit.1:

 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[NEG2:%.*]] = sub nuw i64 [[A:%.*]], 305
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ugt i64 0, [[NEG2]]
 ; CHECK-NEXT:    br i1 [[C_1]], label [[EXIT_1:%.*]], label [[EXIT_2:%.*]]
 ; CHECK:       exit.1:
 ; CHECK-NEXT:    [[C_2:%.*]] = icmp ugt i64 [[A]], 0
 ; CHECK-NEXT:    ret i1 [[C_2]]
 ; CHECK:       exit.2:
-; CHECK-NEXT:    [[C_3:%.*]] = icmp ugt i64 [[A]], 0
 ; CHECK-NEXT:    ret i1 true
 ;
 entry:
   %neg2 = sub nuw i64 %a, 305
   %c.1 = icmp ugt i64 0, %neg2
   br i1 %c.1, label %exit.1, label %exit.2
 
 exit.1:
   %c.2 = icmp ugt i64 %a, 0
   ret i1 %c.2
 
 exit.2:
   %c.3 = icmp ugt i64 %a, 0
   ret i1 %c.3
 }
 
 define i1 @sub_nuw_neg_i16(i16 %a) {
 ; CHECK-LABEL: @sub_nuw_neg_i16(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[NEG2:%.*]] = sub nuw i16 [[A:%.*]], -305
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ugt i16 0, [[NEG2]]
 ; CHECK-NEXT:    br i1 [[C_1]], label [[EXIT_1:%.*]], label [[EXIT_2:%.*]]
 ; CHECK:       exit.1:
-; CHECK-NEXT:    [[C_2:%.*]] = icmp ugt i16 [[A]], 0
 ; CHECK-NEXT:    ret i1 false
 ; CHECK:       exit.2:
 ; CHECK-NEXT:    [[C_3:%.*]] = icmp ugt i16 [[A]], 0
 ; CHECK-NEXT:    ret i1 [[C_3]]
 ;
 entry:
   %neg2 = sub nuw i16 %a, -305
   %c.1 = icmp ugt i16 0, %neg2

llvm/test/Transforms/ConstraintElimination/switch.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -passes=constraint-elimination -S %s | FileCheck %s
 
 declare void @may_unwind()
 
 define i1 @test_switch_in_block_with_assume(i32 %x) {
 ; CHECK-LABEL: @test_switch_in_block_with_assume(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    call void @may_unwind()
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ult i32 [[X:%.*]], 10
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C_1]])
 ; CHECK-NEXT:    switch i32 0, label [[EXIT_1:%.*]] [
 ; CHECK-NEXT:    i32 1, label [[EXIT_2:%.*]]
 ; CHECK-NEXT:    ]
 ; CHECK:       exit.1:
-; CHECK-NEXT:    [[T_1:%.*]] = icmp ult i32 [[X]], 10
 ; CHECK-NEXT:    [[C_2:%.*]] = icmp ult i32 [[X]], 9
 ; CHECK-NEXT:    [[RES_1:%.*]] = xor i1 true, [[C_2]]
 ; CHECK-NEXT:    ret i1 [[RES_1]]
 ; CHECK:       exit.2:
-; CHECK-NEXT:    [[T_2:%.*]] = icmp ult i32 [[X]], 10
 ; CHECK-NEXT:    [[C_3:%.*]] = icmp ult i32 [[X]], 9
 ; CHECK-NEXT:    [[RES_2:%.*]] = xor i1 true, [[C_3]]
 ; CHECK-NEXT:    ret i1 [[RES_2]]
 ;
 entry:
   call void @may_unwind()
   %c.1 = icmp ult i32 %x, 10
   call void @llvm.assume(i1 %c.1)

llvm/test/Transforms/ConstraintElimination/transfer-signed-facts-to-unsigned.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -passes=constraint-elimination -S %s | FileCheck %s
 
 define i1 @len_known_positive_via_idx_1(i8 %len, i8 %idx) {
 ; CHECK-LABEL: @len_known_positive_via_idx_1(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[IDX_POS:%.*]] = icmp sge i8 [[IDX:%.*]], 0
 ; CHECK-NEXT:    [[IDX_SLT_LEN:%.*]] = icmp slt i8 [[IDX]], [[LEN:%.*]]
 ; CHECK-NEXT:    [[AND_1:%.*]] = and i1 [[IDX_POS]], [[IDX_SLT_LEN]]
 ; CHECK-NEXT:    br i1 [[AND_1]], label [[THEN_1:%.*]], label [[ELSE:%.*]]
 ; CHECK:       then.1:
-; CHECK-NEXT:    [[T_1:%.*]] = icmp ult i8 [[IDX]], [[LEN]]
-; CHECK-NEXT:    [[T_2:%.*]] = icmp sge i8 [[LEN]], 0
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp sge i8 [[LEN]], 2
 ; CHECK-NEXT:    [[C_2:%.*]] = icmp sge i8 [[LEN]], 2
 ; CHECK-NEXT:    [[RES_1:%.*]] = xor i1 true, true
 ; CHECK-NEXT:    [[RES_2:%.*]] = xor i1 [[RES_1]], [[C_1]]
 ; CHECK-NEXT:    [[RES_3:%.*]] = xor i1 [[RES_2]], [[C_2]]
 ; CHECK-NEXT:    ret i1 [[RES_3]]
 ; CHECK:       else:
 ; CHECK-NEXT:    ret i1 false

 define i1 @len_known_positive_via_idx_2(i8 %len, i8 %idx) {
 ; CHECK-LABEL: @len_known_positive_via_idx_2(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[IDX_SLT_LEN:%.*]] = icmp slt i8 [[IDX:%.*]], [[LEN:%.*]]
 ; CHECK-NEXT:    [[IDX_POS:%.*]] = icmp sge i8 [[IDX]], 0
 ; CHECK-NEXT:    [[AND_1:%.*]] = and i1 [[IDX_SLT_LEN]], [[IDX_POS]]
 ; CHECK-NEXT:    br i1 [[AND_1]], label [[THEN_1:%.*]], label [[ELSE:%.*]]
 ; CHECK:       then.1:
-; CHECK-NEXT:    [[T_1:%.*]] = icmp ult i8 [[IDX]], [[LEN]]
-; CHECK-NEXT:    [[T_2:%.*]] = icmp sge i8 [[LEN]], 0
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp sge i8 [[LEN]], 2
 ; CHECK-NEXT:    [[C_2:%.*]] = icmp sge i8 [[LEN]], 2
 ; CHECK-NEXT:    [[RES_1:%.*]] = xor i1 true, true
 ; CHECK-NEXT:    [[RES_2:%.*]] = xor i1 [[RES_1]], [[C_1]]
 ; CHECK-NEXT:    [[RES_3:%.*]] = xor i1 [[RES_2]], [[C_2]]
 ; CHECK-NEXT:    ret i1 [[RES_3]]
 ; CHECK:       else:
 ; CHECK-NEXT:    ret i1 false

 declare void @llvm.assume(i1)
 
 define i1 @cnt_positive_sgt_against_base(ptr %p, i32 %cnt) {
 ; CHECK-LABEL: @cnt_positive_sgt_against_base(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt i32 [[CNT:%.*]], -1
 ; CHECK-NEXT:    tail call void @llvm.assume(i1 [[CMP]])
 ; CHECK-NEXT:    [[ADD_PTR:%.*]] = getelementptr inbounds i32, ptr [[P:%.*]], i32 [[CNT]]
-; CHECK-NEXT:    [[CMP_1:%.*]] = icmp uge ptr [[ADD_PTR]], [[P]]
 ; CHECK-NEXT:    br i1 true, label [[THEN:%.*]], label [[ELSE:%.*]]
 ; CHECK:       then:
 ; CHECK-NEXT:    ret i1 false
 ; CHECK:       else:
 ; CHECK-NEXT:    ret i1 true
 ;
 entry:
   %cmp = icmp sgt i32 %cnt, -1

 
 define i1 @cnt_positive_sgt_against_base_with_zext(ptr %p, i32 %cnt) {
 ; CHECK-LABEL: @cnt_positive_sgt_against_base_with_zext(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt i32 [[CNT:%.*]], -1
 ; CHECK-NEXT:    tail call void @llvm.assume(i1 [[CMP]])
 ; CHECK-NEXT:    [[EXT:%.*]] = zext i32 [[CNT]] to i64
 ; CHECK-NEXT:    [[ADD_PTR:%.*]] = getelementptr inbounds i32, ptr [[P:%.*]], i64 [[EXT]]
-; CHECK-NEXT:    [[CMP_1:%.*]] = icmp uge ptr [[ADD_PTR]], [[P]]
 ; CHECK-NEXT:    br i1 true, label [[THEN:%.*]], label [[ELSE:%.*]]
 ; CHECK:       then:
 ; CHECK-NEXT:    ret i1 false
 ; CHECK:       else:
 ; CHECK-NEXT:    ret i1 true
 ;
 entry:
   %cmp = icmp sgt i32 %cnt, -1

 
 define i1 @cnt_positive_sge_against_base_with_zext(ptr %p, i32 %cnt) {
 ; CHECK-LABEL: @cnt_positive_sge_against_base_with_zext(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp sge i32 [[CNT:%.*]], 0
 ; CHECK-NEXT:    tail call void @llvm.assume(i1 [[CMP]])
 ; CHECK-NEXT:    [[EXT:%.*]] = zext i32 [[CNT]] to i64
 ; CHECK-NEXT:    [[ADD_PTR:%.*]] = getelementptr inbounds i32, ptr [[P:%.*]], i64 [[EXT]]
-; CHECK-NEXT:    [[CMP_1:%.*]] = icmp uge ptr [[ADD_PTR]], [[P]]
 ; CHECK-NEXT:    br i1 true, label [[THEN:%.*]], label [[ELSE:%.*]]
 ; CHECK:       then:
 ; CHECK-NEXT:    ret i1 false
 ; CHECK:       else:
 ; CHECK-NEXT:    ret i1 true
 ;
 entry:
   %cmp = icmp sge i32 %cnt, 0

 
 define i1 @cnt_not_known_positive_sgt_against_base_with_zext(ptr %p, i32 %cnt) {
 ; CHECK-LABEL: @cnt_not_known_positive_sgt_against_base_with_zext(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt i32 [[CNT:%.*]], -2
 ; CHECK-NEXT:    tail call void @llvm.assume(i1 [[CMP]])
 ; CHECK-NEXT:    [[EXT:%.*]] = zext i32 [[CNT]] to i64
 ; CHECK-NEXT:    [[ADD_PTR:%.*]] = getelementptr inbounds i32, ptr [[P:%.*]], i64 [[EXT]]
-; CHECK-NEXT:    [[CMP_1:%.*]] = icmp uge ptr [[ADD_PTR]], [[P]]
 ; CHECK-NEXT:    br i1 true, label [[THEN:%.*]], label [[ELSE:%.*]]
 ; CHECK:       then:
 ; CHECK-NEXT:    ret i1 false
 ; CHECK:       else:
 ; CHECK-NEXT:    ret i1 true
 ;
 entry:
   %cmp = icmp sgt i32 %cnt, -2

 
 define i1 @cnt_not_known_positive_sge_against_base_with_zext(ptr %p, i32 %cnt) {
 ; CHECK-LABEL: @cnt_not_known_positive_sge_against_base_with_zext(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp sge i32 [[CNT:%.*]], -1
 ; CHECK-NEXT:    tail call void @llvm.assume(i1 [[CMP]])
 ; CHECK-NEXT:    [[EXT:%.*]] = zext i32 [[CNT]] to i64
 ; CHECK-NEXT:    [[ADD_PTR:%.*]] = getelementptr inbounds i32, ptr [[P:%.*]], i64 [[EXT]]
-; CHECK-NEXT:    [[CMP_1:%.*]] = icmp uge ptr [[ADD_PTR]], [[P]]
 ; CHECK-NEXT:    br i1 true, label [[THEN:%.*]], label [[ELSE:%.*]]
 ; CHECK:       then:
 ; CHECK-NEXT:    ret i1 false
 ; CHECK:       else:
 ; CHECK-NEXT:    ret i1 true
 ;
 entry:
   %cmp = icmp sge i32 %cnt, -1

 
 define i1 @cnt_positive_from_assume_check_against_base_struct_ugt_with_zext(ptr %p, i32 %cnt) {
 ; CHECK-LABEL: @cnt_positive_from_assume_check_against_base_struct_ugt_with_zext(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt i32 [[CNT:%.*]], -1
 ; CHECK-NEXT:    tail call void @llvm.assume(i1 [[CMP]])
 ; CHECK-NEXT:    [[EXT:%.*]] = zext i32 [[CNT]] to i64
 ; CHECK-NEXT:    [[GEP_EXT:%.*]] = getelementptr inbounds [[T:%.*]], ptr [[P:%.*]], i64 0, i32 1, i64 [[EXT]]
-; CHECK-NEXT:    [[CMP_1:%.*]] = icmp ugt ptr [[GEP_EXT]], [[P]]
 ; CHECK-NEXT:    br i1 true, label [[THEN:%.*]], label [[ELSE:%.*]]
 ; CHECK:       then:
 ; CHECK-NEXT:    ret i1 false
 ; CHECK:       else:
 ; CHECK-NEXT:    tail call void @sink(ptr nonnull [[P]])
 ; CHECK-NEXT:    ret i1 true
 ;
 entry:

 define i1 @cnt_positive_from_branch_check_against_base_struct_ugt_with_zext(ptr %p, i32 %cnt) {
 ; CHECK-LABEL: @cnt_positive_from_branch_check_against_base_struct_ugt_with_zext(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt i32 [[CNT:%.*]], -1
 ; CHECK-NEXT:    br i1 [[CMP]], label [[CHECK:%.*]], label [[ELSE:%.*]]
 ; CHECK:       check:
 ; CHECK-NEXT:    [[EXT:%.*]] = zext i32 [[CNT]] to i64
 ; CHECK-NEXT:    [[GEP_EXT:%.*]] = getelementptr inbounds [[T:%.*]], ptr [[P:%.*]], i64 0, i32 1, i64 [[EXT]]
-; CHECK-NEXT:    [[CMP_1:%.*]] = icmp ugt ptr [[GEP_EXT]], [[P]]
 ; CHECK-NEXT:    br i1 true, label [[THEN:%.*]], label [[ELSE]]
 ; CHECK:       then:
 ; CHECK-NEXT:    ret i1 false
 ; CHECK:       else:
 ; CHECK-NEXT:    tail call void @sink(ptr nonnull [[P]])
 ; CHECK-NEXT:    ret i1 true
 ;
 entry:

 define i1 @cnt_not_known_positive_from_branch_check_against_base_struct_ugt_with_zext(ptr %p, i32 %cnt) {
 ; CHECK-LABEL: @cnt_not_known_positive_from_branch_check_against_base_struct_ugt_with_zext(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt i32 [[CNT:%.*]], -2
 ; CHECK-NEXT:    br i1 [[CMP]], label [[CHECK:%.*]], label [[ELSE:%.*]]
 ; CHECK:       check:
 ; CHECK-NEXT:    [[EXT:%.*]] = zext i32 [[CNT]] to i64
 ; CHECK-NEXT:    [[GEP_EXT:%.*]] = getelementptr inbounds [[T:%.*]], ptr [[P:%.*]], i64 0, i32 1, i64 [[EXT]]
-; CHECK-NEXT:    [[CMP_1:%.*]] = icmp ugt ptr [[GEP_EXT]], [[P]]
 ; CHECK-NEXT:    br i1 true, label [[THEN:%.*]], label [[ELSE]]
 ; CHECK:       then:
 ; CHECK-NEXT:    ret i1 false
 ; CHECK:       else:
 ; CHECK-NEXT:    tail call void @sink(ptr nonnull [[P]])
 ; CHECK-NEXT:    ret i1 true
 ;
 entry:
else:
   ret i1 1
 }
 
 define i1 @sge_2(i8 %idx) {
 ; CHECK-LABEL: @sge_2(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp sge i8 [[IDX:%.*]], 2
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[CMP]])
-; CHECK-NEXT:    [[T_1:%.*]] = icmp uge i8 [[IDX]], 2
-; CHECK-NEXT:    [[T_2:%.*]] = icmp uge i8 [[IDX]], 1
 ; CHECK-NEXT:    [[RES_1:%.*]] = xor i1 true, true
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp uge i8 [[IDX]], 3
 ; CHECK-NEXT:    [[RES_2:%.*]] = xor i1 [[RES_1]], [[C_1]]
-; CHECK-NEXT:    [[F_1:%.*]] = icmp ult i8 [[IDX]], 2
 ; CHECK-NEXT:    [[RES_3:%.*]] = xor i1 [[RES_2]], false
 ; CHECK-NEXT:    ret i1 [[RES_3]]
 ;
 entry:
   %cmp = icmp sge i8 %idx, 2
   call void @llvm.assume(i1 %cmp)
   %t.1 = icmp uge i8 %idx, 2
   %t.2 = icmp uge i8 %idx, 1
else:
   ret i32 10
 }
 
 define i1 @sgt_known_neg(i8 %idx) {
 ; CHECK-LABEL: @sgt_known_neg(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt i8 [[IDX:%.*]], -1
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[CMP]])
-; CHECK-NEXT:    [[T_1:%.*]] = icmp uge i8 [[IDX]], 0
 ; CHECK-NEXT:    [[T_2:%.*]] = icmp uge i8 [[IDX]], 1
 ; CHECK-NEXT:    [[RES_1:%.*]] = xor i1 true, [[T_2]]
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ugt i8 [[IDX]], -1
 ; CHECK-NEXT:    [[RES_2:%.*]] = xor i1 [[RES_1]], [[C_1]]
 ; CHECK-NEXT:    ret i1 [[RES_2]]
 ;
 entry:
   %cmp = icmp sgt i8 %idx, -1
   call void @llvm.assume(i1 %cmp)
   %t.1 = icmp uge i8 %idx, 0
   %t.2 = icmp uge i8 %idx, 1
   %res.1 = xor i1 %t.1, %t.2
   %c.1 = icmp ugt i8 %idx, -1
   %res.2 = xor i1 %res.1, %c.1
   ret i1 %res.2
 }
 
 define i1 @sgt_known_pos(i8 %idx) {
 ; CHECK-LABEL: @sgt_known_pos(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt i8 [[IDX:%.*]], 2
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[CMP]])
-; CHECK-NEXT:    [[T_1:%.*]] = icmp ugt i8 [[IDX]], 2
-; CHECK-NEXT:    [[T_2:%.*]] = icmp ugt i8 [[IDX]], 1
 ; CHECK-NEXT:    [[RES_1:%.*]] = xor i1 true, true
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ugt i8 [[IDX]], 3
 ; CHECK-NEXT:    [[RES_2:%.*]] = xor i1 [[RES_1]], [[C_1]]
 ; CHECK-NEXT:    ret i1 [[RES_2]]
 ;
 entry:
   %cmp = icmp sgt i8 %idx, 2
   call void @llvm.assume(i1 %cmp)
   %t.1 = icmp ugt i8 %idx, 2
   %t.2 = icmp ugt i8 %idx, 1
   %res.1 = xor i1 %t.1, %t.2
   %c.1 = icmp ugt i8 %idx, 3
   %res.2 = xor i1 %res.1, %c.1
   ret i1 %res.2
 }
 
 define i1 @sgt_to_ugt(i8 %a) {
 ; CHECK-LABEL: @sgt_to_ugt(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt i8 [[A:%.*]], 2
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[CMP]])
-; CHECK-NEXT:    [[T_1:%.*]] = icmp ugt i8 [[A]], 2
 ; CHECK-NEXT:    ret i1 true
 ;
 entry:
   %cmp = icmp sgt i8 %a, 2
   call void @llvm.assume(i1 %cmp)
   %t.1 = icmp ugt i8 %a, 2
   ret i1 %t.1
 }
 
 define i1 @sgt_to_ugt_less(i8 %a) {
 ; CHECK-LABEL: @sgt_to_ugt_less(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt i8 [[A:%.*]], 2
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[CMP]])
-; CHECK-NEXT:    [[T_1:%.*]] = icmp ugt i8 [[A]], 1
 ; CHECK-NEXT:    ret i1 true
 ;
 entry:
   %cmp = icmp sgt i8 %a, 2
   call void @llvm.assume(i1 %cmp)
   %t.1 = icmp ugt i8 %a, 1
   ret i1 %t.1
 }
 
 define i1 @sgt_to_ugt_var(i8 %a, i8 %b) {
 ; CHECK-LABEL: @sgt_to_ugt_var(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt i8 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    [[CMP_2:%.*]] = icmp sgt i8 [[B]], 0
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[CMP]])
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[CMP_2]])
-; CHECK-NEXT:    [[T_1:%.*]] = icmp ugt i8 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 true
 ;
 entry:
   %cmp = icmp sgt i8 %a, %b
   %cmp.2 = icmp sgt i8 %b, 0
   call void @llvm.assume(i1 %cmp)
   call void @llvm.assume(i1 %cmp.2)
   %t.1 = icmp ugt i8 %a, %b
entry:
   ret i1 %c.1
 }
 
 define i1 @slt_first_op_known_pos(i8 %idx) {
 ; CHECK-LABEL: @slt_first_op_known_pos(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i8 2, [[IDX:%.*]]
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[CMP]])
-; CHECK-NEXT:    [[T_1:%.*]] = icmp ult i8 2, [[IDX]]
-; CHECK-NEXT:    [[T_2:%.*]] = icmp ult i8 1, [[IDX]]
 ; CHECK-NEXT:    [[RES_1:%.*]] = xor i1 true, true
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ult i8 3, [[IDX]]
 ; CHECK-NEXT:    [[RES_2:%.*]] = xor i1 [[RES_1]], [[C_1]]
 ; CHECK-NEXT:    ret i1 [[RES_2]]
 ;
 entry:
   %cmp = icmp slt i8 2, %idx
   call void @llvm.assume(i1 %cmp)

llvm/test/Transforms/ConstraintElimination/transfer-unsigned-facts-to-signed.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -passes=constraint-elimination -S %s | FileCheck %s
 
 define i1 @idx_known_positive_via_len_1(i8 %len, i8 %idx) {
 ; CHECK-LABEL: @idx_known_positive_via_len_1(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[LEN_POS:%.*]] = icmp sge i8 [[LEN:%.*]], 0
 ; CHECK-NEXT:    [[IDX_ULT_LEN:%.*]] = icmp ult i8 [[IDX:%.*]], [[LEN]]
 ; CHECK-NEXT:    [[AND_1:%.*]] = and i1 [[LEN_POS]], [[IDX_ULT_LEN]]
 ; CHECK-NEXT:    br i1 [[AND_1]], label [[THEN_1:%.*]], label [[ELSE:%.*]]
 ; CHECK:       then.1:
-; CHECK-NEXT:    [[T_1:%.*]] = icmp ult i8 [[IDX]], [[LEN]]
-; CHECK-NEXT:    [[T_2:%.*]] = icmp sge i8 [[IDX]], 0
 ; CHECK-NEXT:    [[R_1:%.*]] = xor i1 true, true
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp sge i8 [[IDX]], 1
 ; CHECK-NEXT:    [[R_2:%.*]] = xor i1 [[R_1]], [[C_1]]
-; CHECK-NEXT:    [[C_2:%.*]] = icmp sge i8 [[LEN]], 1
 ; CHECK-NEXT:    [[R_3:%.*]] = xor i1 [[R_2]], true
 ; CHECK-NEXT:    ret i1 [[R_3]]
 ; CHECK:       else:
 ; CHECK-NEXT:    [[C_3:%.*]] = icmp sge i8 [[IDX]], 0
 ; CHECK-NEXT:    ret i1 [[C_3]]
 ;
 entry:
   %len.pos = icmp sge i8 %len, 0

 define i1 @idx_known_positive_via_len_2(i8 %len, i8 %idx) {
 ; CHECK-LABEL: @idx_known_positive_via_len_2(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[IDX_ULT_LEN:%.*]] = icmp ult i8 [[IDX:%.*]], [[LEN:%.*]]
 ; CHECK-NEXT:    [[LEN_POS:%.*]] = icmp sge i8 [[LEN]], 0
 ; CHECK-NEXT:    [[AND_1:%.*]] = and i1 [[IDX_ULT_LEN]], [[LEN_POS]]
 ; CHECK-NEXT:    br i1 [[AND_1]], label [[THEN_1:%.*]], label [[ELSE:%.*]]
 ; CHECK:       then.1:
-; CHECK-NEXT:    [[T_1:%.*]] = icmp ult i8 [[IDX]], [[LEN]]
-; CHECK-NEXT:    [[T_2:%.*]] = icmp sge i8 [[IDX]], 0
 ; CHECK-NEXT:    [[R_1:%.*]] = xor i1 true, true
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp sge i8 [[IDX]], 1
 ; CHECK-NEXT:    [[R_2:%.*]] = xor i1 [[R_1]], [[C_1]]
-; CHECK-NEXT:    [[C_2:%.*]] = icmp sge i8 [[LEN]], 1
 ; CHECK-NEXT:    [[R_3:%.*]] = xor i1 [[R_2]], true
 ; CHECK-NEXT:    ret i1 [[R_3]]
 ; CHECK:       else:
 ; CHECK-NEXT:    [[C_3:%.*]] = icmp sge i8 [[IDX]], 0
 ; CHECK-NEXT:    ret i1 [[C_3]]
 ;
 entry:
   %idx.ult.len  = icmp ult i8 %idx, %len

 define i1 @idx_not_known_positive_via_len_uge(i8 %len, i8 %idx) {
 ; CHECK-LABEL: @idx_not_known_positive_via_len_uge(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[LEN_POS:%.*]] = icmp uge i8 [[LEN:%.*]], 0
 ; CHECK-NEXT:    [[IDX_ULT_LEN:%.*]] = icmp ult i8 [[IDX:%.*]], [[LEN]]
 ; CHECK-NEXT:    [[AND_1:%.*]] = and i1 [[LEN_POS]], [[IDX_ULT_LEN]]
 ; CHECK-NEXT:    br i1 [[AND_1]], label [[THEN_1:%.*]], label [[ELSE:%.*]]
 ; CHECK:       then.1:
-; CHECK-NEXT:    [[C_1:%.*]] = icmp ult i8 [[IDX]], [[LEN]]
 ; CHECK-NEXT:    [[C_2:%.*]] = icmp sge i8 [[IDX]], 0
 ; CHECK-NEXT:    [[R_1:%.*]] = xor i1 true, [[C_2]]
 ; CHECK-NEXT:    [[C_3:%.*]] = icmp sge i8 [[IDX]], 1
 ; CHECK-NEXT:    [[R_2:%.*]] = xor i1 [[R_1]], [[C_3]]
 ; CHECK-NEXT:    [[C_4:%.*]] = icmp sge i8 [[LEN]], 1
 ; CHECK-NEXT:    [[R_3:%.*]] = xor i1 [[R_2]], [[C_4]]
 ; CHECK-NEXT:    ret i1 [[R_3]]
 ; CHECK:       else:

 
 ; There's no information about %len which could be used to determine %len >=s 0.
 define i1 @idx_not_known_positive_via_len(i8 %len, i8 %idx) {
 ; CHECK-LABEL: @idx_not_known_positive_via_len(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[IDX_ULT_LEN:%.*]] = icmp ult i8 [[IDX:%.*]], [[LEN:%.*]]
 ; CHECK-NEXT:    br i1 [[IDX_ULT_LEN]], label [[THEN_1:%.*]], label [[ELSE:%.*]]
 ; CHECK:       then.1:
-; CHECK-NEXT:    [[C_1:%.*]] = icmp ult i8 [[IDX]], [[LEN]]
 ; CHECK-NEXT:    [[C_2:%.*]] = icmp sge i8 [[IDX]], 0
 ; CHECK-NEXT:    [[R_1:%.*]] = xor i1 true, [[C_2]]
 ; CHECK-NEXT:    [[C_3:%.*]] = icmp sge i8 [[IDX]], 1
 ; CHECK-NEXT:    [[R_2:%.*]] = xor i1 [[R_1]], [[C_3]]
 ; CHECK-NEXT:    [[C_4:%.*]] = icmp sge i8 [[LEN]], 1
 ; CHECK-NEXT:    [[R_3:%.*]] = xor i1 [[R_2]], [[C_4]]
 ; CHECK-NEXT:    ret i1 [[R_3]]
 ; CHECK:       else:
else:
   ret i1 %c.5
 }
 
 define i1 @ult_signed_pos_constant(i8 %a) {
 ; CHECK-LABEL: @ult_signed_pos_constant(
 ; CHECK-NEXT:    [[A_ULT_4:%.*]] = icmp ult i8 [[A:%.*]], 4
 ; CHECK-NEXT:    br i1 [[A_ULT_4]], label [[THEN:%.*]], label [[ELSE:%.*]]
 ; CHECK:       then:
-; CHECK-NEXT:    [[T_0:%.*]] = icmp sge i8 [[A]], 0
-; CHECK-NEXT:    [[T_1:%.*]] = icmp slt i8 [[A]], 4
 ; CHECK-NEXT:    [[RES_1:%.*]] = xor i1 true, true
-; CHECK-NEXT:    [[C_0:%.*]] = icmp slt i8 [[A]], 5
 ; CHECK-NEXT:    [[RES_2:%.*]] = xor i1 [[RES_1]], true
 ; CHECK-NEXT:    ret i1 [[RES_2]]
 ; CHECK:       else:
 ; CHECK-NEXT:    [[C_2:%.*]] = icmp sge i8 [[A]], 0
 ; CHECK-NEXT:    [[C_3:%.*]] = icmp slt i8 [[A]], 4
 ; CHECK-NEXT:    [[RES_3:%.*]] = xor i1 [[C_2]], [[C_3]]
 ; CHECK-NEXT:    [[C_4:%.*]] = icmp slt i8 [[A]], 5
 ; CHECK-NEXT:    [[RES_4:%.*]] = xor i1 [[RES_3]], [[C_4]]

llvm/test/Transforms/ConstraintElimination/uge.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -passes=constraint-elimination -S %s | FileCheck %s
 
 declare void @use(i1)
 
 define void @test_1_variable_constraint(i8 %x, i8 %y, i8 %z) {
 ; CHECK-LABEL: @test_1_variable_constraint(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp uge i8 [[X:%.*]], [[Y:%.*]]
 ; CHECK-NEXT:    br i1 [[C_1]], label [[BB1:%.*]], label [[BB2:%.*]]
 ; CHECK:       bb1:
-; CHECK-NEXT:    [[T_1:%.*]] = icmp uge i8 [[X]], [[Y]]
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    [[C_2:%.*]] = icmp uge i8 [[X]], 10
 ; CHECK-NEXT:    call void @use(i1 [[C_2]])
 ; CHECK-NEXT:    [[C_3:%.*]] = icmp uge i8 [[Y]], [[X]]
 ; CHECK-NEXT:    call void @use(i1 [[C_3]])
 ; CHECK-NEXT:    [[C_4:%.*]] = icmp uge i8 10, [[X]]
 ; CHECK-NEXT:    call void @use(i1 [[C_4]])
 ; CHECK-NEXT:    ret void
 ; CHECK:       bb2:
-; CHECK-NEXT:    [[T_2:%.*]] = icmp uge i8 [[Y]], [[X]]
 ; CHECK-NEXT:    call void @use(i1 true)
-; CHECK-NEXT:    [[F_1:%.*]] = icmp uge i8 [[X]], [[Y]]
 ; CHECK-NEXT:    call void @use(i1 false)
 ; CHECK-NEXT:    [[C_5:%.*]] = icmp uge i8 [[X]], 10
 ; CHECK-NEXT:    call void @use(i1 [[C_5]])
 ; CHECK-NEXT:    [[C_6:%.*]] = icmp uge i8 10, [[X]]
 ; CHECK-NEXT:    call void @use(i1 [[C_6]])
 ; CHECK-NEXT:    ret void
 ;
 entry:

 }
 
 define void @test_1_constant_constraint(i8 %x) {
 ; CHECK-LABEL: @test_1_constant_constraint(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp uge i8 [[X:%.*]], 10
 ; CHECK-NEXT:    br i1 [[C_1]], label [[BB1:%.*]], label [[BB2:%.*]]
 ; CHECK:       bb1:
-; CHECK-NEXT:    [[T_1:%.*]] = icmp uge i8 [[X]], 10
 ; CHECK-NEXT:    call void @use(i1 true)
-; CHECK-NEXT:    [[T_2:%.*]] = icmp uge i8 [[X]], 9
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    [[C_2:%.*]] = icmp uge i8 [[X]], 11
 ; CHECK-NEXT:    call void @use(i1 [[C_2]])
 ; CHECK-NEXT:    [[C_4:%.*]] = icmp uge i8 10, [[X]]
 ; CHECK-NEXT:    call void @use(i1 [[C_4]])
 ; CHECK-NEXT:    ret void
 ; CHECK:       bb2:
-; CHECK-NEXT:    [[T_3:%.*]] = icmp uge i8 11, [[X]]
 ; CHECK-NEXT:    call void @use(i1 true)
-; CHECK-NEXT:    [[F_1:%.*]] = icmp uge i8 [[X]], 10
 ; CHECK-NEXT:    call void @use(i1 false)
-; CHECK-NEXT:    [[F_1_1:%.*]] = icmp uge i8 [[X]], 10
 ; CHECK-NEXT:    call void @use(i1 false)
 ; CHECK-NEXT:    [[C_5:%.*]] = icmp uge i8 [[X]], 9
 ; CHECK-NEXT:    call void @use(i1 [[C_5]])
 ; CHECK-NEXT:    [[C_6:%.*]] = icmp uge i8 1, [[X]]
 ; CHECK-NEXT:    call void @use(i1 [[C_6]])
 ; CHECK-NEXT:    ret void
 ;
 entry:

 ; CHECK-LABEL: @test1(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp uge i8 [[X:%.*]], [[Y:%.*]]
 ; CHECK-NEXT:    br i1 [[C_1]], label [[BB1:%.*]], label [[EXIT:%.*]]
 ; CHECK:       bb1:
 ; CHECK-NEXT:    [[C_2:%.*]] = icmp uge i8 [[Y]], [[Z:%.*]]
 ; CHECK-NEXT:    br i1 [[C_2]], label [[BB2:%.*]], label [[EXIT]]
 ; CHECK:       bb2:
-; CHECK-NEXT:    [[C_3:%.*]] = icmp uge i8 [[X]], [[Z]]
 ; CHECK-NEXT:    br i1 true, label [[BB3:%.*]], label [[EXIT]]
 ; CHECK:       bb3:
 ; CHECK-NEXT:    ret i8 10
 ; CHECK:       exit:
 ; CHECK-NEXT:    ret i8 20
 ;
 entry:
   %c.1 = icmp uge i8 %x, %y

 ; CHECK-LABEL: @test4(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp uge i8 [[X:%.*]], [[Y:%.*]]
 ; CHECK-NEXT:    br i1 [[C_1]], label [[BB1:%.*]], label [[EXIT:%.*]]
 ; CHECK:       bb1:
 ; CHECK-NEXT:    [[C_2:%.*]] = icmp uge i8 [[Y]], [[Z:%.*]]
 ; CHECK-NEXT:    br i1 [[C_2]], label [[BB2:%.*]], label [[EXIT]]
 ; CHECK:       bb2:
-; CHECK-NEXT:    [[T_1:%.*]] = icmp uge i8 [[X]], [[Z]]
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    [[U_1:%.*]] = icmp eq i8 [[X]], [[Z]]
 ; CHECK-NEXT:    call void @use(i1 [[U_1]])
 ; CHECK-NEXT:    ret i8 10
 ; CHECK:       exit:
 ; CHECK-NEXT:    ret i8 20
 ;
 entry:

llvm/test/Transforms/ConstraintElimination/ugt-ule.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -passes=constraint-elimination -S %s | FileCheck %s
 
 declare void @use(i1)
 
 define void @test(ptr %m, ptr %ptr) {
 ; CHECK-LABEL: @test(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[CMP_1:%.*]] = icmp ult ptr [[M:%.*]], [[PTR:%.*]]
 ; CHECK-NEXT:    br i1 [[CMP_1]], label [[BB_1:%.*]], label [[BB_2:%.*]]
 ; CHECK:       bb.1:
-; CHECK-NEXT:    [[CMP_2:%.*]] = icmp uge ptr [[M]], [[PTR]]
 ; CHECK-NEXT:    call void @use(i1 false)
 ; CHECK-NEXT:    ret void
 ; CHECK:       bb.2:
 ; CHECK-NEXT:    br label [[BB_2_NEXT:%.*]]
 ; CHECK:       bb.2.next:
-; CHECK-NEXT:    [[CMP_3:%.*]] = icmp uge ptr [[M]], [[PTR]]
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %cmp.1 = icmp ult ptr %m, %ptr
   br i1 %cmp.1, label %bb.1, label %bb.2
 
 bb.1:

llvm/test/Transforms/ConstraintElimination/ule.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -passes=constraint-elimination -S %s | FileCheck %s
 
 declare void @use(i1)
 
 define void @test_1_variable_constraint(i8 %x, i8 %y, i8 %z) {
 ; CHECK-LABEL: @test_1_variable_constraint(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ule i8 [[X:%.*]], [[Y:%.*]]
 ; CHECK-NEXT:    br i1 [[C_1]], label [[BB1:%.*]], label [[BB2:%.*]]
 ; CHECK:       bb1:
-; CHECK-NEXT:    [[T_1:%.*]] = icmp ule i8 [[X]], [[Y]]
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    [[C_2:%.*]] = icmp ule i8 [[X]], 10
 ; CHECK-NEXT:    call void @use(i1 [[C_2]])
 ; CHECK-NEXT:    [[C_3:%.*]] = icmp ule i8 [[Y]], [[X]]
 ; CHECK-NEXT:    call void @use(i1 [[C_3]])
 ; CHECK-NEXT:    [[C_4:%.*]] = icmp ule i8 10, [[X]]
 ; CHECK-NEXT:    call void @use(i1 [[C_4]])
 ; CHECK-NEXT:    ret void
 ; CHECK:       bb2:
-; CHECK-NEXT:    [[T_2:%.*]] = icmp ule i8 [[Y]], [[X]]
 ; CHECK-NEXT:    call void @use(i1 true)
-; CHECK-NEXT:    [[F_1:%.*]] = icmp ule i8 [[X]], [[Y]]
 ; CHECK-NEXT:    call void @use(i1 false)
 ; CHECK-NEXT:    [[C_5:%.*]] = icmp ule i8 [[X]], 10
 ; CHECK-NEXT:    call void @use(i1 [[C_5]])
 ; CHECK-NEXT:    [[C_6:%.*]] = icmp ule i8 10, [[X]]
 ; CHECK-NEXT:    call void @use(i1 [[C_6]])
 ; CHECK-NEXT:    ret void
 ;
 entry:

 }
 
 define void @test_1_constant_constraint(i8 %x) {
 ; CHECK-LABEL: @test_1_constant_constraint(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ule i8 [[X:%.*]], 10
 ; CHECK-NEXT:    br i1 [[C_1]], label [[BB1:%.*]], label [[BB2:%.*]]
 ; CHECK:       bb1:
-; CHECK-NEXT:    [[T_1:%.*]] = icmp ule i8 [[X]], 10
 ; CHECK-NEXT:    call void @use(i1 true)
-; CHECK-NEXT:    [[T_2:%.*]] = icmp ule i8 [[X]], 11
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    [[C_2:%.*]] = icmp ule i8 [[X]], 9
 ; CHECK-NEXT:    call void @use(i1 [[C_2]])
 ; CHECK-NEXT:    [[C_4:%.*]] = icmp ule i8 10, [[X]]
 ; CHECK-NEXT:    call void @use(i1 [[C_4]])
 ; CHECK-NEXT:    ret void
 ; CHECK:       bb2:
-; CHECK-NEXT:    [[T_3:%.*]] = icmp ule i8 10, [[X]]
 ; CHECK-NEXT:    call void @use(i1 true)
-; CHECK-NEXT:    [[F_1:%.*]] = icmp ule i8 [[X]], 9
 ; CHECK-NEXT:    call void @use(i1 false)
-; CHECK-NEXT:    [[F_1_1:%.*]] = icmp ule i8 [[X]], 10
 ; CHECK-NEXT:    call void @use(i1 false)
 ; CHECK-NEXT:    [[C_5:%.*]] = icmp ule i8 [[X]], 11
 ; CHECK-NEXT:    call void @use(i1 [[C_5]])
 ; CHECK-NEXT:    [[C_6:%.*]] = icmp ule i8 12, [[X]]
 ; CHECK-NEXT:    call void @use(i1 [[C_6]])
 ; CHECK-NEXT:    ret void
 ;
 entry:

 ; CHECK-LABEL: @test1(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ule i8 [[X:%.*]], [[Y:%.*]]
 ; CHECK-NEXT:    br i1 [[C_1]], label [[BB1:%.*]], label [[EXIT:%.*]]
 ; CHECK:       bb1:
 ; CHECK-NEXT:    [[C_2:%.*]] = icmp ule i8 [[Y]], [[Z:%.*]]
 ; CHECK-NEXT:    br i1 [[C_2]], label [[BB2:%.*]], label [[EXIT]]
 ; CHECK:       bb2:
-; CHECK-NEXT:    [[C_3:%.*]] = icmp ule i8 [[X]], [[Z]]
 ; CHECK-NEXT:    br i1 true, label [[BB3:%.*]], label [[EXIT]]
 ; CHECK:       bb3:
 ; CHECK-NEXT:    ret i8 10
 ; CHECK:       exit:
 ; CHECK-NEXT:    ret i8 20
 ;
 entry:
   %c.1 = icmp ule i8 %x, %y

 ; CHECK-LABEL: @test4(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ule i8 [[X:%.*]], [[Y:%.*]]
 ; CHECK-NEXT:    br i1 [[C_1]], label [[BB1:%.*]], label [[EXIT:%.*]]
 ; CHECK:       bb1:
 ; CHECK-NEXT:    [[C_2:%.*]] = icmp ule i8 [[Y]], [[Z:%.*]]
 ; CHECK-NEXT:    br i1 [[C_2]], label [[BB2:%.*]], label [[EXIT]]
 ; CHECK:       bb2:
-; CHECK-NEXT:    [[T_1:%.*]] = icmp ule i8 [[X]], [[Z]]
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    [[U_1:%.*]] = icmp eq i8 [[X]], [[Z]]
 ; CHECK-NEXT:    call void @use(i1 [[U_1]])
 ; CHECK-NEXT:    ret i8 10
 ; CHECK:       exit:
 ; CHECK-NEXT:    ret i8 20
 ;
 entry:

llvm/test/Transforms/ConstraintElimination/uses-in-different-blocks.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -passes=constraint-elimination -S %s | FileCheck %s
 
 define i1 @test_conds_single_use_in_different_blocks(i8 %x) {
 ; CHECK-LABEL: @test_conds_single_use_in_different_blocks(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ugt i8 [[X:%.*]], 10
-; CHECK-NEXT:    [[T_1:%.*]] = icmp ugt i8 [[X]], 5
 ; CHECK-NEXT:    [[C_2:%.*]] = icmp ugt i8 [[X]], 5
 ; CHECK-NEXT:    br i1 [[C_1]], label [[THEN:%.*]], label [[ELSE:%.*]]
 ; CHECK:       then:
 ; CHECK-NEXT:    ret i1 true
 ; CHECK:       else:
 ; CHECK-NEXT:    ret i1 [[C_2]]
 ;
 entry:
else:
   ret i1 %c.2
 }
 
 
 define i1 @test_conds_single_use_in_different_blocks_2(i8 %x, i8 %y) {
 ; CHECK-LABEL: @test_conds_single_use_in_different_blocks_2(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ugt i8 [[X:%.*]], 10
-; CHECK-NEXT:    [[T_1:%.*]] = icmp ugt i8 [[Y:%.*]], 5
-; CHECK-NEXT:    [[C_2:%.*]] = icmp ugt i8 [[Y]], [[X]]
+; CHECK-NEXT:    [[C_2:%.*]] = icmp ugt i8 [[Y:%.*]], [[X]]
 ; CHECK-NEXT:    [[C_3:%.*]] = icmp ugt i8 [[Y]], 5
 ; CHECK-NEXT:    br i1 [[C_1]], label [[THEN_1:%.*]], label [[ELSE:%.*]]
 ; CHECK:       then.1:
 ; CHECK-NEXT:    br i1 [[C_2]], label [[THEN_2:%.*]], label [[ELSE]]
 ; CHECK:       then.2:
 ; CHECK-NEXT:    ret i1 true
 ; CHECK:       else:
 ; CHECK-NEXT:    ret i1 [[C_3]]

 ; %entry.
 define i1 @test_conds_multiple_uses_in_different_blocks_2(i8 %x, i8 %y) {
 ; CHECK-LABEL: @test_conds_multiple_uses_in_different_blocks_2(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ugt i8 [[X:%.*]], 10
 ; CHECK-NEXT:    [[T_1:%.*]] = icmp ugt i8 [[Y:%.*]], 5
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[T_1]])
 ; CHECK-NEXT:    [[C_2:%.*]] = icmp ugt i8 [[Y]], [[X]]
-; CHECK-NEXT:    [[C_3:%.*]] = icmp ugt i8 [[Y]], 5
 ; CHECK-NEXT:    br i1 [[C_1]], label [[THEN_1:%.*]], label [[ELSE:%.*]]
 ; CHECK:       then.1:
 ; CHECK-NEXT:    br i1 [[C_2]], label [[THEN_2:%.*]], label [[ELSE]]
 ; CHECK:       then.2:
 ; CHECK-NEXT:    ret i1 true
 ; CHECK:       else:
 ; CHECK-NEXT:    ret i1 true
 ;

llvm/test/Transforms/ConstraintElimination/vector-compares.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -passes=constraint-elimination -S %s | FileCheck %s
 
 declare void @use(i1)
 
 ; Make sure we do not crash when trying to inject info about vector values from SCEV.
 define void @test_vector_iv(i32 %x, i1 %c) {
 ; CHECK-LABEL: @test_vector_iv(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br i1 [[C:%.*]], label [[PRE:%.*]], label [[BB2:%.*]]
 ; CHECK:       pre:
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ule i32 [[X:%.*]], 10
 ; CHECK-NEXT:    br i1 [[C_1]], label [[LOOP:%.*]], label [[BB2]]
 ; CHECK:       loop:
 ; CHECK-NEXT:    [[IV:%.*]] = phi <4 x i8> [ zeroinitializer, [[PRE]] ], [ [[IV_NEXT:%.*]], [[LOOP]] ]
-; CHECK-NEXT:    [[T_1:%.*]] = icmp ule i32 [[X]], 10
 ; CHECK-NEXT:    call void @use(i1 true)
-; CHECK-NEXT:    [[F_1:%.*]] = icmp ugt i32 [[X]], 10
 ; CHECK-NEXT:    call void @use(i1 false)
 ; CHECK-NEXT:    [[C_2:%.*]] = icmp ule i32 [[X]], 9
 ; CHECK-NEXT:    call void @use(i1 [[C_2]])
 ; CHECK-NEXT:    [[C_3:%.*]] = icmp ugt i32 [[X]], 9
 ; CHECK-NEXT:    call void @use(i1 [[C_3]])
 ; CHECK-NEXT:    [[IV_NEXT]] = add nuw nsw <4 x i8> [[IV]], <i8 1, i8 1, i8 1, i8 1>
 ; CHECK-NEXT:    [[E:%.*]] = extractelement <4 x i8> [[IV_NEXT]], i8 2
 ; CHECK-NEXT:    [[EC:%.*]] = icmp eq i8 [[E]], 100
 ; CHECK-NEXT:    br i1 [[EC]], label [[EXIT:%.*]], label [[LOOP]]
 ; CHECK:       exit:
-; CHECK-NEXT:    [[C_4:%.*]] = icmp ule i32 [[X]], 10
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    ret void
 ; CHECK:       bb2:
 ; CHECK-NEXT:    [[C_5:%.*]] = icmp ugt i32 [[X]], 10
 ; CHECK-NEXT:    call void @use(i1 [[C_5]])
 ; CHECK-NEXT:    ret void
 ;
 entry:

llvm/test/Transforms/ConstraintElimination/wrapping-math.ll

 
 define i1 @wrapping_add_known_1(i8 %a) {
 ; CHECK-LABEL: @wrapping_add_known_1(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[PRE:%.*]] = icmp eq i8 [[A:%.*]], 1
 ; CHECK-NEXT:    br i1 [[PRE]], label [[THEN:%.*]], label [[ELSE:%.*]]
 ; CHECK:       then:
 ; CHECK-NEXT:    [[SUB_1:%.*]] = add i8 [[A]], -1
-; CHECK-NEXT:    [[C_1:%.*]] = icmp eq i8 [[SUB_1]], 0
 ; CHECK-NEXT:    ret i1 true
 ; CHECK:       else:
 ; CHECK-NEXT:    [[SUB_2:%.*]] = add i8 [[A]], -1
 ; CHECK-NEXT:    [[C_2:%.*]] = icmp eq i8 [[SUB_2]], 0
 ; CHECK-NEXT:    ret i1 [[C_2]]
 ;
 entry:
   %pre = icmp eq i8 %a, 1

 ; CHECK-LABEL: @test_48253_eq_ne(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[CMP_1:%.*]] = icmp ne i8 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    [[CMP_2:%.*]] = icmp eq i8 [[B]], 0
 ; CHECK-NEXT:    [[OR:%.*]] = or i1 [[CMP_1]], [[CMP_2]]
 ; CHECK-NEXT:    br i1 [[OR]], label [[EXIT_1:%.*]], label [[IF_END:%.*]]
 ; CHECK:       if.end:
 ; CHECK-NEXT:    [[SUB_1:%.*]] = add i8 [[B]], -1
-; CHECK-NEXT:    [[T_1:%.*]] = icmp ult i8 [[SUB_1]], [[A]]
 ; CHECK-NEXT:    [[SUB_2:%.*]] = add i8 [[B]], -2
 ; CHECK-NEXT:    [[C_2:%.*]] = icmp ult i8 [[SUB_2]], [[A]]
 ; CHECK-NEXT:    [[XOR_1:%.*]] = xor i1 true, [[C_2]]
 ; CHECK-NEXT:    ret i1 [[XOR_1]]
 ; CHECK:       exit.1:
 ; CHECK-NEXT:    [[SUB_3:%.*]] = add i8 [[B]], -1
 ; CHECK-NEXT:    [[C_3:%.*]] = icmp ult i8 [[SUB_3]], [[A]]
 ; CHECK-NEXT:    [[SUB_4:%.*]] = add i8 [[B]], -2

 ; CHECK-NEXT:    [[AND:%.*]] = and i1 [[CMP_1]], [[CMP_2]]
 ; CHECK-NEXT:    [[SUB_1:%.*]] = add i8 [[A]], -1
 ; CHECK-NEXT:    [[SUB_2:%.*]] = add i8 [[A]], -2
 ; CHECK-NEXT:    [[SUB_3:%.*]] = add i8 [[A]], -20
 ; CHECK-NEXT:    [[SUB_4:%.*]] = add i8 [[A]], 21
 ; CHECK-NEXT:    [[ADD_1:%.*]] = add i8 [[A]], 1
 ; CHECK-NEXT:    br i1 [[AND]], label [[IF_END:%.*]], label [[EXIT_1:%.*]]
 ; CHECK:       if.end:
-; CHECK-NEXT:    [[T_1:%.*]] = icmp ult i8 [[SUB_1]], [[B]]
-; CHECK-NEXT:    [[T_2:%.*]] = icmp ult i8 [[SUB_2]], [[B]]
 ; CHECK-NEXT:    [[XOR_1:%.*]] = xor i1 true, true
-; CHECK-NEXT:    [[T_3:%.*]] = icmp ult i8 [[SUB_3]], [[B]]
 ; CHECK-NEXT:    [[XOR_2:%.*]] = xor i1 [[XOR_1]], true
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ult i8 [[SUB_4]], [[B]]
 ; CHECK-NEXT:    [[XOR_3:%.*]] = xor i1 [[XOR_2]], [[C_1]]
 ; CHECK-NEXT:    [[C_2:%.*]] = icmp ult i8 [[ADD_1]], [[B]]
 ; CHECK-NEXT:    [[XOR_4:%.*]] = xor i1 [[XOR_3]], [[C_2]]
 ; CHECK-NEXT:    ret i1 [[XOR_4]]
 ; CHECK:       exit.1:
 ; CHECK-NEXT:    [[C_3:%.*]] = icmp ult i8 [[SUB_1]], [[B]]

 
 define i1 @wrapping_add_known_1_add_nuw(i8 %a) {
 ; CHECK-LABEL: @wrapping_add_known_1_add_nuw(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[PRE:%.*]] = icmp eq i8 [[A:%.*]], 1
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[PRE]])
 ; CHECK-NEXT:    [[SUB_1:%.*]] = add i8 [[A]], -1
 ; CHECK-NEXT:    [[ADD:%.*]] = add nuw i8 [[SUB_1]], 10
-; CHECK-NEXT:    [[T_1:%.*]] = icmp uge i8 [[ADD]], 10
-; CHECK-NEXT:    [[T_2:%.*]] = icmp ule i8 [[ADD]], 10
 ; CHECK-NEXT:    [[RES_1:%.*]] = xor i1 true, true
-; CHECK-NEXT:    [[F_1:%.*]] = icmp ult i8 [[ADD]], 10
 ; CHECK-NEXT:    [[RES_2:%.*]] = xor i1 [[RES_1]], false
 ; CHECK-NEXT:    ret i1 [[RES_2]]
 ;
 entry:
   %pre = icmp eq i8 %a, 1
   call void @llvm.assume(i1 %pre)
   %sub.1 = add i8 %a, -1
   %add = add nuw i8 %sub.1, 10
   %t.1 = icmp uge i8 %add, 10
   %t.2 = icmp ule i8 %add, 10
   %res.1 = xor i1 %t.1, %t.2
   %f.1 = icmp ult i8 %add, 10
   %res.2 = xor i1 %res.1, %f.1
   ret i1 %res.2
 }
 
 define i1 @add_nuw_wrapping_add_known_1(i8 %a) {
 ; CHECK-LABEL: @add_nuw_wrapping_add_known_1(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[PRE:%.*]] = icmp eq i8 [[A:%.*]], 1
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[PRE]])
 ; CHECK-NEXT:    [[ADD:%.*]] = add nuw i8 [[A]], 10
 ; CHECK-NEXT:    [[SUB_1:%.*]] = add i8 [[ADD]], -1
-; CHECK-NEXT:    [[T_1:%.*]] = icmp uge i8 [[SUB_1]], 10
-; CHECK-NEXT:    [[T_2:%.*]] = icmp ule i8 [[SUB_1]], 10
 ; CHECK-NEXT:    [[RES_1:%.*]] = xor i1 true, true
-; CHECK-NEXT:    [[F_1:%.*]] = icmp ult i8 [[SUB_1]], 10
 ; CHECK-NEXT:    [[RES_2:%.*]] = xor i1 [[RES_1]], false
 ; CHECK-NEXT:    ret i1 [[RES_2]]
 ;
 entry:
   %pre = icmp eq i8 %a, 1
   call void @llvm.assume(i1 %pre)
   %add = add nuw i8 %a, 10
   %sub.1 = add i8 %add, -1

llvm/test/Transforms/ConstraintElimination/zext-for-per-formula-reasoning.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -passes=constraint-elimination -S %s | FileCheck %s
 
 declare void @llvm.assume(i1)
 
 define i1 @test(i8 %x, i8 %y) {
 ; CHECK-LABEL: @test(
 ; CHECK-NEXT:    [[ADD:%.*]] = add nuw nsw i8 [[X:%.*]], [[Y:%.*]]
 ; CHECK-NEXT:    [[CMP_0:%.*]] = icmp uge i8 [[ADD]], 10
 ; CHECK-NEXT:    tail call void @llvm.assume(i1 [[CMP_0]])
 ; CHECK-NEXT:    [[EXT:%.*]] = zext i8 [[X]] to i16
-; CHECK-NEXT:    [[T_1:%.*]] = icmp uge i16 [[EXT]], 0
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp uge i16 [[EXT]], 1
 ; CHECK-NEXT:    [[RES:%.*]] = xor i1 true, [[C_1]]
 ; CHECK-NEXT:    ret i1 [[RES]]
 ;
   %add = add nuw nsw i8 %x, %y
   %cmp.0 = icmp uge i8 %add, 10
   tail call void @llvm.assume(i1 %cmp.0)
   %ext = zext i8 %x to i16
   %t.1 = icmp uge i16 %ext, 0
   %c.1 = icmp uge i16 %ext, 1
   %res = xor i1 %t.1, %c.1
   ret i1 %res
 }
 
 define i1 @test2(i8 %x, i8 %y) {
 ; CHECK-LABEL: @test2(
 ; CHECK-NEXT:    [[ADD:%.*]] = add nuw nsw i8 [[X:%.*]], [[Y:%.*]]
 ; CHECK-NEXT:    [[CMP_0:%.*]] = icmp uge i8 [[ADD]], 0
 ; CHECK-NEXT:    tail call void @llvm.assume(i1 [[CMP_0]])
 ; CHECK-NEXT:    [[EXT:%.*]] = zext i8 [[X]] to i16
 ; CHECK-NEXT:    [[ADD_1:%.*]] = add nuw nsw i16 [[EXT]], 1
-; CHECK-NEXT:    [[T_1:%.*]] = icmp uge i16 [[ADD_1]], 1
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp uge i16 [[ADD_1]], 2
-; CHECK-NEXT:    [[F_1:%.*]] = icmp ult i16 [[ADD_1]], 1
 ; CHECK-NEXT:    [[RES_1:%.*]] = xor i1 true, [[C_1]]
 ; CHECK-NEXT:    [[RES_2:%.*]] = xor i1 [[RES_1]], false
 ; CHECK-NEXT:    [[C_2:%.*]] = icmp sge i16 [[ADD_1]], 1
 ; CHECK-NEXT:    [[RES_3:%.*]] = xor i1 [[RES_2]], [[C_2]]
 ; CHECK-NEXT:    ret i1 [[RES_3]]
 ;
   %add = add nuw nsw i8 %x, %y
   %cmp.0 = icmp uge i8 %add, 0

 define i1 @gep_zext_idx(ptr %p, i8 %cnt, i8 %off) {
 ; CHECK-LABEL: @gep_zext_idx(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[ADD:%.*]] = add nuw nsw i8 [[CNT:%.*]], [[OFF:%.*]]
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp ugt i8 [[ADD]], 10
 ; CHECK-NEXT:    tail call void @llvm.assume(i1 [[CMP]])
 ; CHECK-NEXT:    [[EXT:%.*]] = zext i8 [[CNT]] to i16
 ; CHECK-NEXT:    [[ADD_PTR:%.*]] = getelementptr inbounds i32, ptr [[P:%.*]], i16 [[EXT]]
-; CHECK-NEXT:    [[T_1:%.*]] = icmp uge ptr [[ADD_PTR]], [[P]]
-; CHECK-NEXT:    [[F_1:%.*]] = icmp ult ptr [[ADD_PTR]], [[P]]
 ; CHECK-NEXT:    [[GEP_11:%.*]] = getelementptr inbounds i32, ptr [[P]], i16 11
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ugt ptr [[ADD_PTR]], [[GEP_11]]
 ; CHECK-NEXT:    [[RES_1:%.*]] = xor i1 true, false
 ; CHECK-NEXT:    [[RES_2:%.*]] = xor i1 [[RES_1]], [[C_1]]
 ; CHECK-NEXT:    ret i1 [[RES_2]]
 ;
 entry:
   %add = add nuw nsw i8 %cnt, %off

llvm/test/Transforms/ConstraintElimination/zext.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -passes=constraint-elimination -S %s | FileCheck %s
 
 define i1 @uge_zext(i8 %x, i16 %y) {
 ; CHECK-LABEL: @uge_zext(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[X_EXT:%.*]] = zext i8 [[X:%.*]] to i16
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp uge i16 [[X_EXT]], [[Y:%.*]]
 ; CHECK-NEXT:    br i1 [[C_1]], label [[BB1:%.*]], label [[BB2:%.*]]
 ; CHECK:       bb1:
-; CHECK-NEXT:    [[T_1:%.*]] = icmp uge i16 [[X_EXT]], [[Y]]
 ; CHECK-NEXT:    [[C_2:%.*]] = icmp uge i16 [[X_EXT]], 10
 ; CHECK-NEXT:    [[R_1:%.*]] = xor i1 true, [[C_2]]
 ; CHECK-NEXT:    [[C_3:%.*]] = icmp uge i16 [[Y]], [[X_EXT]]
 ; CHECK-NEXT:    [[R_2:%.*]] = xor i1 [[R_1]], [[C_3]]
 ; CHECK-NEXT:    [[C_4:%.*]] = icmp uge i16 10, [[X_EXT]]
 ; CHECK-NEXT:    [[R_3:%.*]] = xor i1 [[R_2]], [[C_4]]
 ; CHECK-NEXT:    ret i1 [[R_3]]
 ; CHECK:       bb2:
-; CHECK-NEXT:    [[T_2:%.*]] = icmp uge i16 [[Y]], [[X_EXT]]
-; CHECK-NEXT:    [[F_1:%.*]] = icmp uge i16 [[X_EXT]], [[Y]]
 ; CHECK-NEXT:    [[R_4:%.*]] = xor i1 true, false
 ; CHECK-NEXT:    [[C_5:%.*]] = icmp uge i16 [[X_EXT]], 10
 ; CHECK-NEXT:    [[R_5:%.*]] = xor i1 [[R_4]], [[C_5]]
 ; CHECK-NEXT:    [[C_6:%.*]] = icmp uge i16 10, [[X_EXT]]
 ; CHECK-NEXT:    [[R_6:%.*]] = xor i1 [[R_5]], [[C_6]]
 ; CHECK-NEXT:    ret i1 [[R_6]]
 ;
 entry:

 define i1 @uge_compare_short_and_extended(i8 %x, i8 %y) {
 ; CHECK-LABEL: @uge_compare_short_and_extended(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp uge i8 [[X:%.*]], [[Y:%.*]]
 ; CHECK-NEXT:    [[X_EXT:%.*]] = zext i8 [[X]] to i16
 ; CHECK-NEXT:    [[Y_EXT:%.*]] = zext i8 [[Y]] to i16
 ; CHECK-NEXT:    br i1 [[C_1]], label [[BB1:%.*]], label [[BB2:%.*]]
 ; CHECK:       bb1:
-; CHECK-NEXT:    [[T_1:%.*]] = icmp uge i16 [[X_EXT]], [[Y_EXT]]
 ; CHECK-NEXT:    [[C_2:%.*]] = icmp uge i16 [[X_EXT]], 10
 ; CHECK-NEXT:    [[R_1:%.*]] = xor i1 true, [[C_2]]
 ; CHECK-NEXT:    [[C_3:%.*]] = icmp sge i16 [[Y_EXT]], [[X_EXT]]
 ; CHECK-NEXT:    [[R_2:%.*]] = xor i1 [[R_1]], [[C_3]]
 ; CHECK-NEXT:    [[C_4:%.*]] = icmp uge i16 10, [[X_EXT]]
 ; CHECK-NEXT:    [[R_3:%.*]] = xor i1 [[R_2]], [[C_4]]
 ; CHECK-NEXT:    ret i1 [[R_3]]
 ; CHECK:       bb2:
-; CHECK-NEXT:    [[T_2:%.*]] = icmp uge i16 [[Y_EXT]], [[X_EXT]]
-; CHECK-NEXT:    [[F_1:%.*]] = icmp uge i16 [[X_EXT]], [[Y_EXT]]
 ; CHECK-NEXT:    [[R_4:%.*]] = xor i1 true, false
 ; CHECK-NEXT:    [[C_5:%.*]] = icmp uge i16 [[X_EXT]], 10
 ; CHECK-NEXT:    [[R_5:%.*]] = xor i1 [[R_4]], [[C_5]]
 ; CHECK-NEXT:    [[C_6:%.*]] = icmp uge i16 10, [[X_EXT]]
 ; CHECK-NEXT:    [[R_6:%.*]] = xor i1 [[R_5]], [[C_6]]
 ; CHECK-NEXT:    ret i1 [[R_6]]
 ;
 entry:

 ; CHECK-NEXT:    [[C_2:%.*]] = icmp uge i16 [[X_EXT]], 10
 ; CHECK-NEXT:    [[R_1:%.*]] = xor i1 [[T_1]], [[C_2]]
 ; CHECK-NEXT:    [[C_3:%.*]] = icmp uge i16 [[Y]], [[X_EXT]]
 ; CHECK-NEXT:    [[R_2:%.*]] = xor i1 [[R_1]], [[C_3]]
 ; CHECK-NEXT:    [[C_4:%.*]] = icmp uge i16 10, [[X_EXT]]
 ; CHECK-NEXT:    [[R_3:%.*]] = xor i1 [[R_2]], [[C_4]]
 ; CHECK-NEXT:    ret i1 [[R_3]]
 ; CHECK:       bb2:
-; CHECK-NEXT:    [[T_2:%.*]] = icmp uge i16 [[Y]], [[X_EXT]]
-; CHECK-NEXT:    [[F_1:%.*]] = icmp uge i16 [[X_EXT]], [[Y]]
 ; CHECK-NEXT:    [[R_4:%.*]] = xor i1 true, false
 ; CHECK-NEXT:    [[C_5:%.*]] = icmp uge i16 [[X_EXT]], 10
 ; CHECK-NEXT:    [[R_5:%.*]] = xor i1 [[R_4]], [[C_5]]
 ; CHECK-NEXT:    [[C_6:%.*]] = icmp uge i16 10, [[X_EXT]]
 ; CHECK-NEXT:    [[R_6:%.*]] = xor i1 [[R_5]], [[C_6]]
 ; CHECK-NEXT:    ret i1 [[R_6]]
 ;
 entry:

 
 define i1 @sge_zext(i8 %x, i16 %y) {
 ; CHECK-LABEL: @sge_zext(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[X_EXT:%.*]] = zext i8 [[X:%.*]] to i16
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp sge i16 [[X_EXT]], [[Y:%.*]]
 ; CHECK-NEXT:    br i1 [[C_1]], label [[BB1:%.*]], label [[BB2:%.*]]
 ; CHECK:       bb1:
-; CHECK-NEXT:    [[T_1:%.*]] = icmp sge i16 [[X_EXT]], [[Y]]
 ; CHECK-NEXT:    [[C_2:%.*]] = icmp sge i16 [[X_EXT]], 10
 ; CHECK-NEXT:    [[R_1:%.*]] = xor i1 true, [[C_2]]
 ; CHECK-NEXT:    [[C_3:%.*]] = icmp sge i16 [[Y]], [[X_EXT]]
 ; CHECK-NEXT:    [[R_2:%.*]] = xor i1 [[R_1]], [[C_3]]
 ; CHECK-NEXT:    [[C_4:%.*]] = icmp sge i16 10, [[X_EXT]]
 ; CHECK-NEXT:    [[R_3:%.*]] = xor i1 [[R_2]], [[C_4]]
 ; CHECK-NEXT:    ret i1 [[R_3]]
 ; CHECK:       bb2:
-; CHECK-NEXT:    [[T_2:%.*]] = icmp sge i16 [[Y]], [[X_EXT]]
-; CHECK-NEXT:    [[F_1:%.*]] = icmp sge i16 [[X_EXT]], [[Y]]
 ; CHECK-NEXT:    [[R_4:%.*]] = xor i1 true, false
 ; CHECK-NEXT:    [[C_5:%.*]] = icmp sge i16 [[X_EXT]], 10
 ; CHECK-NEXT:    [[R_5:%.*]] = xor i1 [[R_4]], [[C_5]]
 ; CHECK-NEXT:    [[C_6:%.*]] = icmp sge i16 10, [[X_EXT]]
 ; CHECK-NEXT:    [[R_6:%.*]] = xor i1 [[R_5]], [[C_6]]
 ; CHECK-NEXT:    ret i1 [[R_6]]
 ;
 entry:
bb2:
   %c.5 = icmp sge i16 %x.ext, 10
   %r.5 = xor i1 %r.4, %c.5
   %c.6 = icmp sge i16 10, %x.ext
   %r.6 = xor i1 %r.5, %c.6
   ret i1 %r.6
 }
 
 define i1 @test_pr58009_const_zext() {
+; CHECK-LABEL: @test_pr58009_const_zext(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[EXT_T_1:%.*]] = zext i1 true to i16
+; CHECK-NEXT:    [[EXT_T_2:%.*]] = zext i1 true to i16
+; CHECK-NEXT:    [[RES_1:%.*]] = xor i1 true, false
+; CHECK-NEXT:    [[EXT_F_1:%.*]] = zext i1 false to i16
+; CHECK-NEXT:    [[EXT_F_2:%.*]] = zext i1 false to i16
+; CHECK-NEXT:    [[RES_2:%.*]] = xor i1 [[RES_1]], true
+; CHECK-NEXT:    [[RES_3:%.*]] = xor i1 [[RES_2]], false
+; CHECK-NEXT:    [[T_3:%.*]] = icmp ult i16 [[EXT_F_1]], [[EXT_T_2]]
+; CHECK-NEXT:    [[F_3:%.*]] = icmp ugt i16 [[EXT_F_1]], [[EXT_T_2]]
+; CHECK-NEXT:    [[RES_4:%.*]] = xor i1 [[RES_3]], [[T_3]]
+; CHECK-NEXT:    [[RES_5:%.*]] = xor i1 [[RES_4]], [[F_3]]
+; CHECK-NEXT:    ret i1 [[RES_5]]
+;
 entry:
   %ext.t.1 = zext i1 true to i16
   %ext.t.2 = zext i1 true to i16
   %t.1 = icmp uge i16 %ext.t.1, %ext.t.2
   %f.1 = icmp ugt i16 %ext.t.1, %ext.t.2
   %res.1 = xor i1 %t.1, %f.1
 
   %ext.f.1 = zext i1 false to i16