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

[dmgreen]

Summary

This adds to D69245, adding extra signed patterns for folding from a sadd_with_overflow to a sadd_sat. These are more complex than the unsigned patterns, as the overflow can occur in either direction.

For the add case, the positive overflow can only occur if both of the values are positive (same for both the values being negative). So there is an extra select on whether to use the positive or negative overflow limit.

[dmgreen]

Just a rebase.

[lebedev.ri]

This patch is doing too much at once - i think there are ~14 folds being added here.

llvm/lib/Transforms/InstCombine/InstCombineSelect.cpp

1772

s/A/TrueVal/, s/B/FalseVal/

1822

/*IsAdd=*/true

1833

/*IsAdd=*/false

[dmgreen]

Yeah, this one got a bit big! Let me at least split it in half.

[dmgreen]

Split out the subs, leaving just the adds here

[dmgreen]

Alives, all of which pass:

Name: SAdd_x_lt0
  %ao = sadd_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 = sadd_sat %x, %y

Name: SAdd_x_lt1
  %ao = sadd_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 = sadd_sat %x, %y

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

Name: SAdd_x_lg1
  %ao = sadd_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 = sadd_sat %x, %y

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

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

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

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

[dmgreen]

Updated the patterns to be more straight forward.

[spatel]

LGTM (but give @lebedev.ri a chance to comment again too)

llvm/lib/Transforms/InstCombine/InstCombineSelect.cpp

1765–1766

Sink these values to their uses in IsMinMax()?

1775

Probably want to make this a const reference (avoid copy for crazy big numbers).

[lebedev.ri]

Not a fan of such large amount of patterns.
There's obvious duplication here:

llvm/lib/Transforms/InstCombine/InstCombineSelect.cpp

1782

if(Op != X && Op != Y)
  return false;

1785–1790

drop Op == X &&

1793–1802

drop

[lebedev.ri]

In D69252#1734436, @lebedev.ri wrote:

Not a fan of such large amount of patterns.
There's obvious duplication here:

To be noted, those can be fixed when committing, no need for further review.

[dmgreen]

Right. I was aiming for a symmetry between the adds and the subs. But you are probably correct that it's better simplified like this.

llvm/lib/Transforms/InstCombine/InstCombineSelect.cpp

if (OtherAddOp) {
         return RI;
       } else
         return BinaryOperator::CreateAdd(SubOp->getOperand(0), NewSel);
     }
   }
   return nullptr;
 }
 
-/// Turn A, O = uadd.with.overflow X, Y; O ? -1 : A --> uadd_sat X, Y
-/// And A, O = usub.with.overflow X, Y; O ? 0 : A --> usub_sat X, Y
+/// 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) {
   auto *CondVal = dyn_cast<ExtractValueInst>(SI.getCondition());
   Value *TrueVal = SI.getTrueValue();
   auto *FalseVal = dyn_cast<ExtractValueInst>(SI.getFalseValue());
   if (!CondVal || !FalseVal)
     return nullptr;
 
   // Check the extracts point to the same instruction
   if (CondVal->getNumIndices() != 1 || CondVal->getIndices()[0] != 1)
     return nullptr;
   if (FalseVal->getNumIndices() != 1 || FalseVal->getIndices()[0] != 0)
     return nullptr;
   if (CondVal->getAggregateOperand() != FalseVal->getAggregateOperand())
     return nullptr;
   auto *II = dyn_cast<IntrinsicInst>(CondVal->getAggregateOperand());
   if (!II)
     return nullptr;
 
+  Value *Op1 = II->getArgOperand(0);
+  Value *Op2 = II->getArgOperand(1);
+
+  auto IsSignedSaturateLimit = [&](Value *Limit, bool IsAdd) {
+    Type *Ty = Limit->getType();
+    APInt MinVal = APInt::getSignedMinValue(Ty->getScalarSizeInBits());
+    APInt MaxVal = APInt::getSignedMaxValue(Ty->getScalarSizeInBits());
+
+    ICmpInst::Predicate Pred;
+    Value *A, *B, *Op;
+    const APInt *C;
+    if (!match(Limit, m_Select(m_ICmp(Pred, m_Value(Op), m_APInt(C)),
+                               m_Value(A), m_Value(B))))
+      return false;
+
+    // This set:
+    // 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
+    // X - Y overflows ? (X <s 0 ? INTMIN : INTMAX) : 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
+    if (match(A, m_SpecificInt(MinVal)) && match(B, m_SpecificInt(MaxVal))) {
+      if (Pred == ICmpInst::ICMP_SLT && C->isNullValue())
+        return Op == Op1 || (IsAdd && Op == Op2);
+      if (Pred == ICmpInst::ICMP_SLT && C->isOneValue())
+        return IsAdd && (Op == Op1 || Op == Op2);
+      if (Pred == ICmpInst::ICMP_SGT &&
+          (C->isAllOnesValue() || C->isNullValue()))
+        return !IsAdd && Op == Op2;
+    }
+    // This set:
+    // 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
+    // X - Y overflows ? (X >s -1 ? 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
+    if (match(A, m_SpecificInt(MaxVal)) && match(B, m_SpecificInt(MinVal))) {
+      if (Pred == ICmpInst::ICMP_SGT && C->isAllOnesValue())
+        return Op == Op1 || (IsAdd && Op == Op2);
+      if (Pred == ICmpInst::ICMP_SGT && C->isNullValue())
+        return IsAdd && (Op == Op1 || Op == Op2);
+      if (Pred == ICmpInst::ICMP_SLT && (C->isOneValue() || C->isNullValue()))
+        return !IsAdd && Op == Op2;
+    }
+
+    return false;
+  };
+
   Intrinsic::ID NewIntrinsicID;
   if (II->getIntrinsicID() == Intrinsic::uadd_with_overflow &&
       match(TrueVal, m_AllOnes()))
-    // A, O = uadd.with.overflow X, Y; O ? -1 : A --> uadd_sat X, Y
+    // 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()))
-    // A, O = usub.with.overflow X, Y; O ? 0 : A --> usub_sat X, Y
+    // X - Y overflows ? 0 : X - Y -> usub_sat X, Y
     NewIntrinsicID = Intrinsic::usub_sat;
+  else if (II->getIntrinsicID() == Intrinsic::sadd_with_overflow &&
+           IsSignedSaturateLimit(TrueVal, 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, false))
+    // X - Y overflows ? (X <s 0 ? 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 ? (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, {II->getArgOperand(0), II->getArgOperand(1)});
+  return CallInst::Create(F, {Op1, Op2});
 }
 
 Instruction *InstCombiner::foldSelectExtConst(SelectInst &Sel) {
   Constant *C;
   if (!match(Sel.getTrueValue(), m_Constant(C)) &&
       !match(Sel.getFalseValue(), m_Constant(C)))
     return nullptr;
 

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 @sadd_x_lt_max(i8 %x, i8 %y) {
 ; CHECK-LABEL: @sadd_x_lt_max(
-; CHECK-NEXT:    [[AO:%.*]] = tail call { i8, i1 } @llvm.sadd.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.sadd.sat.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
 ; CHECK-NEXT:    ret i8 [[R]]
 ;
   %ao = tail call { i8, i1 } @llvm.sadd.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 sle i8 %x, 0
   %s = select i1 %c, i8 127, i8 -128
   %r = select i1 %o, i8 %s, i8 %a
   ret i8 %r
 }
 
 define i8 @sadd_x_le_max(i8 %x, i8 %y) {
 ; CHECK-LABEL: @sadd_x_le_max(
-; CHECK-NEXT:    [[AO:%.*]] = tail call { i8, i1 } @llvm.sadd.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.sadd.sat.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
 ; CHECK-NEXT:    ret i8 [[R]]
 ;
   %ao = tail call { i8, i1 } @llvm.sadd.with.overflow.i8(i8 %x, i8 %y)
   %o = extractvalue { i8, i1 } %ao, 1
   %a = extractvalue { i8, i1 } %ao, 0
   %c = icmp sle i8 %x, 0
   %s = select i1 %c, i8 -128, i8 127
   %r = select i1 %o, i8 %s, i8 %a
   ret i8 %r
 }
 
 define i8 @sadd_x_gt_min(i8 %x, i8 %y) {
 ; CHECK-LABEL: @sadd_x_gt_min(
-; CHECK-NEXT:    [[AO:%.*]] = tail call { i8, i1 } @llvm.sadd.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]], 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.sadd.sat.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
 ; CHECK-NEXT:    ret i8 [[R]]
 ;
   %ao = tail call { i8, i1 } @llvm.sadd.with.overflow.i8(i8 %x, i8 %y)
   %o = extractvalue { i8, i1 } %ao, 1
   %a = extractvalue { i8, i1 } %ao, 0
   %c = icmp sgt i8 %x, 0
   %s = select i1 %c, i8 127, i8 -128
   %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 @sadd_x_ge_min(i8 %x, i8 %y) {
 ; CHECK-LABEL: @sadd_x_ge_min(
-; CHECK-NEXT:    [[AO:%.*]] = tail call { i8, i1 } @llvm.sadd.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.sadd.sat.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
 ; CHECK-NEXT:    ret i8 [[R]]
 ;
   %ao = tail call { i8, i1 } @llvm.sadd.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 slt i8 %y, 0
   %s = select i1 %c, i8 127, i8 -128
   %r = select i1 %o, i8 %s, i8 %a
   ret i8 %r
 }
 
 define i8 @sadd_y_lt_max(i8 %x, i8 %y) {
 ; CHECK-LABEL: @sadd_y_lt_max(
-; CHECK-NEXT:    [[AO:%.*]] = tail call { i8, i1 } @llvm.sadd.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 -128, i8 127
-; CHECK-NEXT:    [[R:%.*]] = select i1 [[O]], i8 [[S]], i8 [[A]]
+; CHECK-NEXT:    [[R:%.*]] = call i8 @llvm.sadd.sat.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
 ; CHECK-NEXT:    ret i8 [[R]]
 ;
   %ao = tail call { i8, i1 } @llvm.sadd.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 -128, i8 127
   %r = select i1 %o, i8 %s, i8 %a
;
   %c = icmp sle i8 %y, 0
   %s = select i1 %c, i8 127, i8 -128
   %r = select i1 %o, i8 %s, i8 %a
   ret i8 %r
 }
 
 define i8 @sadd_y_le_max(i8 %x, i8 %y) {
 ; CHECK-LABEL: @sadd_y_le_max(
-; CHECK-NEXT:    [[AO:%.*]] = tail call { i8, i1 } @llvm.sadd.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 -128, i8 127
-; CHECK-NEXT:    [[R:%.*]] = select i1 [[O]], i8 [[S]], i8 [[A]]
+; CHECK-NEXT:    [[R:%.*]] = call i8 @llvm.sadd.sat.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
 ; CHECK-NEXT:    ret i8 [[R]]
 ;
   %ao = tail call { i8, i1 } @llvm.sadd.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 -128, i8 127
   %r = select i1 %o, i8 %s, i8 %a
   ret i8 %r
 }
 
 define i8 @sadd_y_gt_min(i8 %x, i8 %y) {
 ; CHECK-LABEL: @sadd_y_gt_min(
-; CHECK-NEXT:    [[AO:%.*]] = tail call { i8, i1 } @llvm.sadd.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 127, i8 -128
-; CHECK-NEXT:    [[R:%.*]] = select i1 [[O]], i8 [[S]], i8 [[A]]
+; CHECK-NEXT:    [[R:%.*]] = call i8 @llvm.sadd.sat.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
 ; CHECK-NEXT:    ret i8 [[R]]
 ;
   %ao = tail call { i8, i1 } @llvm.sadd.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 127, i8 -128
   %r = select i1 %o, i8 %s, i8 %a
;
   %c = icmp sgt i8 %y, 0
   %s = select i1 %c, i8 -128, i8 127
   %r = select i1 %o, i8 %s, i8 %a
   ret i8 %r
 }
 
 define i8 @sadd_y_ge_min(i8 %x, i8 %y) {
 ; CHECK-LABEL: @sadd_y_ge_min(
-; CHECK-NEXT:    [[AO:%.*]] = tail call { i8, i1 } @llvm.sadd.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 127, i8 -128
-; CHECK-NEXT:    [[R:%.*]] = select i1 [[O]], i8 [[S]], i8 [[A]]
+; CHECK-NEXT:    [[R:%.*]] = call i8 @llvm.sadd.sat.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
 ; CHECK-NEXT:    ret i8 [[R]]
 ;
   %ao = tail call { i8, i1 } @llvm.sadd.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 127, i8 -128
   %r = select i1 %o, i8 %s, i8 %a
;
   %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 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
;
   %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
   ret i8 %r
 }
 
 
 define i32 @sadd_i32(i32 %x, i32 %y) {
 ; CHECK-LABEL: @sadd_i32(
-; CHECK-NEXT:    [[AO:%.*]] = tail call { i32, i1 } @llvm.sadd.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.sadd.sat.i32(i32 [[X:%.*]], i32 [[Y:%.*]])
 ; CHECK-NEXT:    ret i32 [[R]]
 ;
   %ao = tail call { i32, i1 } @llvm.sadd.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
   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