[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

1762

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

1804

/*IsAdd=*/true

1815

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

1755–1756

Sink these values to their uses in IsMinMax()?

1765

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

1772

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

1775–1780

drop Op == X &&

1783–1792

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 BinaryOperator::CreateAdd(SubOp->getOperand(0), NewSel);
     }
   }
   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
 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) {
+    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;
+
+    // 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;
+
+    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))
+    // 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
     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, {X, Y});
 }
 
 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
;
   %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