[InstCombine] Canonicalize ssub.with.overflow to ssub.sat

[dmgreen]

Summary

Working on top of D69252, this adds canonicalisation patterns for ssub.with.overflow to ssub.sats.

These are the alive patterns being selected, all of which pass:

Name: SSub_x_lt0
  %ao = ssub_overflow i8 %x, %y
  %a = extractvalue %ao, 0
  %o = extractvalue %ao, 1
  %c = icmp slt i8 %x, 0
  %s = select i1 %c, i8 -128, i8 127
  %x5 = select i1 %o, i8 %s, i8 %a
=>
  %x5 = ssub_sat %x, %y

Name: SSub_x_lt1
  %ao = ssub_overflow i8 %x, %y
  %a = extractvalue %ao, 0
  %o = extractvalue %ao, 1
  %c = icmp slt i8 %x, -1
  %s = select i1 %c, i8 -128, i8 127
  %x5 = select i1 %o, i8 %s, i8 %a
=>
  %x5 = ssub_sat %x, %y

Name: SSub_x_lg2
; Not valid.
  %ao = ssub_overflow i8 %x, %y
  %a = extractvalue %ao, 0
  %o = extractvalue %ao, 1
  %c = icmp sgt i8 %x, -2
  %s = select i1 %c, i8 127, i8 -128
  %x5 = select i1 %o, i8 %s, i8 %a
=>
  %x5 = ssub_sat %x, %y

Name: SSub_x_lg1
  %ao = ssub_overflow i8 %x, %y
  %a = extractvalue %ao, 0
  %o = extractvalue %ao, 1
  %c = icmp sgt i8 %x, -1
  %s = select i1 %c, i8 127, i8 -128
  %x5 = select i1 %o, i8 %s, i8 %a
=>
  %x5 = ssub_sat %x, %y

Name: SSub_y_lt0
  %ao = ssub_overflow i8 %x, %y
  %a = extractvalue %ao, 0
  %o = extractvalue %ao, 1
  %c = icmp slt i8 %y, 0
  %s = select i1 %c, i8 127, i8 -128
  %x5 = select i1 %o, i8 %s, i8 %a
=>
  %x5 = ssub_sat %x, %y

Name: SSub_y_lt1
  %ao = ssub_overflow i8 %x, %y
  %a = extractvalue %ao, 0
  %o = extractvalue %ao, 1
  %c = icmp slt i8 %y, 1
  %s = select i1 %c, i8 127, i8 -128
  %x5 = select i1 %o, i8 %s, i8 %a
=>
  %x5 = ssub_sat %x, %y

Name: SSub_y_lg0
  %ao = ssub_overflow i8 %x, %y
  %a = extractvalue %ao, 0
  %o = extractvalue %ao, 1
  %c = icmp sgt i8 %y, 0
  %s = select i1 %c, i8 -128, i8 127
  %x5 = select i1 %o, i8 %s, i8 %a
=>
  %x5 = ssub_sat %x, %y

Name: SSub_y_lg1
  %ao = ssub_overflow i8 %x, %y
  %a = extractvalue %ao, 0
  %o = extractvalue %ao, 1
  %c = icmp sgt i8 %y, -1
  %s = select i1 %c, i8 -128, i8 127
  %x5 = select i1 %o, i8 %s, i8 %a
=>
  %x5 = ssub_sat %x, %y

[lebedev.ri]

Such a pattern matching maze, wow.
Looks correct to me, but wouldn't hurt if someone else could also take a look (@nikic? @spatel ?)

[spatel]

In D69753#1740120, @lebedev.ri wrote:

Such a pattern matching maze, wow.

It can at least be reduced similarly to the sadd_sat patch by bailing out early if Op is not X or Y. And maybe that makes it easier to combine the logic for ssub_sat and sadd_sat, but I'm not sure if that makes the code more confusing than it's worth.

Looks correct to me, but wouldn't hurt if someone else could also take a look (@nikic? @spatel ?)

Seems like the expected extension of the earlier patch, so LGTM.

[dmgreen]

Update/rebase. Let me know if there's a better way to structure this that you can think of.

[spatel]

In D69753#1740262, @dmgreen wrote:

Update/rebase. Let me know if there's a better way to structure this that you can think of.

Ah, I didn't catch that asymmetry between add (commutative) and sub (not commutative). I don't have any good suggestions to make it shorter. Even if there is, it's better to commit this as-is to make sure the logic is correct in this form vs. any non-obvious reduced form.

llvm/lib/Transforms/InstCombine/InstCombineSelect.cpp

static Instruction *foldAddSubSelect(SelectInst &SI,
   }
   return nullptr;
 }
 
 /// Turn X + Y overflows ? -1 : X + Y -> uadd_sat X, Y
 /// And X - Y overflows ? 0 : X - Y -> usub_sat X, Y
 /// Along with a number of patterns similar to:
 /// X + Y overflows ? (X < 0 ? INTMIN : INTMAX) : X + Y --> sadd_sat X, Y
+/// X - Y overflows ? (X > 0 ? INTMAX : INTMIN) : X - Y --> ssub_sat X, Y
 static Instruction *
 foldOverflowingAddSubSelect(SelectInst &SI, InstCombiner::BuilderTy &Builder) {
   Value *CondVal = SI.getCondition();
   Value *TrueVal = SI.getTrueValue();
   Value *FalseVal = SI.getFalseValue();
 
   WithOverflowInst *II;
   if (!match(CondVal, m_ExtractValue<1>(m_WithOverflowInst(II))) ||
       !match(FalseVal, m_ExtractValue<0>(m_Specific(II))))
     return nullptr;
 
   Value *X = II->getLHS();
   Value *Y = II->getRHS();
 
-  auto IsSignedSaturateLimit = [&](Value *Limit) {
+  auto IsSignedSaturateLimit = [&](Value *Limit, bool IsAdd) {
     Type *Ty = Limit->getType();
 
     ICmpInst::Predicate Pred;
     Value *TrueVal, *FalseVal, *Op;
     const APInt *C;
     if (!match(Limit, m_Select(m_ICmp(Pred, m_Value(Op), m_APInt(C)),
                                m_Value(TrueVal), m_Value(FalseVal))))
       return false;
 
     auto IsZeroOrOne = [](const APInt &C) {
       return C.isNullValue() || C.isOneValue();
     };
     auto IsMinMax = [&](Value *Min, Value *Max) {
       APInt MinVal = APInt::getSignedMinValue(Ty->getScalarSizeInBits());
       APInt MaxVal = APInt::getSignedMaxValue(Ty->getScalarSizeInBits());
       return match(Min, m_SpecificInt(MinVal)) &&
              match(Max, m_SpecificInt(MaxVal));
     };
 
     if (Op != X && Op != Y)
       return false;
 
+    if (IsAdd) {
       // X + Y overflows ? (X <s 0 ? INTMIN : INTMAX) : X + Y --> sadd_sat X, Y
       // X + Y overflows ? (X <s 1 ? INTMIN : INTMAX) : X + Y --> sadd_sat X, Y
       // X + Y overflows ? (Y <s 0 ? INTMIN : INTMAX) : X + Y --> sadd_sat X, Y
       // X + Y overflows ? (Y <s 1 ? INTMIN : INTMAX) : X + Y --> sadd_sat X, Y
       if (Pred == ICmpInst::ICMP_SLT && IsZeroOrOne(*C) &&
           IsMinMax(TrueVal, FalseVal))
         return true;
       // X + Y overflows ? (X >s 0 ? INTMAX : INTMIN) : X + Y --> sadd_sat X, Y
       // X + Y overflows ? (X >s -1 ? INTMAX : INTMIN) : X + Y --> sadd_sat X, Y
       // X + Y overflows ? (Y >s 0 ? INTMAX : INTMIN) : X + Y --> sadd_sat X, Y
       // X + Y overflows ? (Y >s -1 ? INTMAX : INTMIN) : X + Y --> sadd_sat X, Y
       if (Pred == ICmpInst::ICMP_SGT && IsZeroOrOne(*C + 1) &&
           IsMinMax(FalseVal, TrueVal))
         return true;
+    } else {
+      // X - Y overflows ? (X <s 0 ? INTMIN : INTMAX) : X - Y --> ssub_sat X, Y
+      // X - Y overflows ? (X <s -1 ? INTMIN : INTMAX) : X - Y --> ssub_sat X, Y
+      if (Op == X && Pred == ICmpInst::ICMP_SLT && IsZeroOrOne(*C + 1) &&
+          IsMinMax(TrueVal, FalseVal))
+        return true;
+      // X - Y overflows ? (X >s -1 ? INTMAX : INTMIN) : X - Y --> ssub_sat X, Y
+      // X - Y overflows ? (X >s -2 ? INTMAX : INTMIN) : X - Y --> ssub_sat X, Y
+      if (Op == X && Pred == ICmpInst::ICMP_SGT && IsZeroOrOne(*C + 2) &&
+          IsMinMax(FalseVal, TrueVal))
+        return true;
+      // X - Y overflows ? (Y <s 0 ? INTMAX : INTMIN) : X - Y --> ssub_sat X, Y
+      // X - Y overflows ? (Y <s 1 ? INTMAX : INTMIN) : X - Y --> ssub_sat X, Y
+      if (Op == Y && Pred == ICmpInst::ICMP_SLT && IsZeroOrOne(*C) &&
+          IsMinMax(FalseVal, TrueVal))
+        return true;
+      // X - Y overflows ? (Y >s 0 ? INTMIN : INTMAX) : X - Y --> ssub_sat X, Y
+      // X - Y overflows ? (Y >s -1 ? INTMIN : INTMAX) : X - Y --> ssub_sat X, Y
+      if (Op == Y && Pred == ICmpInst::ICMP_SGT && IsZeroOrOne(*C + 1) &&
+          IsMinMax(TrueVal, FalseVal))
+        return true;
+    }
 
     return false;
   };
 
   Intrinsic::ID NewIntrinsicID;
   if (II->getIntrinsicID() == Intrinsic::uadd_with_overflow &&
       match(TrueVal, m_AllOnes()))
     // X + Y overflows ? -1 : X + Y -> uadd_sat X, Y
     NewIntrinsicID = Intrinsic::uadd_sat;
   else if (II->getIntrinsicID() == Intrinsic::usub_with_overflow &&
            match(TrueVal, m_Zero()))
     // X - Y overflows ? 0 : X - Y -> usub_sat X, Y
     NewIntrinsicID = Intrinsic::usub_sat;
   else if (II->getIntrinsicID() == Intrinsic::sadd_with_overflow &&
-           IsSignedSaturateLimit(TrueVal))
+           IsSignedSaturateLimit(TrueVal, /*IsAdd=*/true))
     // X + Y overflows ? (X <s 0 ? INTMIN : INTMAX) : X + Y --> sadd_sat X, Y
     // X + Y overflows ? (X <s 1 ? INTMIN : INTMAX) : X + Y --> sadd_sat X, Y
     // X + Y overflows ? (X >s 0 ? INTMAX : INTMIN) : X + Y --> sadd_sat X, Y
     // X + Y overflows ? (X >s -1 ? INTMAX : INTMIN) : X + Y --> sadd_sat X, Y
     // X + Y overflows ? (Y <s 0 ? INTMIN : INTMAX) : X + Y --> sadd_sat X, Y
     // X + Y overflows ? (Y <s 1 ? INTMIN : INTMAX) : X + Y --> sadd_sat X, Y
     // X + Y overflows ? (Y >s 0 ? INTMAX : INTMIN) : X + Y --> sadd_sat X, Y
     // X + Y overflows ? (Y >s -1 ? INTMAX : INTMIN) : X + Y --> sadd_sat X, Y
     NewIntrinsicID = Intrinsic::sadd_sat;
+  else if (II->getIntrinsicID() == Intrinsic::ssub_with_overflow &&
+           IsSignedSaturateLimit(TrueVal, /*IsAdd=*/false))
+    // X - Y overflows ? (X <s 0 ? INTMIN : INTMAX) : X - Y --> ssub_sat X, Y
+    // X - Y overflows ? (X <s -1 ? INTMIN : INTMAX) : X - Y --> ssub_sat X, Y
+    // X - Y overflows ? (X >s -1 ? INTMAX : INTMIN) : X - Y --> ssub_sat X, Y
+    // X - Y overflows ? (X >s -2 ? INTMAX : INTMIN) : X - Y --> ssub_sat X, Y
+    // X - Y overflows ? (Y <s 0 ? INTMAX : INTMIN) : X - Y --> ssub_sat X, Y
+    // X - Y overflows ? (Y <s 1 ? INTMAX : INTMIN) : X - Y --> ssub_sat X, Y
+    // X - Y overflows ? (Y >s 0 ? INTMIN : INTMAX) : X - Y --> ssub_sat X, Y
+    // X - Y overflows ? (Y >s -1 ? INTMIN : INTMAX) : X - Y --> ssub_sat X, Y
+    NewIntrinsicID = Intrinsic::ssub_sat;
   else
     return nullptr;
 
   Function *F =
       Intrinsic::getDeclaration(SI.getModule(), NewIntrinsicID, SI.getType());
   return CallInst::Create(F, {X, Y});
 }
 

llvm/test/Transforms/InstCombine/overflow_to_sat.ll

;
   %c = icmp slt i8 %x, 0
   %s = select i1 %c, i8 127, i8 -128
   %r = select i1 %o, i8 %s, i8 %a
   ret i8 %r
 }
 
 define i8 @ssub_x_lt_max(i8 %x, i8 %y) {
 ; CHECK-LABEL: @ssub_x_lt_max(
-; CHECK-NEXT:    [[AO:%.*]] = tail call { i8, i1 } @llvm.ssub.with.overflow.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT:    [[O:%.*]] = extractvalue { i8, i1 } [[AO]], 1
-; CHECK-NEXT:    [[A:%.*]] = extractvalue { i8, i1 } [[AO]], 0
-; CHECK-NEXT:    [[C:%.*]] = icmp slt i8 [[X]], 0
-; CHECK-NEXT:    [[S:%.*]] = select i1 [[C]], i8 -128, i8 127
-; CHECK-NEXT:    [[R:%.*]] = select i1 [[O]], i8 [[S]], i8 [[A]]
+; CHECK-NEXT:    [[R:%.*]] = call i8 @llvm.ssub.sat.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
 ; CHECK-NEXT:    ret i8 [[R]]
 ;
   %ao = tail call { i8, i1 } @llvm.ssub.with.overflow.i8(i8 %x, i8 %y)
   %o = extractvalue { i8, i1 } %ao, 1
   %a = extractvalue { i8, i1 } %ao, 0
   %c = icmp slt i8 %x, 0
   %s = select i1 %c, i8 -128, i8 127
   %r = select i1 %o, i8 %s, i8 %a
;
   %c = icmp slt i8 %x, -1
   %s = select i1 %c, i8 127, i8 -128
   %r = select i1 %o, i8 %s, i8 %a
   ret i8 %r
 }
 
 define i8 @ssub_x_lt2_max(i8 %x, i8 %y) {
 ; CHECK-LABEL: @ssub_x_lt2_max(
-; CHECK-NEXT:    [[AO:%.*]] = tail call { i8, i1 } @llvm.ssub.with.overflow.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT:    [[O:%.*]] = extractvalue { i8, i1 } [[AO]], 1
-; CHECK-NEXT:    [[A:%.*]] = extractvalue { i8, i1 } [[AO]], 0
-; CHECK-NEXT:    [[C:%.*]] = icmp slt i8 [[X]], -1
-; CHECK-NEXT:    [[S:%.*]] = select i1 [[C]], i8 -128, i8 127
-; CHECK-NEXT:    [[R:%.*]] = select i1 [[O]], i8 [[S]], i8 [[A]]
+; CHECK-NEXT:    [[R:%.*]] = call i8 @llvm.ssub.sat.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
 ; CHECK-NEXT:    ret i8 [[R]]
 ;
   %ao = tail call { i8, i1 } @llvm.ssub.with.overflow.i8(i8 %x, i8 %y)
   %o = extractvalue { i8, i1 } %ao, 1
   %a = extractvalue { i8, i1 } %ao, 0
   %c = icmp slt i8 %x, -1
   %s = select i1 %c, i8 -128, i8 127
   %r = select i1 %o, i8 %s, i8 %a
;
   %c = icmp sgt i8 %x, 0
   %s = select i1 %c, i8 -128, i8 127
   %r = select i1 %o, i8 %s, i8 %a
   ret i8 %r
 }
 
 define i8 @ssub_x_ge_min(i8 %x, i8 %y) {
 ; CHECK-LABEL: @ssub_x_ge_min(
-; CHECK-NEXT:    [[AO:%.*]] = tail call { i8, i1 } @llvm.ssub.with.overflow.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT:    [[O:%.*]] = extractvalue { i8, i1 } [[AO]], 1
-; CHECK-NEXT:    [[A:%.*]] = extractvalue { i8, i1 } [[AO]], 0
-; CHECK-NEXT:    [[C:%.*]] = icmp sgt i8 [[X]], -1
-; CHECK-NEXT:    [[S:%.*]] = select i1 [[C]], i8 127, i8 -128
-; CHECK-NEXT:    [[R:%.*]] = select i1 [[O]], i8 [[S]], i8 [[A]]
+; CHECK-NEXT:    [[R:%.*]] = call i8 @llvm.ssub.sat.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
 ; CHECK-NEXT:    ret i8 [[R]]
 ;
   %ao = tail call { i8, i1 } @llvm.ssub.with.overflow.i8(i8 %x, i8 %y)
   %o = extractvalue { i8, i1 } %ao, 1
   %a = extractvalue { i8, i1 } %ao, 0
   %c = icmp sge i8 %x, 0
   %s = select i1 %c, i8 127, i8 -128
   %r = select i1 %o, i8 %s, i8 %a
;
   %c = icmp sge i8 %x, 0
   %s = select i1 %c, i8 -128, i8 127
   %r = select i1 %o, i8 %s, i8 %a
   ret i8 %r
 }
 
 define i8 @ssub_x_gt2_min(i8 %x, i8 %y) {
 ; CHECK-LABEL: @ssub_x_gt2_min(
-; CHECK-NEXT:    [[AO:%.*]] = tail call { i8, i1 } @llvm.ssub.with.overflow.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT:    [[O:%.*]] = extractvalue { i8, i1 } [[AO]], 1
-; CHECK-NEXT:    [[A:%.*]] = extractvalue { i8, i1 } [[AO]], 0
-; CHECK-NEXT:    [[C:%.*]] = icmp sgt i8 [[X]], -2
-; CHECK-NEXT:    [[S:%.*]] = select i1 [[C]], i8 127, i8 -128
-; CHECK-NEXT:    [[R:%.*]] = select i1 [[O]], i8 [[S]], i8 [[A]]
+; CHECK-NEXT:    [[R:%.*]] = call i8 @llvm.ssub.sat.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
 ; CHECK-NEXT:    ret i8 [[R]]
 ;
   %ao = tail call { i8, i1 } @llvm.ssub.with.overflow.i8(i8 %x, i8 %y)
   %o = extractvalue { i8, i1 } %ao, 1
   %a = extractvalue { i8, i1 } %ao, 0
   %c = icmp sgt i8 %x, -2
   %s = select i1 %c, i8 127, i8 -128
   %r = select i1 %o, i8 %s, i8 %a
;
   %s = select i1 %c, i8 -128, i8 127
   %r = select i1 %o, i8 %s, i8 %a
   ret i8 %r
 }
 
 
 define i8 @ssub_y_lt_min(i8 %x, i8 %y) {
 ; CHECK-LABEL: @ssub_y_lt_min(
-; CHECK-NEXT:    [[AO:%.*]] = tail call { i8, i1 } @llvm.ssub.with.overflow.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT:    [[O:%.*]] = extractvalue { i8, i1 } [[AO]], 1
-; CHECK-NEXT:    [[A:%.*]] = extractvalue { i8, i1 } [[AO]], 0
-; CHECK-NEXT:    [[C:%.*]] = icmp slt i8 [[Y]], 0
-; CHECK-NEXT:    [[S:%.*]] = select i1 [[C]], i8 127, i8 -128
-; CHECK-NEXT:    [[R:%.*]] = select i1 [[O]], i8 [[S]], i8 [[A]]
+; CHECK-NEXT:    [[R:%.*]] = call i8 @llvm.ssub.sat.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
 ; CHECK-NEXT:    ret i8 [[R]]
 ;
   %ao = tail call { i8, i1 } @llvm.ssub.with.overflow.i8(i8 %x, i8 %y)
   %o = extractvalue { i8, i1 } %ao, 1
   %a = extractvalue { i8, i1 } %ao, 0
   %c = icmp slt i8 %y, 0
   %s = select i1 %c, i8 127, i8 -128
   %r = select i1 %o, i8 %s, i8 %a
;
   %c = icmp slt i8 %y, 0
   %s = select i1 %c, i8 -128, i8 127
   %r = select i1 %o, i8 %s, i8 %a
   ret i8 %r
 }
 
 define i8 @ssub_y_le_min(i8 %x, i8 %y) {
 ; CHECK-LABEL: @ssub_y_le_min(
-; CHECK-NEXT:    [[AO:%.*]] = tail call { i8, i1 } @llvm.ssub.with.overflow.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT:    [[O:%.*]] = extractvalue { i8, i1 } [[AO]], 1
-; CHECK-NEXT:    [[A:%.*]] = extractvalue { i8, i1 } [[AO]], 0
-; CHECK-NEXT:    [[C:%.*]] = icmp slt i8 [[Y]], 1
-; CHECK-NEXT:    [[S:%.*]] = select i1 [[C]], i8 127, i8 -128
-; CHECK-NEXT:    [[R:%.*]] = select i1 [[O]], i8 [[S]], i8 [[A]]
+; CHECK-NEXT:    [[R:%.*]] = call i8 @llvm.ssub.sat.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
 ; CHECK-NEXT:    ret i8 [[R]]
 ;
   %ao = tail call { i8, i1 } @llvm.ssub.with.overflow.i8(i8 %x, i8 %y)
   %o = extractvalue { i8, i1 } %ao, 1
   %a = extractvalue { i8, i1 } %ao, 0
   %c = icmp sle i8 %y, 0
   %s = select i1 %c, i8 127, i8 -128
   %r = select i1 %o, i8 %s, i8 %a
;
   %c = icmp sgt i8 %y, 0
   %s = select i1 %c, i8 127, i8 -128
   %r = select i1 %o, i8 %s, i8 %a
   ret i8 %r
 }
 
 define i8 @ssub_y_gt_max(i8 %x, i8 %y) {
 ; CHECK-LABEL: @ssub_y_gt_max(
-; CHECK-NEXT:    [[AO:%.*]] = tail call { i8, i1 } @llvm.ssub.with.overflow.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT:    [[O:%.*]] = extractvalue { i8, i1 } [[AO]], 1
-; CHECK-NEXT:    [[A:%.*]] = extractvalue { i8, i1 } [[AO]], 0
-; CHECK-NEXT:    [[C:%.*]] = icmp sgt i8 [[Y]], 0
-; CHECK-NEXT:    [[S:%.*]] = select i1 [[C]], i8 -128, i8 127
-; CHECK-NEXT:    [[R:%.*]] = select i1 [[O]], i8 [[S]], i8 [[A]]
+; CHECK-NEXT:    [[R:%.*]] = call i8 @llvm.ssub.sat.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
 ; CHECK-NEXT:    ret i8 [[R]]
 ;
   %ao = tail call { i8, i1 } @llvm.ssub.with.overflow.i8(i8 %x, i8 %y)
   %o = extractvalue { i8, i1 } %ao, 1
   %a = extractvalue { i8, i1 } %ao, 0
   %c = icmp sgt i8 %y, 0
   %s = select i1 %c, i8 -128, i8 127
   %r = select i1 %o, i8 %s, i8 %a
;
   %c = icmp sge i8 %y, 0
   %s = select i1 %c, i8 127, i8 -128
   %r = select i1 %o, i8 %s, i8 %a
   ret i8 %r
 }
 
 define i8 @ssub_y_ge_max(i8 %x, i8 %y) {
 ; CHECK-LABEL: @ssub_y_ge_max(
-; CHECK-NEXT:    [[AO:%.*]] = tail call { i8, i1 } @llvm.ssub.with.overflow.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT:    [[O:%.*]] = extractvalue { i8, i1 } [[AO]], 1
-; CHECK-NEXT:    [[A:%.*]] = extractvalue { i8, i1 } [[AO]], 0
-; CHECK-NEXT:    [[C:%.*]] = icmp sgt i8 [[Y]], -1
-; CHECK-NEXT:    [[S:%.*]] = select i1 [[C]], i8 -128, i8 127
-; CHECK-NEXT:    [[R:%.*]] = select i1 [[O]], i8 [[S]], i8 [[A]]
+; CHECK-NEXT:    [[R:%.*]] = call i8 @llvm.ssub.sat.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
 ; CHECK-NEXT:    ret i8 [[R]]
 ;
   %ao = tail call { i8, i1 } @llvm.ssub.with.overflow.i8(i8 %x, i8 %y)
   %o = extractvalue { i8, i1 } %ao, 1
   %a = extractvalue { i8, i1 } %ao, 0
   %c = icmp sge i8 %y, 0
   %s = select i1 %c, i8 -128, i8 127
   %r = select i1 %o, i8 %s, i8 %a
;
   %c = icmp slt i32 %x, 0
   %s = select i1 %c, i32 -2147483648, i32 2147483647
   %r = select i1 %o, i32 %s, i32 %a
   ret i32 %r
 }
 
 define i32 @ssub_i32(i32 %x, i32 %y) {
 ; CHECK-LABEL: @ssub_i32(
-; CHECK-NEXT:    [[AO:%.*]] = tail call { i32, i1 } @llvm.ssub.with.overflow.i32(i32 [[X:%.*]], i32 [[Y:%.*]])
-; CHECK-NEXT:    [[O:%.*]] = extractvalue { i32, i1 } [[AO]], 1
-; CHECK-NEXT:    [[A:%.*]] = extractvalue { i32, i1 } [[AO]], 0
-; CHECK-NEXT:    [[C:%.*]] = icmp slt i32 [[X]], 0
-; CHECK-NEXT:    [[S:%.*]] = select i1 [[C]], i32 -2147483648, i32 2147483647
-; CHECK-NEXT:    [[R:%.*]] = select i1 [[O]], i32 [[S]], i32 [[A]]
+; CHECK-NEXT:    [[R:%.*]] = call i32 @llvm.ssub.sat.i32(i32 [[X:%.*]], i32 [[Y:%.*]])
 ; CHECK-NEXT:    ret i32 [[R]]
 ;
   %ao = tail call { i32, i1 } @llvm.ssub.with.overflow.i32(i32 %x, i32 %y)
   %o = extractvalue { i32, i1 } %ao, 1
   %a = extractvalue { i32, i1 } %ao, 0
   %c = icmp slt i32 %x, 0
   %s = select i1 %c, i32 -2147483648, i32 2147483647
   %r = select i1 %o, i32 %s, i32 %a