[InstCombine] Fold comparison of usub.sat

[0xdc03]

Summary

This patch introduces a fold for the operation "usub_sat(X, C) pred C2"
where "C" and "C2" are constants. The fold is:

usub_sat(X, C) pred C2
=> (X < C)  || ((X - C) pred C2) -> when (0 pred C2) is true
=> (X >= C) && ((X - C) pred C2) -> when (0 pred C2) is false

These expressions can generally be folded into a simpler expression. As
they can sometimes emit more than one instruction, they are limited to
cases where the "usub_sat" has only one user.

Fixes #58342.

Proofs: https://alive2.llvm.org/ce/z/ws_N2J

[nikic]

Could you please add alive2 proofs for these transforms?

llvm/lib/Transforms/InstCombine/InstCombineCompares.cpp

3523

m_ImmConstant

3750

Add comment explaining the transform, something like this:

//    usub.sat(X, C) pred C2
// -> (X < C ? 0 : X - C) pred C2
// -> X >= C && (X - C) pred C2 (if 0 pred C2 is false)
// -> X < C || (X - C) pred C2 (if 0 pred C2 is true)

3760

Some of these cases will end up producing 2 instructions (add + icmp), so I think we should add a one-use limitation on the intrinsic.

llvm/test/Transforms/InstCombine/icmp-usub-sat.ll

120

Add a multi-use and vector test.

[goldstein.w.n]

Can you both add comment explaning at least the fold taking place in the code (where it takes place) and update the summary with an alive2 link + some description of the exact folds.

[goldstein.w.n]

llvm/lib/Transforms/InstCombine/InstCombineCompares.cpp

3521

EqPred is kind of confusing (since its a non-equality pred), maybe NewPred?

3751

m_ImmConstant() here as well.

llvm/test/Transforms/InstCombine/icmp-usub-sat.ll

120

Can you split tests to seperate patch (make series with tests as Patch1 then impl as Patch2) so we can see the diff this patch causes.

[0xdc03]

• Redo the broken code
• Add comments explaining everything with derivations

Depends on D154342.

[0xdc03]

llvm/lib/Transforms/InstCombine/InstCombineCompares.cpp

3521

Done!

3523

Done!

3750

Done!

3751

Done!

3760

Done!

llvm/test/Transforms/InstCombine/icmp-usub-sat.ll

120

Done! D154342

[nikic]

llvm/lib/Transforms/InstCombine/InstCombineCompares.cpp

3363–3366

This should be if (match(Op1, m_APInt(COp1)) to match a constant int or int splat.

3378

3381

Check the return value -- does this actually always succeed?

It would have expected that you need to use the getEquivalentICmp overload that also provides an additional Offset (because that one *is* guaranteed to succeed).

3397

Do we ever actually take this fallback code patch? I searched for freeze, and i1 and or i1 in your tests without hits.

3498

Could fold this into foldICmpUSubSatWithConstant() and only impose the limitation if we actually need to produce more than one instruction.

[0xdc03]

• Address reviewer comments
• Remove fold for non-splat constant vectors

[0xdc03]

llvm/lib/Transforms/InstCombine/InstCombineCompares.cpp

3363–3366

Done!

3378

Done!

3381

Done! I am a bit concerned about the codegen this causes, maybe I have done something wrong with using Builder.CreateAdd? Looking at test cases like icmp_sle_basic_positive, there is an extra add instruction generated, which I would've expected to get folded. Could this be due to a lack of nuw/nsw?

3397

Yeah, I had not come up with a test case to exercise that code path, because I didn't realize that the fold is only called when splat vectors are given as operands to the icmp, and I have no tests to check non-splat vector in the usub.sat and a splat vector in the icmp.

3498

Done!

[0xdc03]

• Remove unnecessary header "ValueTracking.h" now that isGuaranteedNotToBeUndefOrPoison is not being used.

[goldstein.w.n]

LGTM. Since nikic was the primary review give him a few days to potentially add more feedback before pushing.

llvm/lib/Transforms/InstCombine/InstCombineCompares.cpp

3502

nit: extra space before "a <= b" compared to below.

[nikic]

llvm/lib/Transforms/InstCombine/InstCombineCompares.cpp

3367

3368

Prefer early return over nesting.

3370

This comment isn't correct.

3374

3380

Early return

3673

In terms of overall code structure, I would prefer it if we added an extra switch (II->getIntrinsicID()) here, before the isEquality() handling, where we can handle folds that apply for both equality and non-equality comparisons. This is a recurring pattern, e.g. we've seen the same issue in D152677.

[0xdc03]

• Address reviewer comments
  • Remove unnecessary nesting
  • Add an extra switch to foldICmpIntrinsicWithConstant

[0xdc03]

llvm/lib/Transforms/InstCombine/InstCombineCompares.cpp

3370

Is this better: // Convert '(X - C) pred C2' into 'X pred C2' shifted by C.?

3381

I marked this as done, but I think its worth confirming this just in case you missed this.

3673

Done!

[nikic]

llvm/lib/Transforms/InstCombine/InstCombineCompares.cpp

3381

The codegen here is correct. This is how you do a two-sided range check (it's equivalent to something like X >= C1 && X <= C2).

3397

Redundant nullptr return...

3507

I don't think this comment adds value relative to the old one-liner...

3682

I'd move this compare() call into foldICmpUSubSatWithConstant(). Seems odd to split this operation out.

[0xdc03]

• Address reviewer comments
  • Remove unnecessary comments
  • Move function further down for cleaner diff
  • Remove unnecessary parameter

[0xdc03]

llvm/lib/Transforms/InstCombine/InstCombineCompares.cpp

3381

Ah, fair enough them.

3397

Oof ... :facepalm:

3507

Removed it!

3682

Ah, that was bad copy pasting from the older code! Sorry about that.

[0xdc03]

• Rebase on main

[nikic]

LGTM

llvm/lib/Transforms/InstCombine/InstCombineCompares.cpp

3684

[0xdc03]

• Rebase on updated test cases
• Fix )

[0xdc03]

Test failure seems unrelated to the change:

Failed Tests (1):
  Clangd Unit Tests :: ./ClangdTests/ClangdServer/RespectsTweakFormatting

llvm/lib/Transforms/InstCombine/InstCombineCompares.cpp

 #include "InstCombineInternal.h"
 #include "llvm/ADT/APSInt.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/Analysis/CaptureTracking.h"
 #include "llvm/Analysis/CmpInstAnalysis.h"
 #include "llvm/Analysis/ConstantFolding.h"
 #include "llvm/Analysis/InstructionSimplify.h"
+#include "llvm/Analysis/ValueTracking.h"
 #include "llvm/Analysis/VectorUtils.h"
 #include "llvm/IR/ConstantRange.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/GetElementPtrTypeIterator.h"
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/PatternMatch.h"
 #include "llvm/Support/KnownBits.h"
 #include "llvm/Transforms/InstCombine/InstCombiner.h"
case Instruction::UDiv:
     }
     break;
   default:
     break;
   }
   return nullptr;
 }
 
+static Instruction *
+foldICmpUSubSatWithConstant(bool ConstantComparisonWithZero,
+                            ICmpInst::Predicate Pred, IntrinsicInst *II,
+                            const APInt &C, InstCombiner::BuilderTy &Builder) {
+  // Let Y = usub.sat(X, C) pred C2
+  //  => Y = (X < C ? 0 : (X - C)) pred C2
+  //  => Y = (X < C) ? (0 pred C2) : ((X - C) pred C2)
+  //
+  // When (0 pred C2) [ConstantComparisonWithZero] is true, then
+  //    Y = (X < C) ? true : ((X - C) pred C2)
+  // => Y = (X < C) || ((X - C)) pred C2
+  // else
+  //    Y = (X < C) ? false : ((X - C) pred C2)
+  // => Y = !(X < C) && ((X - C) pred C2)
+  // => Y = (X >= C) && ((X - C) pred C2)
+  Value *Op0 = II->getOperand(0);
+  Value *Op1 = II->getOperand(1);
+
+  auto [NewPred, LogicalOp] =
+      ConstantComparisonWithZero
+          ? std::make_pair(ICmpInst::ICMP_ULT, Instruction::BinaryOps::Or)
+          : std::make_pair(ICmpInst::ICMP_UGE, Instruction::BinaryOps::And);
+
+  Constant *COp1 = nullptr;
+  if (match(Op1, m_ImmConstant(COp1))) {
+    // Try to see if we can generate a single icmp directly.
+    if (isa<ConstantInt>(COp1) || COp1->getSplatValue()) {
+      const APInt &COp1Int = COp1->getUniqueInteger();
+      ConstantRange C1 = ConstantRange::makeExactICmpRegion(NewPred, COp1Int);
+      // Convert '(X - C) pred C2' into 'X pred (C + C2)'.
+      ConstantRange C2 = ConstantRange::makeExactICmpRegion(Pred, C);
+      C2 = C2.add(COp1Int);
+
+      std::optional<ConstantRange> Combination = std::nullopt;
+      if (LogicalOp == Instruction::BinaryOps::Or)
+        Combination = C1.exactUnionWith(C2);
+      else /* LogicalOp == Instruction::BinaryOp::And */
+        Combination = C1.exactIntersectWith(C2);
+
+      if (Combination.has_value()) {
+        CmpInst::Predicate EquivalentPred;
+        APInt EquivalentInt;
+        Combination->getEquivalentICmp(EquivalentPred, EquivalentInt);
+
+        return new ICmpInst(EquivalentPred, Op0,
+                            ConstantInt::get(COp1->getType(), EquivalentInt));
+      }
+    }
+
+    // Two uses of X can cause issues with undef, so freeze the value if it is
+    // not known to be noundef.
+    if (!isGuaranteedNotToBeUndefOrPoison(Op0))
+      Op0 = Builder.CreateFreeze(Op0);
+
+    // Fall back to generating the two icmps and the logical op.
+    Constant *CondConstant = ConstantInt::get(COp1->getType(), C);
+    return BinaryOperator::Create(
+        LogicalOp, Builder.CreateICmp(NewPred, Op0, Op1),
+        Builder.CreateICmp(Pred, Builder.CreateSub(Op0, Op1), CondConstant));
+  }
+
+  return nullptr;
+}
+
 /// Fold an equality icmp with LLVM intrinsic and constant operand.
 Instruction *InstCombinerImpl::foldICmpEqIntrinsicWithConstant(
     ICmpInst &Cmp, IntrinsicInst *II, const APInt &C) {
   Type *Ty = II->getType();
   unsigned BitWidth = C.getBitWidth();
   const ICmpInst::Predicate Pred = Cmp.getPredicate();
 
   switch (II->getIntrinsicID()) {
Instruction *InstCombinerImpl::foldICmpEqIntrinsicWithConstant(
   }
 
   case Intrinsic::ssub_sat:
     // ssub.sat(a, b) == 0 -> a == b
     if (C.isZero())
       return new ICmpInst(Pred, II->getArgOperand(0), II->getArgOperand(1));
     break;
   case Intrinsic::usub_sat: {
-    // usub.sat(a, b) == 0  ->  a <= b
+    // These transforms may end up producing more than one instruction for the
+    // intrinsic, so limit them to one user.
+    if (!II->hasOneUse())
+      break;
+
+    // This is a special case of foldICmpIntrinsicWithConstant.
+    //
+    // Here we have two cases:
+    // - usub.sat(a, b) == c (or)
+    // - usub.sat(a, b) != c
+    //
+    // When c == 0, this simplifies to
+    // - usub.sat(a, b) == 0 ->  a <= b
+    // - usub.sat(a, b) != 0 -> a > b
+    // else we have:
+    // - usub.sat(a, b) == c -> (a >= b) && (a - b) == c (as 0 == c is false)
+    // - usub.sat(a, b) != c -> (a < b) || (a - b) != c (as 0 != c is true)
+    // which is handled by foldICmpUSubSatWithConstant.
+
     if (C.isZero()) {
       ICmpInst::Predicate NewPred =
           Pred == ICmpInst::ICMP_EQ ? ICmpInst::ICMP_ULE : ICmpInst::ICMP_UGT;
       return new ICmpInst(NewPred, II->getArgOperand(0), II->getArgOperand(1));
     }
+
+    if (auto *Folded = foldICmpUSubSatWithConstant(Pred != ICmpInst::ICMP_EQ,
+                                                   Pred, II, C, Builder))
+      return Folded;
+
     break;
   }
   default:
     break;
   }
 
   return nullptr;
 }
Instruction *InstCombinerImpl::foldICmpBinOpWithConstant(ICmpInst &Cmp,
 
   // TODO: These folds could be refactored to be part of the above calls.
   return foldICmpBinOpEqualityWithConstant(Cmp, BO, C);
 }
 
 /// Fold an icmp with LLVM intrinsic and constant operand: icmp Pred II, C.
 Instruction *InstCombinerImpl::foldICmpIntrinsicWithConstant(ICmpInst &Cmp,
                                                              IntrinsicInst *II,
                                                              const APInt &C) {
   if (Cmp.isEquality())
     return foldICmpEqIntrinsicWithConstant(Cmp, II, C);
 
   Type *Ty = II->getType();
   unsigned BitWidth = C.getBitWidth();
   ICmpInst::Predicate Pred = Cmp.getPredicate();
   switch (II->getIntrinsicID()) {
   case Intrinsic::ctpop: {
     // (ctpop X > BitWidth - 1) --> X == -1
     Value *X = II->getArgOperand(0);
     if (C == BitWidth - 1 && Pred == ICmpInst::ICMP_UGT)
       return CmpInst::Create(Instruction::ICmp, ICmpInst::ICMP_EQ, X,
                              ConstantInt::getAllOnesValue(Ty));
     // (ctpop X < BitWidth) --> X != -1
     if (C == BitWidth && Pred == ICmpInst::ICMP_ULT)
       return CmpInst::Create(Instruction::ICmp, ICmpInst::ICMP_NE, X,
                              ConstantInt::getAllOnesValue(Ty));
     break;
   }
if (ICmpInst::isSigned(Pred)) {
         return new ICmpInst(ICmpInst::ICMP_SLE, II->getArgOperand(0),
                             II->getArgOperand(1));
       // X s>= 0 is cannonicalized to X s> -1
       if (Pred == ICmpInst::ICMP_SGT && C.isAllOnes())
         return new ICmpInst(ICmpInst::ICMP_SGE, II->getArgOperand(0),
                             II->getArgOperand(1));
     }
     break;
+  case Intrinsic::usub_sat: {
+    // These transforms may end up producing more than one instruction for the
+    // intrinsic, so limit them to one user.
+    if (!II->hasOneUse())
+      break;
+
+    if (auto *Folded = foldICmpUSubSatWithConstant(
+            ICmpInst::compare(APInt::getZero(C.getBitWidth()), C, Pred), Pred,
+            II, C, Builder))
+      return Folded;
+
+    break;
+  }
   default:
     break;
   }
 
   return nullptr;
 }
 
 /// Handle icmp with constant (but not simple integer constant) RHS.

llvm/test/Transforms/InstCombine/icmp-usub-sat.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 2
 ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
 
 ; Tests for InstCombineCompares.cpp::foldICmpUSubSatWithConstant
 ; https://github.com/llvm/llvm-project/issues/58342
 
 ; ==============================================================================
 ; Basic tests with one user and positive arguments
 ; ==============================================================================
 define i1 @icmp_eq_basic_positive(i8 %arg) {
 ; CHECK-LABEL: define i1 @icmp_eq_basic_positive
 ; CHECK-SAME: (i8 [[ARG:%.*]]) {
-; CHECK-NEXT:    [[SUB:%.*]] = call i8 @llvm.usub.sat.i8(i8 [[ARG]], i8 2)
-; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i8 [[SUB]], 5
+; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i8 [[ARG]], 7
 ; CHECK-NEXT:    ret i1 [[CMP]]
 ;
   %sub = call i8 @llvm.usub.sat.i8(i8 %arg, i8 2)
   %cmp = icmp eq i8 %sub, 5
   ret i1 %cmp
 }
 
 define i1 @icmp_ne_basic_positive(i16 %arg) {
 ; CHECK-LABEL: define i1 @icmp_ne_basic_positive
 ; CHECK-SAME: (i16 [[ARG:%.*]]) {
-; CHECK-NEXT:    [[SUB:%.*]] = call i16 @llvm.usub.sat.i16(i16 [[ARG]], i16 8)
-; CHECK-NEXT:    [[CMP:%.*]] = icmp ne i16 [[SUB]], 9
+; CHECK-NEXT:    [[CMP:%.*]] = icmp ne i16 [[ARG]], 17
 ; CHECK-NEXT:    ret i1 [[CMP]]
 ;
   %sub = call i16 @llvm.usub.sat.i16(i16 %arg, i16 8)
   %cmp = icmp ne i16 %sub, 9
   ret i1 %cmp
 }
 
 define i1 @icmp_ule_basic_positive(i32 %arg) {
 ; CHECK-LABEL: define i1 @icmp_ule_basic_positive
 ; CHECK-SAME: (i32 [[ARG:%.*]]) {
-; CHECK-NEXT:    [[SUB:%.*]] = call i32 @llvm.usub.sat.i32(i32 [[ARG]], i32 6)
-; CHECK-NEXT:    [[CMP:%.*]] = icmp ult i32 [[SUB]], 4
+; CHECK-NEXT:    [[CMP:%.*]] = icmp ult i32 [[ARG]], 10
 ; CHECK-NEXT:    ret i1 [[CMP]]
 ;
   %sub = call i32 @llvm.usub.sat.i32(i32 %arg, i32 6)
   %cmp = icmp ule i32 %sub, 3
   ret i1 %cmp
 }
 
 define i1 @icmp_ult_basic_positive(i64 %arg) {
 ; CHECK-LABEL: define i1 @icmp_ult_basic_positive
 ; CHECK-SAME: (i64 [[ARG:%.*]]) {
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp ult i64 [[ARG]], 6
 ; CHECK-NEXT:    ret i1 [[CMP]]
 ;
   %sub = call i64 @llvm.usub.sat.i64(i64 %arg, i64 5)
   %cmp = icmp ult i64 %sub, 1
   ret i1 %cmp
 }
 
 define i1 @icmp_uge_basic_positive(i8 %arg) {
 ; CHECK-LABEL: define i1 @icmp_uge_basic_positive
 ; CHECK-SAME: (i8 [[ARG:%.*]]) {
-; CHECK-NEXT:    [[SUB:%.*]] = call i8 @llvm.usub.sat.i8(i8 [[ARG]], i8 4)
-; CHECK-NEXT:    [[CMP:%.*]] = icmp ugt i8 [[SUB]], 3
+; CHECK-NEXT:    [[CMP:%.*]] = icmp ugt i8 [[ARG]], 7
 ; CHECK-NEXT:    ret i1 [[CMP]]
 ;
   %sub = call i8 @llvm.usub.sat.i8(i8 %arg, i8 4)
   %cmp = icmp uge i8 %sub, 4
   ret i1 %cmp
 }
 
 define i1 @icmp_ugt_basic_positive(i16 %arg) {
 ; CHECK-LABEL: define i1 @icmp_ugt_basic_positive
 ; CHECK-SAME: (i16 [[ARG:%.*]]) {
-; CHECK-NEXT:    [[SUB:%.*]] = call i16 @llvm.usub.sat.i16(i16 [[ARG]], i16 1)
-; CHECK-NEXT:    [[CMP:%.*]] = icmp ugt i16 [[SUB]], 3
+; CHECK-NEXT:    [[CMP:%.*]] = icmp ugt i16 [[ARG]], 4
 ; CHECK-NEXT:    ret i1 [[CMP]]
 ;
   %sub = call i16 @llvm.usub.sat.i16(i16 %arg, i16 1)
   %cmp = icmp ugt i16 %sub, 3
   ret i1 %cmp
 }
 
 define i1 @icmp_sle_basic_positive(i32 %arg) {
 ; CHECK-LABEL: define i1 @icmp_sle_basic_positive
 ; CHECK-SAME: (i32 [[ARG:%.*]]) {
-; CHECK-NEXT:    [[SUB:%.*]] = call i32 @llvm.usub.sat.i32(i32 [[ARG]], i32 10)
-; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i32 [[SUB]], 9
+; CHECK-NEXT:    [[CMP:%.*]] = icmp ult i32 [[ARG]], -2147483639
 ; CHECK-NEXT:    ret i1 [[CMP]]
 ;
   %sub = call i32 @llvm.usub.sat.i32(i32 %arg, i32 10)
   %cmp = icmp sle i32 %sub, 8
   ret i1 %cmp
 }
 
 define i1 @icmp_slt_basic_positive(i64 %arg) {
 ; CHECK-LABEL: define i1 @icmp_slt_basic_positive
 ; CHECK-SAME: (i64 [[ARG:%.*]]) {
-; CHECK-NEXT:    [[SUB:%.*]] = call i64 @llvm.usub.sat.i64(i64 [[ARG]], i64 24)
-; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i64 [[SUB]], 5
+; CHECK-NEXT:    [[CMP:%.*]] = icmp ult i64 [[ARG]], -9223372036854775803
 ; CHECK-NEXT:    ret i1 [[CMP]]
 ;
   %sub = call i64 @llvm.usub.sat.i64(i64 %arg, i64 24)
   %cmp = icmp slt i64 %sub, 5
   ret i1 %cmp
 }
 
 define i1 @icmp_sge_basic_positive(i8 %arg) {
 ; CHECK-LABEL: define i1 @icmp_sge_basic_positive
 ; CHECK-SAME: (i8 [[ARG:%.*]]) {
-; CHECK-NEXT:    [[SUB:%.*]] = call i8 @llvm.usub.sat.i8(i8 [[ARG]], i8 1)
-; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt i8 [[SUB]], 3
+; CHECK-NEXT:    [[CMP:%.*]] = icmp ult i8 [[ARG]], 124
 ; CHECK-NEXT:    ret i1 [[CMP]]
 ;
   %sub = call i8 @llvm.usub.sat.i8(i8 %arg, i8 1)
   %cmp = icmp sge i8 %sub, 4
   ret i1 %cmp
 }
 
 define i1 @icmp_sgt_basic_positive(i16 %arg) {
 ; CHECK-LABEL: define i1 @icmp_sgt_basic_positive
 ; CHECK-SAME: (i16 [[ARG:%.*]]) {
-; CHECK-NEXT:    [[SUB:%.*]] = call i16 @llvm.usub.sat.i16(i16 [[ARG]], i16 2)
-; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt i16 [[SUB]], 5
+; CHECK-NEXT:    [[CMP:%.*]] = icmp ult i16 [[ARG]], 32762
 ; CHECK-NEXT:    ret i1 [[CMP]]
 ;
   %sub = call i16 @llvm.usub.sat.i16(i16 %arg, i16 2)
   %cmp = icmp sgt i16 %sub, 5
   ret i1 %cmp
 }
 
 ; ==============================================================================
 ; Basic tests with one user and negative arguments
 ; ==============================================================================
 define i1 @icmp_eq_basic_negative(i8 %arg) {
 ; CHECK-LABEL: define i1 @icmp_eq_basic_negative
 ; CHECK-SAME: (i8 [[ARG:%.*]]) {
 ; CHECK-NEXT:    ret i1 false
 ;
   %sub = call i8 @llvm.usub.sat.i8(i8 %arg, i8 -2)
;
   %sub = call i16 @llvm.usub.sat.i16(i16 %arg, i16 -8)
   %cmp = icmp ne i16 %sub, 9
   ret i1 %cmp
 }
 
 define i1 @icmp_ule_basic_negative(i32 %arg) {
 ; CHECK-LABEL: define i1 @icmp_ule_basic_negative
 ; CHECK-SAME: (i32 [[ARG:%.*]]) {
-; CHECK-NEXT:    [[SUB:%.*]] = call i32 @llvm.usub.sat.i32(i32 [[ARG]], i32 -6)
-; CHECK-NEXT:    [[CMP:%.*]] = icmp ult i32 [[SUB]], 4
+; CHECK-NEXT:    [[CMP:%.*]] = icmp ult i32 [[ARG]], -2
 ; CHECK-NEXT:    ret i1 [[CMP]]
 ;
   %sub = call i32 @llvm.usub.sat.i32(i32 %arg, i32 -6)
   %cmp = icmp ule i32 %sub, 3
   ret i1 %cmp
 }
 
 define i1 @icmp_ult_basic_negative(i64 %arg) {
;
   %sub = call i16 @llvm.usub.sat.i16(i16 %arg, i16 -1)
   %cmp = icmp ugt i16 %sub, 3
   ret i1 %cmp
 }
 
 define i1 @icmp_sle_basic_negative(i32 %arg) {
 ; CHECK-LABEL: define i1 @icmp_sle_basic_negative
 ; CHECK-SAME: (i32 [[ARG:%.*]]) {
-; CHECK-NEXT:    [[SUB:%.*]] = call i32 @llvm.usub.sat.i32(i32 [[ARG]], i32 -10)
-; CHECK-NEXT:    [[CMP:%.*]] = icmp ult i32 [[SUB]], 9
+; CHECK-NEXT:    [[CMP:%.*]] = icmp ne i32 [[ARG]], -1
 ; CHECK-NEXT:    ret i1 [[CMP]]
 ;
   %sub = call i32 @llvm.usub.sat.i32(i32 %arg, i32 -10)
   %cmp = icmp sle i32 %sub, 8
   ret i1 %cmp
 }
 
 define i1 @icmp_slt_basic_negative(i64 %arg) {
 ; CHECK-LABEL: define i1 @icmp_slt_basic_negative
 ; CHECK-SAME: (i64 [[ARG:%.*]]) {
-; CHECK-NEXT:    [[SUB:%.*]] = call i64 @llvm.usub.sat.i64(i64 [[ARG]], i64 -24)
-; CHECK-NEXT:    [[CMP:%.*]] = icmp ult i64 [[SUB]], 5
+; CHECK-NEXT:    [[CMP:%.*]] = icmp ult i64 [[ARG]], -19
 ; CHECK-NEXT:    ret i1 [[CMP]]
 ;
   %sub = call i64 @llvm.usub.sat.i64(i64 %arg, i64 -24)
   %cmp = icmp slt i64 %sub, 5
   ret i1 %cmp
 }
 
 define i1 @icmp_sge_basic_negative(i8 %arg) {
;
   %ret = trunc i32 %add to i1
   ret i1 %ret
 }
 
 define i1 @icmp_ult_multiuse_positive(i64 %arg) {
 ; CHECK-LABEL: define i1 @icmp_ult_multiuse_positive
 ; CHECK-SAME: (i64 [[ARG:%.*]]) {
 ; CHECK-NEXT:    [[SUB:%.*]] = call i64 @llvm.usub.sat.i64(i64 [[ARG]], i64 5)
-; CHECK-NEXT:    [[CMP:%.*]] = icmp ult i64 [[ARG]], 6
+; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i64 [[SUB]], 0
 ; CHECK-NEXT:    [[TMP1:%.*]] = and i64 [[SUB]], 1
 ; CHECK-NEXT:    [[SUB_TR:%.*]] = icmp ne i64 [[TMP1]], 0
 ; CHECK-NEXT:    [[ADD_NARROW:%.*]] = xor i1 [[SUB_TR]], [[CMP]]
 ; CHECK-NEXT:    ret i1 [[ADD_NARROW]]
 ;
   %sub = call i64 @llvm.usub.sat.i64(i64 %arg, i64 5)
   %cmp = icmp ult i64 %sub, 1
   %ext = zext i1 %cmp to i64
;
   %ret = trunc i32 %add to i1
   ret i1 %ret
 }
 
 define i1 @icmp_ult_multiuse_negative(i64 %arg) {
 ; CHECK-LABEL: define i1 @icmp_ult_multiuse_negative
 ; CHECK-SAME: (i64 [[ARG:%.*]]) {
 ; CHECK-NEXT:    [[SUB:%.*]] = call i64 @llvm.usub.sat.i64(i64 [[ARG]], i64 -5)
-; CHECK-NEXT:    [[CMP:%.*]] = icmp ult i64 [[ARG]], -4
+; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i64 [[SUB]], 0
 ; CHECK-NEXT:    [[TMP1:%.*]] = and i64 [[SUB]], 1
 ; CHECK-NEXT:    [[SUB_TR:%.*]] = icmp ne i64 [[TMP1]], 0
 ; CHECK-NEXT:    [[ADD_NARROW:%.*]] = xor i1 [[SUB_TR]], [[CMP]]
 ; CHECK-NEXT:    ret i1 [[ADD_NARROW]]
 ;
   %sub = call i64 @llvm.usub.sat.i64(i64 %arg, i64 -5)
   %cmp = icmp ult i64 %sub, 1
   %ext = zext i1 %cmp to i64

 }
 
 ; ==============================================================================
 ; Tests with vector types
 ; ==============================================================================
 define <2 x i1> @icmp_eq_vector_positive_equal(<2 x i8> %arg) {
 ; CHECK-LABEL: define <2 x i1> @icmp_eq_vector_positive_equal
 ; CHECK-SAME: (<2 x i8> [[ARG:%.*]]) {
-; CHECK-NEXT:    [[SUB:%.*]] = call <2 x i8> @llvm.usub.sat.v2i8(<2 x i8> [[ARG]], <2 x i8> <i8 2, i8 2>)
-; CHECK-NEXT:    [[CMP:%.*]] = icmp eq <2 x i8> [[SUB]], <i8 5, i8 5>
+; CHECK-NEXT:    [[CMP:%.*]] = icmp eq <2 x i8> [[ARG]], <i8 7, i8 7>
 ; CHECK-NEXT:    ret <2 x i1> [[CMP]]
 ;
   %sub = call <2 x i8> @llvm.usub.sat.v2i8(<2 x i8> %arg, <2 x i8> <i8 2, i8 2>)
   %cmp = icmp eq <2 x i8> %sub, <i8 5, i8 5>
   ret <2 x i1> %cmp
 }
 
 define <2 x i1> @icmp_eq_vector_negative_equal(<2 x i8> %arg) {
;
   %sub = call <2 x i8> @llvm.usub.sat.v2i8(<2 x i8> %arg, <2 x i8> <i8 -1, i8 -2>)
   %cmp = icmp eq <2 x i8> %sub, <i8 5, i8 6>
   ret <2 x i1> %cmp
 }
 
 define <2 x i1> @icmp_ne_vector_positive_equal(<2 x i16> %arg) {
 ; CHECK-LABEL: define <2 x i1> @icmp_ne_vector_positive_equal
 ; CHECK-SAME: (<2 x i16> [[ARG:%.*]]) {
-; CHECK-NEXT:    [[SUB:%.*]] = call <2 x i16> @llvm.usub.sat.v2i16(<2 x i16> [[ARG]], <2 x i16> <i16 32, i16 32>)
-; CHECK-NEXT:    [[CMP:%.*]] = icmp ne <2 x i16> [[SUB]], <i16 5, i16 5>
+; CHECK-NEXT:    [[CMP:%.*]] = icmp ne <2 x i16> [[ARG]], <i16 37, i16 37>
 ; CHECK-NEXT:    ret <2 x i1> [[CMP]]
 ;
   %sub = call <2 x i16> @llvm.usub.sat.v2i16(<2 x i16> %arg, <2 x i16> <i16 32, i16 32>)
   %cmp = icmp ne <2 x i16> %sub, <i16 5, i16 5>
   ret <2 x i1> %cmp
 }
 
 define <2 x i1> @icmp_ne_vector_positive_unequal(<2 x i16> %arg) {
 ; CHECK-LABEL: define <2 x i1> @icmp_ne_vector_positive_unequal
 ; CHECK-SAME: (<2 x i16> [[ARG:%.*]]) {
 ; CHECK-NEXT:    [[SUB:%.*]] = call <2 x i16> @llvm.usub.sat.v2i16(<2 x i16> [[ARG]], <2 x i16> <i16 3, i16 33>)
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp ne <2 x i16> [[SUB]], <i16 7, i16 6>
 ; CHECK-NEXT:    ret <2 x i1> [[CMP]]
 ;
   %sub = call <2 x i16> @llvm.usub.sat.v2i16(<2 x i16> %arg, <2 x i16> <i16 3, i16 33>)
   %cmp = icmp ne <2 x i16> %sub, <i16 7, i16 6>
   ret <2 x i1> %cmp
 }
 
 define <2 x i1> @icmp_ule_vector_positive_equal(<2 x i32> %arg) {
 ; CHECK-LABEL: define <2 x i1> @icmp_ule_vector_positive_equal
 ; CHECK-SAME: (<2 x i32> [[ARG:%.*]]) {
-; CHECK-NEXT:    [[SUB:%.*]] = call <2 x i32> @llvm.usub.sat.v2i32(<2 x i32> [[ARG]], <2 x i32> <i32 32, i32 32>)
-; CHECK-NEXT:    [[CMP:%.*]] = icmp ult <2 x i32> [[SUB]], <i32 5, i32 5>
+; CHECK-NEXT:    [[CMP:%.*]] = icmp ult <2 x i32> [[ARG]], <i32 37, i32 37>
 ; CHECK-NEXT:    ret <2 x i1> [[CMP]]
 ;
   %sub = call <2 x i32> @llvm.usub.sat.v2i32(<2 x i32> %arg, <2 x i32> <i32 32, i32 32>)
   %cmp = icmp ult <2 x i32> %sub, <i32 5, i32 5>
   ret <2 x i1> %cmp
 }
 
 define <2 x i1> @icmp_ule_vector_positive_unequal(<2 x i32> %arg) {
 ; CHECK-LABEL: define <2 x i1> @icmp_ule_vector_positive_unequal
 ; CHECK-SAME: (<2 x i32> [[ARG:%.*]]) {
 ; CHECK-NEXT:    [[SUB:%.*]] = call <2 x i32> @llvm.usub.sat.v2i32(<2 x i32> [[ARG]], <2 x i32> <i32 3, i32 35>)
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp ult <2 x i32> [[SUB]], <i32 5, i32 7>
 ; CHECK-NEXT:    ret <2 x i1> [[CMP]]
 ;
   %sub = call <2 x i32> @llvm.usub.sat.v2i32(<2 x i32> %arg, <2 x i32> <i32 3, i32 35>)
   %cmp = icmp ult <2 x i32> %sub, <i32 5, i32 7>
   ret <2 x i1> %cmp
 }
 
 define <2 x i1> @icmp_sgt_vector_positive_equal(<2 x i64> %arg) {
 ; CHECK-LABEL: define <2 x i1> @icmp_sgt_vector_positive_equal
 ; CHECK-SAME: (<2 x i64> [[ARG:%.*]]) {
-; CHECK-NEXT:    [[SUB:%.*]] = call <2 x i64> @llvm.usub.sat.v2i64(<2 x i64> [[ARG]], <2 x i64> <i64 409623, i64 409623>)
-; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt <2 x i64> [[SUB]], <i64 1234, i64 1234>
+; CHECK-NEXT:    [[CMP:%.*]] = icmp ult <2 x i64> [[ARG]], <i64 9223372036854774573, i64 9223372036854774573>
 ; CHECK-NEXT:    ret <2 x i1> [[CMP]]
 ;
   %sub = call <2 x i64> @llvm.usub.sat.v2i64(<2 x i64> %arg, <2 x i64> <i64 409623, i64 409623>)
   %cmp = icmp sgt <2 x i64> %sub, <i64 1234, i64 1234>
   ret <2 x i1> %cmp
 }
 
 define <2 x i1> @icmp_sgt_vector_positive_unequal(<2 x i64> %arg) {