[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

3440

m_ImmConstant

3733

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)

3743

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

3438

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

3734

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

3438

Done!

3440

Done!

3733

Done!

3734

Done!

3743

Done!

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

120

Done! D154342

[nikic]

llvm/lib/Transforms/InstCombine/InstCombineCompares.cpp

3362–3365

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

3377

3380

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

3396

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

3433

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

3362–3365

Done!

3377

Done!

3380

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?

3396

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.

3433

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

3437

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

[nikic]

llvm/lib/Transforms/InstCombine/InstCombineCompares.cpp

3366

3367

Prefer early return over nesting.

3369

This comment isn't correct.

3373

3379

Early return

3645–3657

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

3369

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

3380

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

3645–3657

Done!

[nikic]

llvm/lib/Transforms/InstCombine/InstCombineCompares.cpp

3380

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

3396

Redundant nullptr return...

3442

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

3654

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

3380

Ah, fair enough them.

3396

Oof ... :facepalm:

3442

Removed it!

3654

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

3596

[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

case Intrinsic::bswap:
     // bswap(A) == C  ->  A == bswap(C)
     return new ICmpInst(Pred, II->getArgOperand(0),
                         ConstantInt::get(Ty, C.byteSwap()));
 
   case Intrinsic::bitreverse:
     // bitreverse(A) == C  ->  A == bitreverse(C)
     return new ICmpInst(Pred, II->getArgOperand(0),
                         ConstantInt::get(Ty, C.reverseBits()));
 
   case Intrinsic::ctlz:
   case Intrinsic::cttz: {
     // ctz(A) == bitwidth(A)  ->  A == 0 and likewise for !=
     if (C == BitWidth)
       return new ICmpInst(Pred, II->getArgOperand(0),
                           ConstantInt::getNullValue(Ty));
 
     // ctz(A) == C -> A & Mask1 == Mask2, where Mask2 only has bit C set
     // and Mask1 has bits 0..C+1 set. Similar for ctl, but for high bits.
     // Limit to one use to ensure we don't increase instruction count.
     unsigned Num = C.getLimitedValue(BitWidth);
     if (Num != BitWidth && II->hasOneUse()) {
       bool IsTrailing = II->getIntrinsicID() == Intrinsic::cttz;
       APInt Mask1 = IsTrailing ? APInt::getLowBitsSet(BitWidth, Num + 1)
                                : APInt::getHighBitsSet(BitWidth, Num + 1);
       APInt Mask2 = IsTrailing
         ? APInt::getOneBitSet(BitWidth, Num)
         : APInt::getOneBitSet(BitWidth, BitWidth - Num - 1);
       return new ICmpInst(Pred, Builder.CreateAnd(II->getArgOperand(0), Mask1),
                           ConstantInt::get(Ty, Mask2));
     }
     break;
   }
 
   case Intrinsic::ctpop: {
     // popcount(A) == 0  ->  A == 0 and likewise for !=
     // popcount(A) == bitwidth(A)  ->  A == -1 and likewise for !=
     bool IsZero = C.isZero();
     if (IsZero || C == BitWidth)
       return new ICmpInst(Pred, II->getArgOperand(0),
                           IsZero ? Constant::getNullValue(Ty)
                                  : Constant::getAllOnesValue(Ty));
 
     break;
   }
 
   case Intrinsic::fshl:
   case Intrinsic::fshr:
     if (II->getArgOperand(0) == II->getArgOperand(1)) {
       const APInt *RotAmtC;
       // ror(X, RotAmtC) == C --> X == rol(C, RotAmtC)
       // rol(X, RotAmtC) == C --> X == ror(C, RotAmtC)
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
     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));
     }
     break;
   }
   default:
     break;
   }
 
   return nullptr;
 }
 
 /// Fold an icmp with LLVM intrinsics
 static Instruction *
 foldICmpIntrinsicWithIntrinsic(ICmpInst &Cmp,
                                InstCombiner::BuilderTy &Builder) {
   assert(Cmp.isEquality());
 
Instruction *InstCombinerImpl::foldICmpBinOpWithConstant(ICmpInst &Cmp,
   default:
     break;
   }
 
   // TODO: These folds could be refactored to be part of the above calls.
   return foldICmpBinOpEqualityWithConstant(Cmp, BO, C);
 }
 
+static Instruction *
+foldICmpUSubSatWithConstant(ICmpInst::Predicate Pred, IntrinsicInst *II,
+                            const APInt &C, InstCombiner::BuilderTy &Builder) {
+  // This transform may end up producing more than one instruction for the
+  // intrinsic, so limit it to one user of the intrinsic.
+  if (!II->hasOneUse())
+    return nullptr;
+
+  // 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) 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);
+
+  // Check (0 pred C2)
+  auto [NewPred, LogicalOp] =
+      ICmpInst::compare(APInt::getZero(C.getBitWidth()), C, Pred)
+          ? std::make_pair(ICmpInst::ICMP_ULT, Instruction::BinaryOps::Or)
+          : std::make_pair(ICmpInst::ICMP_UGE, Instruction::BinaryOps::And);
+
+  const APInt *COp1;
+  // This transform only works when the usub_sat has an integral constant or
+  // splat vector as the second operand.
+  if (!match(Op1, m_APInt(COp1)))
+    return nullptr;
+
+  ConstantRange C1 = ConstantRange::makeExactICmpRegion(NewPred, *COp1);
+  // Convert '(X - C) pred C2' into 'X pred C2' shifted by C.
+  ConstantRange C2 = ConstantRange::makeExactICmpRegion(Pred, C);
+  C2 = C2.add(*COp1);
+
+  std::optional<ConstantRange> Combination;
+  if (LogicalOp == Instruction::BinaryOps::Or)
+    Combination = C1.exactUnionWith(C2);
+  else /* LogicalOp == Instruction::BinaryOps::And */
+    Combination = C1.exactIntersectWith(C2);
+
+  if (!Combination)
+    return nullptr;
+
+  CmpInst::Predicate EquivPred;
+  APInt EquivInt;
+  APInt EquivOffset;
+
+  Combination->getEquivalentICmp(EquivPred, EquivInt, EquivOffset);
+
+  return new ICmpInst(
+      EquivPred,
+      Builder.CreateAdd(Op0, ConstantInt::get(Op1->getType(), EquivOffset)),
+      ConstantInt::get(Op1->getType(), EquivInt));
+}
+
 /// Fold an icmp with LLVM intrinsic and constant operand: icmp Pred II, C.
 Instruction *InstCombinerImpl::foldICmpIntrinsicWithConstant(ICmpInst &Cmp,
                                                              IntrinsicInst *II,
                                                              const APInt &C) {
+  ICmpInst::Predicate Pred = Cmp.getPredicate();
+
+  // Handle folds that apply for any kind of icmp.
+  switch (II->getIntrinsicID()) {
+  default:
+    break;
+  case Intrinsic::usub_sat:
+    if (auto *Folded = foldICmpUSubSatWithConstant(Pred, II, C, Builder))
+      return Folded;
+    break;
+  }
+
   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 (ICmpInst::isSigned(Pred)) {
       // 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;
   default:
     break;
   }
 
   return nullptr;
 }
 
 /// Handle icmp with constant (but not simple integer constant) RHS.
 Instruction *InstCombinerImpl::foldICmpInstWithConstantNotInt(ICmpInst &I) {
   Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
   Constant *RHSC = dyn_cast<Constant>(Op1);
   Instruction *LHSI = dyn_cast<Instruction>(Op0);
   if (!RHSC || !LHSI)
     return nullptr;
 
   switch (LHSI->getOpcode()) {
   case Instruction::GetElementPtr:
     // icmp pred GEP (P, int 0, int 0, int 0), null -> icmp pred P, null
     if (RHSC->isNullValue() &&
         cast<GetElementPtrInst>(LHSI)->hasAllZeroIndices())
       return new ICmpInst(

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:    [[SUB:%.*]] = call i64 @llvm.usub.sat.i64(i64 [[ARG]], i64 5)
-; CHECK-NEXT:    [[CMP:%.*]] = icmp ult i64 [[SUB]], 2
+; CHECK-NEXT:    [[CMP:%.*]] = icmp ult i64 [[ARG]], 7
 ; CHECK-NEXT:    ret i1 [[CMP]]
 ;
   %sub = call i64 @llvm.usub.sat.i64(i64 %arg, i64 5)
   %cmp = icmp ult i64 %sub, 2
   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:    [[TMP1:%.*]] = add i32 [[ARG]], 2147483638
+; CHECK-NEXT:    [[CMP:%.*]] = icmp ult i32 [[TMP1]], -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:    [[TMP1:%.*]] = add i64 [[ARG]], 9223372036854775784
+; CHECK-NEXT:    [[CMP:%.*]] = icmp ult i64 [[TMP1]], -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:    [[TMP1:%.*]] = add i8 [[ARG]], -5
+; CHECK-NEXT:    [[CMP:%.*]] = icmp ult i8 [[TMP1]], 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:    [[TMP1:%.*]] = add i16 [[ARG]], -8
+; CHECK-NEXT:    [[CMP:%.*]] = icmp ult i16 [[TMP1]], 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:    [[SUB:%.*]] = call i8 @llvm.usub.sat.i8(i8 [[ARG]], i8 -20)
-; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i8 [[SUB]], 5
+; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i8 [[ARG]], -15
 ; CHECK-NEXT:    ret i1 [[CMP]]
 ;
   %sub = call i8 @llvm.usub.sat.i8(i8 %arg, i8 -20)
   %cmp = icmp eq i8 %sub, 5
   ret i1 %cmp
 }
 
 define i1 @icmp_ne_basic_negative(i16 %arg) {
 ; CHECK-LABEL: define i1 @icmp_ne_basic_negative
 ; CHECK-SAME: (i16 [[ARG:%.*]]) {
-; CHECK-NEXT:    [[SUB:%.*]] = call i16 @llvm.usub.sat.i16(i16 [[ARG]], i16 -80)
-; CHECK-NEXT:    [[CMP:%.*]] = icmp ne i16 [[SUB]], 9
+; CHECK-NEXT:    [[CMP:%.*]] = icmp ne i16 [[ARG]], -71
 ; CHECK-NEXT:    ret i1 [[CMP]]
 ;
   %sub = call i16 @llvm.usub.sat.i16(i16 %arg, i16 -80)
   %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) {
 ; CHECK-LABEL: define i1 @icmp_ult_basic_negative
 ; CHECK-SAME: (i64 [[ARG:%.*]]) {
-; CHECK-NEXT:    [[SUB:%.*]] = call i64 @llvm.usub.sat.i64(i64 [[ARG]], i64 -10)
-; CHECK-NEXT:    [[CMP:%.*]] = icmp ult i64 [[SUB]], 2
+; CHECK-NEXT:    [[CMP:%.*]] = icmp ult i64 [[ARG]], -8
 ; CHECK-NEXT:    ret i1 [[CMP]]
 ;
   %sub = call i64 @llvm.usub.sat.i64(i64 %arg, i64 -10)
   %cmp = icmp ult i64 %sub, 2
   ret i1 %cmp
 }
 
 define i1 @icmp_uge_basic_negative(i8 %arg) {
 ; CHECK-LABEL: define i1 @icmp_uge_basic_negative
 ; CHECK-SAME: (i8 [[ARG:%.*]]) {
-; CHECK-NEXT:    [[SUB:%.*]] = call i8 @llvm.usub.sat.i8(i8 [[ARG]], i8 -4)
-; CHECK-NEXT:    [[CMP:%.*]] = icmp ugt i8 [[SUB]], 1
+; CHECK-NEXT:    [[CMP:%.*]] = icmp ugt i8 [[ARG]], -3
 ; CHECK-NEXT:    ret i1 [[CMP]]
 ;
   %sub = call i8 @llvm.usub.sat.i8(i8 %arg, i8 -4)
   %cmp = icmp uge i8 %sub, 2
   ret i1 %cmp
 }
 
 define i1 @icmp_ugt_basic_negative(i16 %arg) {
 ; CHECK-LABEL: define i1 @icmp_ugt_basic_negative
 ; CHECK-SAME: (i16 [[ARG:%.*]]) {
-; CHECK-NEXT:    [[SUB:%.*]] = call i16 @llvm.usub.sat.i16(i16 [[ARG]], i16 -10)
-; CHECK-NEXT:    [[CMP:%.*]] = icmp ugt i16 [[SUB]], 3
+; CHECK-NEXT:    [[CMP:%.*]] = icmp ugt i16 [[ARG]], -7
 ; CHECK-NEXT:    ret i1 [[CMP]]
 ;
   %sub = call i16 @llvm.usub.sat.i16(i16 %arg, i16 -10)
   %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) {
 ; CHECK-LABEL: define i1 @icmp_sge_basic_negative
 ; CHECK-SAME: (i8 [[ARG:%.*]]) {
-; CHECK-NEXT:    [[SUB:%.*]] = call i8 @llvm.usub.sat.i8(i8 [[ARG]], i8 -10)
-; 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 -10)
   %cmp = icmp sge i8 %sub, 4
   ret i1 %cmp
 }
 
 define i1 @icmp_sgt_basic_negative(i16 %arg) {
 ; CHECK-LABEL: define i1 @icmp_sgt_basic_negative
 ; CHECK-SAME: (i16 [[ARG:%.*]]) {
-; CHECK-NEXT:    [[SUB:%.*]] = call i16 @llvm.usub.sat.i16(i16 [[ARG]], i16 -20)
-; CHECK-NEXT:    [[CMP:%.*]] = icmp ugt i16 [[SUB]], 5
+; CHECK-NEXT:    [[CMP:%.*]] = icmp ugt i16 [[ARG]], -15
 ; CHECK-NEXT:    ret i1 [[CMP]]
 ;
   %sub = call i16 @llvm.usub.sat.i16(i16 %arg, i16 -20)
   %cmp = icmp sgt i16 %sub, 5
   ret i1 %cmp
 }
 
 ; ==============================================================================

 }
 
 ; ==============================================================================
 ; Tests with vector types and positive arguments
 ; ==============================================================================
 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_positive_unequal(<2 x i8> %arg) {
 ; CHECK-LABEL: define <2 x i1> @icmp_eq_vector_positive_unequal
 ; 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 1, i8 2>)
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp eq <2 x i8> [[SUB]], <i8 5, i8 6>
 ; CHECK-NEXT:    ret <2 x i1> [[CMP]]
 ;
   %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:    [[TMP1:%.*]] = add <2 x i64> [[ARG]], <i64 -410858, i64 -410858>
+; CHECK-NEXT:    [[CMP:%.*]] = icmp ult <2 x i64> [[TMP1]], <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) {

 }
 
 ; ==============================================================================
 ; Tests with vector types and negative arguments
 ; ==============================================================================
 define <2 x i1> @icmp_eq_vector_negative_equal(<2 x i8> %arg) {
 ; CHECK-LABEL: define <2 x i1> @icmp_eq_vector_negative_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 -5, i8 -5>)
-; CHECK-NEXT:    [[CMP:%.*]] = icmp eq <2 x i8> [[SUB]], <i8 2, i8 2>
+; CHECK-NEXT:    [[CMP:%.*]] = icmp eq <2 x i8> [[ARG]], <i8 -3, i8 -3>
 ; CHECK-NEXT:    ret <2 x i1> [[CMP]]
 ;
   %sub = call <2 x i8> @llvm.usub.sat.v2i8(<2 x i8> %arg, <2 x i8> <i8 -5, i8 -5>)
   %cmp = icmp eq <2 x i8> %sub, <i8 2, i8 2>
   ret <2 x i1> %cmp
 }
 
 define <2 x i1> @icmp_eq_vector_negative_unequal(<2 x i8> %arg) {