[InstructionSimplify] Add support for saturating add/sub

[nikic]

Summary

Add support for saturating add/sub in InstructionSimplify. In particular, the following simplifications are supported:

• sat(X + 0) -> X
• sat(X + undef) -> -1
• sat(X uadd MAX) -> MAX
• (and commutative variants)

• sat(X - 0) -> X
• sat(X - X) -> 0
• sat(X - undef) -> 0
• sat(undef - X) -> 0
• sat(0 usub X) -> 0
• sat(X usub MAX) -> 0

[spatel]

test/Transforms/InstSimplify/saturating-add-sub.ll

62 ↗

(On Diff #174047)

This result doesn't match the scalar logic for undefs. I didn't step through it, but I'm guessing it's because <i8 undef, i8, undef> matched successfully with m_AllOnes(). Not sure if that should be considered a bug or not.

Generally, we do folds with undef operands before anything else, so we don't see that potential difference. If that doesn't resolve it, then there's definitely an underlying bug in m_Undef().

Nit 1: I prefer that each test is its own function. I had to step back through the CHECK lines twice to make sure I wasn't seeing things. If each test was its own function, you could interleave scalar/vector, and it would be more obvious if there was a difference between those.

Nit 2: Please commit the tests to trunk with baseline CHECKs as a preliminary commit to the actual code commit. That way, we won't lose the test coverage even if the code patch is reverted for some reason.

[spatel]

test/Transforms/InstSimplify/saturating-add-sub.ll

76 ↗

(On Diff #174047)

Looking at the matcher implementation, just rearranging the code in this patch isn't going to cover up the discrepancy between scalar and vector. If you want to ignore that to make progress here, just adjust this test with the standard spelling of vector undef:

%x4 = call <2 x i8> @llvm.uadd.sat.v2i8(<2 x i8> %a, <2 x i8> undef)

[nikic]

test/Transforms/InstSimplify/saturating-add-sub.ll

62 ↗

(On Diff #174047)

I think that the matcher issue is a bug, and have submitted D54631 to fix it. At least this behavior should be consistent, i.e. either m_AllOnes() matches both scalar and vector undef, or it matches neither. Right now it matches vector, but not scalar, which is neither here nor there...

I also checked whether using <2 x i8> undef allows us to work around the problem for the purposes of this test, but it does not change the result. I'm assuming that <2 x i8> <i8 undef, i8 undef> gets normalized to <2 x i8> undef at some point.

Changing the check order so that the undef check comes first would work, but I'd prefer to fix the matcher implementation than have this somewhat subtle workaround.

Regarding commits, I don't have commit access so can't apply those directly. Should I open another patch that includes just the baseline checks?

[spatel]

test/Transforms/InstSimplify/saturating-add-sub.ll

62 ↗

(On Diff #174047)

Thanks - I wasn't sure if you were willing to fix the underlying problem, so that's the reason I suggested the work-around for this patch.

You're correct that <2 x i8> <i8 undef, i8 undef> becomes <2 x i8> undef. That should be somewhere in ConstantFolding.

I will commit the baseline test files on your behalf shortly. Then, you can rebase D54631 and this one.

[spatel]

test/Transforms/InstSimplify/saturating-add-sub.ll

170 ↗

(On Diff #174047)

That should be "ssub" not "usub". Have a look at:
rL347060
and make sure I didn't introduce any typos while translating the tests to separate functions.

[nikic]

Rebase over baseline test.

[nikic]

test/Transforms/InstSimplify/saturating-add-sub.ll

170 ↗

(On Diff #174047)

Thanks a lot for splitting up the tests! I've now rebased and updated the test output. I made two minor adjustments in the tests: In usub_vector_undef I changed the RHS to undef,undef (as 0,undef is effectively 0). In usub_vector_undef_commute I moved the undef operand to the LHS.

[spatel]

lib/Analysis/InstructionSimplify.cpp

4925–4928 ↗

(On Diff #174391)

It's slightly better to return a constant when one of the operands is undef because that eliminates the use of a variable. That also matches the behavior of the subtracts.

For sadd_sat, we can always return 0, and for uadd_sat, we can always return -1?

[nikic]

lib/Analysis/InstructionSimplify.cpp

4925–4928 ↗

(On Diff #174391)

The question of undef handling is also discussed here: https://reviews.llvm.org/D54237#1294571

The problem is that we can't return 0 for sadd_sat, due to the asymmetric range for signed integers. If one operand is -128, the largest number you can reach is -128 + 127 = -1, not 0. That's why I'm returning the other operand here, so that handling is consistent for uadd/sadd.

But ... now that I think about it, shouldn't it be legal to return -1 for *both* the signed and the unsigned case?

[spatel]

lib/Analysis/InstructionSimplify.cpp

4925–4928 ↗

(On Diff #174391)

Return -1 for both sounds good to me. cc'ing @nlopes in case he sees an alternative.

In the earlier discussion, you said (uadd_sat X, undef) could return 0, but I don't think that's possible. Say for example that X=42. There's no undef value that we can add to get us to 0 (or any value <42). uadd_sat must go to all-ones or choose "0" as the undef and return X.

[nikic]

Return -1 for both signed and unsigned saturating addition with undef operand.

[spatel]

LGTM.

Have you requested commit privileges?

[nikic]

I've requested commit access, but would prefer it if you could commit these patches in the meantime, to avoid holding things up for too long.

llvm/trunk/lib/Analysis/InstructionSimplify.cpp

case Intrinsic::smul_with_overflow:
     // X * 0 -> { 0, false }
     if (match(Op0, m_Zero()) || match(Op1, m_Zero()))
       return Constant::getNullValue(ReturnType);
     // undef * X -> { 0, false }
     // X * undef -> { 0, false }
     if (match(Op0, m_Undef()) || match(Op1, m_Undef()))
       return Constant::getNullValue(ReturnType);
     break;
+  case Intrinsic::uadd_sat:
+    // sat(MAX + X) -> MAX
+    // sat(X + MAX) -> MAX
+    if (match(Op0, m_AllOnes()) || match(Op1, m_AllOnes()))
+      return Constant::getAllOnesValue(ReturnType);
+    LLVM_FALLTHROUGH;
+  case Intrinsic::sadd_sat:
+    // sat(X + undef) -> -1
+    // sat(undef + X) -> -1
+    // For unsigned: Assume undef is MAX, thus we saturate to MAX (-1).
+    // For signed: Assume undef is ~X, in which case X + ~X = -1.
+    if (match(Op0, m_Undef()) || match(Op1, m_Undef()))
+      return Constant::getAllOnesValue(ReturnType);
+
+    // X + 0 -> X
+    if (match(Op1, m_Zero()))
+      return Op0;
+    // 0 + X -> X
+    if (match(Op0, m_Zero()))
+      return Op1;
+    break;
+  case Intrinsic::usub_sat:
+    // sat(0 - X) -> 0, sat(X - MAX) -> 0
+    if (match(Op0, m_Zero()) || match(Op1, m_AllOnes()))
+      return Constant::getNullValue(ReturnType);
+    LLVM_FALLTHROUGH;
+  case Intrinsic::ssub_sat:
+    // X - X -> 0, X - undef -> 0, undef - X -> 0
+    if (Op0 == Op1 || match(Op0, m_Undef()) || match(Op1, m_Undef()))
+      return Constant::getNullValue(ReturnType);
+    // X - 0 -> X
+    if (match(Op1, m_Zero()))
+      return Op0;
+    break;
   case Intrinsic::load_relative:
     if (auto *C0 = dyn_cast<Constant>(Op0))
       if (auto *C1 = dyn_cast<Constant>(Op1))
         return SimplifyRelativeLoad(C0, C1, Q.DL);
     break;
   case Intrinsic::powi:
     if (auto *Power = dyn_cast<ConstantInt>(Op1)) {
       // powi(x, 0) -> 1.0

llvm/trunk/test/Transforms/InstSimplify/saturating-add-sub.ll

 
 declare i8 @llvm.usub.sat.i8(i8, i8)
 declare i8 @llvm.ssub.sat.i8(i8, i8)
 declare <2 x i8> @llvm.usub.sat.v2i8(<2 x i8>, <2 x i8>)
 declare <2 x i8> @llvm.ssub.sat.v2i8(<2 x i8>, <2 x i8>)
 
 define i8 @uadd_scalar_0(i8 %a) {
 ; CHECK-LABEL: @uadd_scalar_0(
-; CHECK-NEXT:    [[X1:%.*]] = call i8 @llvm.uadd.sat.i8(i8 [[A:%.*]], i8 0)
-; CHECK-NEXT:    ret i8 [[X1]]
+; CHECK-NEXT:    ret i8 [[A:%.*]]
 ;
   %x1 = call i8 @llvm.uadd.sat.i8(i8 %a, i8 0)
   ret i8 %x1
 }
 
 define <2 x i8> @uadd_vector_0(<2 x i8> %a) {
 ; CHECK-LABEL: @uadd_vector_0(
-; CHECK-NEXT:    [[X1V:%.*]] = call <2 x i8> @llvm.uadd.sat.v2i8(<2 x i8> [[A:%.*]], <2 x i8> zeroinitializer)
-; CHECK-NEXT:    ret <2 x i8> [[X1V]]
+; CHECK-NEXT:    ret <2 x i8> [[A:%.*]]
 ;
   %x1v = call <2 x i8> @llvm.uadd.sat.v2i8(<2 x i8> %a, <2 x i8> zeroinitializer)
   ret <2 x i8> %x1v
 }
 
 define i3 @uadd_scalar_0_commute(i3 %a) {
 ; CHECK-LABEL: @uadd_scalar_0_commute(
-; CHECK-NEXT:    [[X2:%.*]] = call i3 @llvm.uadd.sat.i3(i3 0, i3 [[A:%.*]])
-; CHECK-NEXT:    ret i3 [[X2]]
+; CHECK-NEXT:    ret i3 [[A:%.*]]
 ;
   %x2 = call i3 @llvm.uadd.sat.i3(i3 0, i3 %a)
   ret i3 %x2
 }
 
 define <2 x i8> @uadd_vector_0_commute(<2 x i8> %a) {
 ; CHECK-LABEL: @uadd_vector_0_commute(
-; CHECK-NEXT:    [[X2V:%.*]] = call <2 x i8> @llvm.uadd.sat.v2i8(<2 x i8> <i8 0, i8 undef>, <2 x i8> [[A:%.*]])
-; CHECK-NEXT:    ret <2 x i8> [[X2V]]
+; CHECK-NEXT:    ret <2 x i8> [[A:%.*]]
 ;
   %x2v = call <2 x i8> @llvm.uadd.sat.v2i8(<2 x i8> <i8 0, i8 undef>, <2 x i8> %a)
   ret <2 x i8> %x2v
 }
 
 define i8 @uadd_scalar_maxval(i8 %a) {
 ; CHECK-LABEL: @uadd_scalar_maxval(
-; CHECK-NEXT:    [[X3:%.*]] = call i8 @llvm.uadd.sat.i8(i8 [[A:%.*]], i8 -1)
-; CHECK-NEXT:    ret i8 [[X3]]
+; CHECK-NEXT:    ret i8 -1
 ;
   %x3 = call i8 @llvm.uadd.sat.i8(i8 %a, i8 255)
   ret i8 %x3
 }
 
 define <2 x i9> @uadd_vector_maxval(<2 x i9> %a) {
 ; CHECK-LABEL: @uadd_vector_maxval(
-; CHECK-NEXT:    [[X3V:%.*]] = call <2 x i9> @llvm.uadd.sat.v2i9(<2 x i9> [[A:%.*]], <2 x i9> <i9 -1, i9 -1>)
-; CHECK-NEXT:    ret <2 x i9> [[X3V]]
+; CHECK-NEXT:    ret <2 x i9> <i9 -1, i9 -1>
 ;
   %x3v = call <2 x i9> @llvm.uadd.sat.v2i9(<2 x i9> %a, <2 x i9> <i9 511, i9 511>)
   ret <2 x i9> %x3v
 }
 
 define i3 @uadd_scalar_maxval_commute(i3 %a) {
 ; CHECK-LABEL: @uadd_scalar_maxval_commute(
-; CHECK-NEXT:    [[X4:%.*]] = call i3 @llvm.uadd.sat.i3(i3 -1, i3 [[A:%.*]])
-; CHECK-NEXT:    ret i3 [[X4]]
+; CHECK-NEXT:    ret i3 -1
 ;
   %x4 = call i3 @llvm.uadd.sat.i3(i3 7, i3 %a)
   ret i3 %x4
 }
 
 define <2 x i8> @uadd_vector_maxval_commute(<2 x i8> %a) {
 ; CHECK-LABEL: @uadd_vector_maxval_commute(
-; CHECK-NEXT:    [[X4V:%.*]] = call <2 x i8> @llvm.uadd.sat.v2i8(<2 x i8> <i8 -1, i8 -1>, <2 x i8> [[A:%.*]])
-; CHECK-NEXT:    ret <2 x i8> [[X4V]]
+; CHECK-NEXT:    ret <2 x i8> <i8 -1, i8 -1>
 ;
   %x4v = call <2 x i8> @llvm.uadd.sat.v2i8(<2 x i8> <i8 255, i8 255>, <2 x i8> %a)
   ret <2 x i8> %x4v
 }
 
 define i8 @uadd_scalar_undef(i8 %a) {
 ; CHECK-LABEL: @uadd_scalar_undef(
-; CHECK-NEXT:    [[X5:%.*]] = call i8 @llvm.uadd.sat.i8(i8 [[A:%.*]], i8 undef)
-; CHECK-NEXT:    ret i8 [[X5]]
+; CHECK-NEXT:    ret i8 -1
 ;
   %x5 = call i8 @llvm.uadd.sat.i8(i8 %a, i8 undef)
   ret i8 %x5
 }
 
 define <2 x i8> @uadd_vector_undef(<2 x i8> %a) {
 ; CHECK-LABEL: @uadd_vector_undef(
-; CHECK-NEXT:    [[X5V:%.*]] = call <2 x i8> @llvm.uadd.sat.v2i8(<2 x i8> [[A:%.*]], <2 x i8> undef)
-; CHECK-NEXT:    ret <2 x i8> [[X5V]]
+; CHECK-NEXT:    ret <2 x i8> <i8 -1, i8 -1>
 ;
   %x5v = call <2 x i8> @llvm.uadd.sat.v2i8(<2 x i8> %a, <2 x i8> <i8 undef, i8 undef>)
   ret <2 x i8> %x5v
 }
 
 define i8 @uadd_scalar_undef_commute(i8 %a) {
 ; CHECK-LABEL: @uadd_scalar_undef_commute(
-; CHECK-NEXT:    [[X6:%.*]] = call i8 @llvm.uadd.sat.i8(i8 undef, i8 [[A:%.*]])
-; CHECK-NEXT:    ret i8 [[X6]]
+; CHECK-NEXT:    ret i8 -1
 ;
   %x6 = call i8 @llvm.uadd.sat.i8(i8 undef, i8 %a)
   ret i8 %x6
 }
 
 define <2 x i8> @uadd_vector_undef_commute(<2 x i8> %a) {
 ; CHECK-LABEL: @uadd_vector_undef_commute(
-; CHECK-NEXT:    [[X5V:%.*]] = call <2 x i8> @llvm.uadd.sat.v2i8(<2 x i8> undef, <2 x i8> [[A:%.*]])
-; CHECK-NEXT:    ret <2 x i8> [[X5V]]
+; CHECK-NEXT:    ret <2 x i8> <i8 -1, i8 -1>
 ;
   %x5v = call <2 x i8> @llvm.uadd.sat.v2i8(<2 x i8> undef, <2 x i8> %a)
   ret <2 x i8> %x5v
 }
 
 define i8 @sadd_scalar_0(i8 %a) {
 ; CHECK-LABEL: @sadd_scalar_0(
-; CHECK-NEXT:    [[Y1:%.*]] = call i8 @llvm.sadd.sat.i8(i8 [[A:%.*]], i8 0)
-; CHECK-NEXT:    ret i8 [[Y1]]
+; CHECK-NEXT:    ret i8 [[A:%.*]]
 ;
   %y1 = call i8 @llvm.sadd.sat.i8(i8 %a, i8 0)
   ret i8 %y1
 }
 
 define <2 x i8> @sadd_vector_0(<2 x i8> %a) {
 ; CHECK-LABEL: @sadd_vector_0(
-; CHECK-NEXT:    [[Y1V:%.*]] = call <2 x i8> @llvm.sadd.sat.v2i8(<2 x i8> [[A:%.*]], <2 x i8> <i8 undef, i8 0>)
-; CHECK-NEXT:    ret <2 x i8> [[Y1V]]
+; CHECK-NEXT:    ret <2 x i8> [[A:%.*]]
 ;
   %y1v = call <2 x i8> @llvm.sadd.sat.v2i8(<2 x i8> %a, <2 x i8> <i8 undef, i8 0>)
   ret <2 x i8> %y1v
 }
 
 define i8 @sadd_scalar_0_commute(i8 %a) {
 ; CHECK-LABEL: @sadd_scalar_0_commute(
-; CHECK-NEXT:    [[Y2:%.*]] = call i8 @llvm.sadd.sat.i8(i8 0, i8 [[A:%.*]])
-; CHECK-NEXT:    ret i8 [[Y2]]
+; CHECK-NEXT:    ret i8 [[A:%.*]]
 ;
   %y2 = call i8 @llvm.sadd.sat.i8(i8 0, i8 %a)
   ret i8 %y2
 }
 
 define <2 x i8> @sadd_vector_0_commute(<2 x i8> %a) {
 ; CHECK-LABEL: @sadd_vector_0_commute(
-; CHECK-NEXT:    [[Y2V:%.*]] = call <2 x i8> @llvm.sadd.sat.v2i8(<2 x i8> zeroinitializer, <2 x i8> [[A:%.*]])
-; CHECK-NEXT:    ret <2 x i8> [[Y2V]]
+; CHECK-NEXT:    ret <2 x i8> [[A:%.*]]
 ;
   %y2v = call <2 x i8> @llvm.sadd.sat.v2i8(<2 x i8> zeroinitializer, <2 x i8> %a)
   ret <2 x i8> %y2v
 }
 
 define i8 @sadd_scalar_maxval(i8 %a) {
 ; CHECK-LABEL: @sadd_scalar_maxval(
 ; CHECK-NEXT:    [[Y3:%.*]] = call i8 @llvm.sadd.sat.i8(i8 [[A:%.*]], i8 127)

 ; CHECK-NEXT:    ret <2 x i8> [[Y4V]]
 ;
   %y4v = call <2 x i8> @llvm.sadd.sat.v2i8(<2 x i8> <i8 undef, i8 127>, <2 x i8> %a)
   ret <2 x i8> %y4v
 }
 
 define i8 @sadd_scalar_undef(i8 %a) {
 ; CHECK-LABEL: @sadd_scalar_undef(
-; CHECK-NEXT:    [[Y5:%.*]] = call i8 @llvm.sadd.sat.i8(i8 [[A:%.*]], i8 undef)
-; CHECK-NEXT:    ret i8 [[Y5]]
+; CHECK-NEXT:    ret i8 -1
 ;
   %y5 = call i8 @llvm.sadd.sat.i8(i8 %a, i8 undef)
   ret i8 %y5
 }
 
 define <2 x i8> @sadd_vector_undef(<2 x i8> %a) {
 ; CHECK-LABEL: @sadd_vector_undef(
-; CHECK-NEXT:    [[Y5V:%.*]] = call <2 x i8> @llvm.sadd.sat.v2i8(<2 x i8> [[A:%.*]], <2 x i8> undef)
-; CHECK-NEXT:    ret <2 x i8> [[Y5V]]
+; CHECK-NEXT:    ret <2 x i8> <i8 -1, i8 -1>
 ;
   %y5v = call <2 x i8> @llvm.sadd.sat.v2i8(<2 x i8> %a, <2 x i8> undef)
   ret <2 x i8> %y5v
 }
 
 define i8 @sadd_scalar_undef_commute(i8 %a) {
 ; CHECK-LABEL: @sadd_scalar_undef_commute(
-; CHECK-NEXT:    [[Y6:%.*]] = call i8 @llvm.sadd.sat.i8(i8 undef, i8 [[A:%.*]])
-; CHECK-NEXT:    ret i8 [[Y6]]
+; CHECK-NEXT:    ret i8 -1
 ;
   %y6 = call i8 @llvm.sadd.sat.i8(i8 undef, i8 %a)
   ret i8 %y6
 }
 
 define <2 x i8> @sadd_vector_undef_commute(<2 x i8> %a) {
 ; CHECK-LABEL: @sadd_vector_undef_commute(
-; CHECK-NEXT:    [[Y6V:%.*]] = call <2 x i8> @llvm.sadd.sat.v2i8(<2 x i8> undef, <2 x i8> [[A:%.*]])
-; CHECK-NEXT:    ret <2 x i8> [[Y6V]]
+; CHECK-NEXT:    ret <2 x i8> <i8 -1, i8 -1>
 ;
   %y6v = call <2 x i8> @llvm.sadd.sat.v2i8(<2 x i8> undef, <2 x i8> %a)
   ret <2 x i8> %y6v
 }
 
 define i8 @usub_scalar_0(i8 %a) {
 ; CHECK-LABEL: @usub_scalar_0(
-; CHECK-NEXT:    [[X1:%.*]] = call i8 @llvm.usub.sat.i8(i8 [[A:%.*]], i8 0)
-; CHECK-NEXT:    ret i8 [[X1]]
+; CHECK-NEXT:    ret i8 [[A:%.*]]
 ;
   %x1 = call i8 @llvm.usub.sat.i8(i8 %a, i8 0)
   ret i8 %x1
 }
 
 define <2 x i8> @usub_vector_0(<2 x i8> %a) {
 ; CHECK-LABEL: @usub_vector_0(
-; CHECK-NEXT:    [[X1V:%.*]] = call <2 x i8> @llvm.usub.sat.v2i8(<2 x i8> [[A:%.*]], <2 x i8> zeroinitializer)
-; CHECK-NEXT:    ret <2 x i8> [[X1V]]
+; CHECK-NEXT:    ret <2 x i8> [[A:%.*]]
 ;
   %x1v = call <2 x i8> @llvm.usub.sat.v2i8(<2 x i8> %a, <2 x i8> <i8 0, i8 0>)
   ret <2 x i8> %x1v
 }
 
 define i8 @usub_scalar_0_commute(i8 %a) {
 ; CHECK-LABEL: @usub_scalar_0_commute(
-; CHECK-NEXT:    [[X2:%.*]] = call i8 @llvm.usub.sat.i8(i8 0, i8 [[A:%.*]])
-; CHECK-NEXT:    ret i8 [[X2]]
+; CHECK-NEXT:    ret i8 0
 ;
   %x2 = call i8 @llvm.usub.sat.i8(i8 0, i8 %a)
   ret i8 %x2
 }
 
 define <2 x i8> @usub_vector_0_commute(<2 x i8> %a) {
 ; CHECK-LABEL: @usub_vector_0_commute(
-; CHECK-NEXT:    [[X2V:%.*]] = call <2 x i8> @llvm.usub.sat.v2i8(<2 x i8> zeroinitializer, <2 x i8> [[A:%.*]])
-; CHECK-NEXT:    ret <2 x i8> [[X2V]]
+; CHECK-NEXT:    ret <2 x i8> zeroinitializer
 ;
   %x2v = call <2 x i8> @llvm.usub.sat.v2i8(<2 x i8> <i8 0, i8 0>, <2 x i8> %a)
   ret <2 x i8> %x2v
 }
 
 define i8 @usub_scalar_maxval(i8 %a) {
 ; CHECK-LABEL: @usub_scalar_maxval(
-; CHECK-NEXT:    [[X3:%.*]] = call i8 @llvm.usub.sat.i8(i8 [[A:%.*]], i8 -1)
-; CHECK-NEXT:    ret i8 [[X3]]
+; CHECK-NEXT:    ret i8 0
 ;
   %x3 = call i8 @llvm.usub.sat.i8(i8 %a, i8 255)
   ret i8 %x3
 }
 
 define <2 x i8> @usub_vector_maxval(<2 x i8> %a) {
 ; CHECK-LABEL: @usub_vector_maxval(
-; CHECK-NEXT:    [[X3V:%.*]] = call <2 x i8> @llvm.usub.sat.v2i8(<2 x i8> [[A:%.*]], <2 x i8> <i8 -1, i8 -1>)
-; CHECK-NEXT:    ret <2 x i8> [[X3V]]
+; CHECK-NEXT:    ret <2 x i8> zeroinitializer
 ;
   %x3v = call <2 x i8> @llvm.usub.sat.v2i8(<2 x i8> %a, <2 x i8> <i8 255, i8 255>)
   ret <2 x i8> %x3v
 }
 
 define i8 @usub_scalar_undef(i8 %a) {
 ; CHECK-LABEL: @usub_scalar_undef(
-; CHECK-NEXT:    [[X4:%.*]] = call i8 @llvm.usub.sat.i8(i8 [[A:%.*]], i8 undef)
-; CHECK-NEXT:    ret i8 [[X4]]
+; CHECK-NEXT:    ret i8 0
 ;
   %x4 = call i8 @llvm.usub.sat.i8(i8 %a, i8 undef)
   ret i8 %x4
 }
 
 define <2 x i8> @usub_vector_undef(<2 x i8> %a) {
 ; CHECK-LABEL: @usub_vector_undef(
-; CHECK-NEXT:    [[X4V:%.*]] = call <2 x i8> @llvm.usub.sat.v2i8(<2 x i8> [[A:%.*]], <2 x i8> <i8 0, i8 undef>)
-; CHECK-NEXT:    ret <2 x i8> [[X4V]]
+; CHECK-NEXT:    ret <2 x i8> zeroinitializer
 ;
-  %x4v = call <2 x i8> @llvm.usub.sat.v2i8(<2 x i8> %a, <2 x i8> <i8 0, i8 undef>)
+  %x4v = call <2 x i8> @llvm.usub.sat.v2i8(<2 x i8> %a, <2 x i8> <i8 undef, i8 undef>)
   ret <2 x i8> %x4v
 }
 
 define i8 @usub_scalar_undef_commute(i8 %a) {
 ; CHECK-LABEL: @usub_scalar_undef_commute(
-; CHECK-NEXT:    [[X5:%.*]] = call i8 @llvm.usub.sat.i8(i8 undef, i8 [[A:%.*]])
-; CHECK-NEXT:    ret i8 [[X5]]
+; CHECK-NEXT:    ret i8 0
 ;
   %x5 = call i8 @llvm.usub.sat.i8(i8 undef, i8 %a)
   ret i8 %x5
 }
 
 define <2 x i8> @usub_vector_undef_commute(<2 x i8> %a) {
 ; CHECK-LABEL: @usub_vector_undef_commute(
-; CHECK-NEXT:    [[X5V:%.*]] = call <2 x i8> @llvm.usub.sat.v2i8(<2 x i8> [[A:%.*]], <2 x i8> undef)
-; CHECK-NEXT:    ret <2 x i8> [[X5V]]
+; CHECK-NEXT:    ret <2 x i8> zeroinitializer
 ;
-  %x5v = call <2 x i8> @llvm.usub.sat.v2i8(<2 x i8> %a, <2 x i8> <i8 undef, i8 undef>)
+  %x5v = call <2 x i8> @llvm.usub.sat.v2i8(<2 x i8> <i8 undef, i8 undef>, <2 x i8> %a)
   ret <2 x i8> %x5v
 }
 
 define i8 @usub_scalar_same(i8 %a) {
 ; CHECK-LABEL: @usub_scalar_same(
-; CHECK-NEXT:    [[X6:%.*]] = call i8 @llvm.usub.sat.i8(i8 [[A:%.*]], i8 [[A]])
-; CHECK-NEXT:    ret i8 [[X6]]
+; CHECK-NEXT:    ret i8 0
 ;
   %x6 = call i8 @llvm.usub.sat.i8(i8 %a, i8 %a)
   ret i8 %x6
 }
 
 define <2 x i8> @usub_vector_same(<2 x i8> %a) {
 ; CHECK-LABEL: @usub_vector_same(
-; CHECK-NEXT:    [[X6V:%.*]] = call <2 x i8> @llvm.usub.sat.v2i8(<2 x i8> [[A:%.*]], <2 x i8> [[A]])
-; CHECK-NEXT:    ret <2 x i8> [[X6V]]
+; CHECK-NEXT:    ret <2 x i8> zeroinitializer
 ;
   %x6v = call <2 x i8> @llvm.usub.sat.v2i8(<2 x i8> %a, <2 x i8> %a)
   ret <2 x i8> %x6v
 }
 
 define i8 @ssub_scalar_0(i8 %a) {
 ; CHECK-LABEL: @ssub_scalar_0(
-; CHECK-NEXT:    [[Y1:%.*]] = call i8 @llvm.ssub.sat.i8(i8 [[A:%.*]], i8 0)
-; CHECK-NEXT:    ret i8 [[Y1]]
+; CHECK-NEXT:    ret i8 [[A:%.*]]
 ;
   %y1 = call i8 @llvm.ssub.sat.i8(i8 %a, i8 0)
   ret i8 %y1
 }
 
 define <2 x i8> @ssub_vector_0(<2 x i8> %a) {
 ; CHECK-LABEL: @ssub_vector_0(
-; CHECK-NEXT:    [[Y1V:%.*]] = call <2 x i8> @llvm.ssub.sat.v2i8(<2 x i8> [[A:%.*]], <2 x i8> zeroinitializer)
-; CHECK-NEXT:    ret <2 x i8> [[Y1V]]
+; CHECK-NEXT:    ret <2 x i8> [[A:%.*]]
 ;
   %y1v = call <2 x i8> @llvm.ssub.sat.v2i8(<2 x i8> %a, <2 x i8> <i8 0, i8 0>)
   ret <2 x i8> %y1v
 }
 
 define i8 @ssub_scalar_0_commute(i8 %a) {
 ; CHECK-LABEL: @ssub_scalar_0_commute(
 ; CHECK-NEXT:    [[Y2:%.*]] = call i8 @llvm.ssub.sat.i8(i8 0, i8 [[A:%.*]])

 ; CHECK-NEXT:    ret <2 x i8> [[Y3V]]
 ;
   %y3v = call <2 x i8> @llvm.ssub.sat.v2i8(<2 x i8> %a, <2 x i8> <i8 127, i8 127>)
   ret <2 x i8> %y3v
 }
 
 define i8 @ssub_scalar_undef(i8 %a) {
 ; CHECK-LABEL: @ssub_scalar_undef(
-; CHECK-NEXT:    [[Y4:%.*]] = call i8 @llvm.ssub.sat.i8(i8 [[A:%.*]], i8 undef)
-; CHECK-NEXT:    ret i8 [[Y4]]
+; CHECK-NEXT:    ret i8 0
 ;
   %y4 = call i8 @llvm.ssub.sat.i8(i8 %a, i8 undef)
   ret i8 %y4
 }
 
 define <2 x i8> @ssub_vector_undef(<2 x i8> %a) {
 ; CHECK-LABEL: @ssub_vector_undef(
-; CHECK-NEXT:    [[Y4V:%.*]] = call <2 x i8> @llvm.ssub.sat.v2i8(<2 x i8> [[A:%.*]], <2 x i8> undef)
-; CHECK-NEXT:    ret <2 x i8> [[Y4V]]
+; CHECK-NEXT:    ret <2 x i8> zeroinitializer
 ;
   %y4v = call <2 x i8> @llvm.ssub.sat.v2i8(<2 x i8> %a, <2 x i8> undef)
   ret <2 x i8> %y4v
 }
 
 define i8 @ssub_scalar_undef_commute(i8 %a) {
 ; CHECK-LABEL: @ssub_scalar_undef_commute(
-; CHECK-NEXT:    [[Y5:%.*]] = call i8 @llvm.ssub.sat.i8(i8 undef, i8 [[A:%.*]])
-; CHECK-NEXT:    ret i8 [[Y5]]
+; CHECK-NEXT:    ret i8 0
 ;
   %y5 = call i8 @llvm.ssub.sat.i8(i8 undef, i8 %a)
   ret i8 %y5
 }
 
 define <2 x i8> @ssub_vector_undef_commute(<2 x i8> %a) {
 ; CHECK-LABEL: @ssub_vector_undef_commute(
-; CHECK-NEXT:    [[Y5V:%.*]] = call <2 x i8> @llvm.ssub.sat.v2i8(<2 x i8> undef, <2 x i8> [[A:%.*]])
-; CHECK-NEXT:    ret <2 x i8> [[Y5V]]
+; CHECK-NEXT:    ret <2 x i8> zeroinitializer
 ;
   %y5v = call <2 x i8> @llvm.ssub.sat.v2i8(<2 x i8> <i8 undef, i8 undef>, <2 x i8> %a)
   ret <2 x i8> %y5v
 }
 
 define i8 @ssub_scalar_same(i8 %a) {
 ; CHECK-LABEL: @ssub_scalar_same(
-; CHECK-NEXT:    [[Y6:%.*]] = call i8 @llvm.ssub.sat.i8(i8 [[A:%.*]], i8 [[A]])
-; CHECK-NEXT:    ret i8 [[Y6]]
+; CHECK-NEXT:    ret i8 0
 ;
   %y6 = call i8 @llvm.ssub.sat.i8(i8 %a, i8 %a)
   ret i8 %y6
 }
 
 define <2 x i8> @ssub_vector_same(<2 x i8> %a) {
 ; CHECK-LABEL: @ssub_vector_same(
-; CHECK-NEXT:    [[Y6V:%.*]] = call <2 x i8> @llvm.ssub.sat.v2i8(<2 x i8> [[A:%.*]], <2 x i8> [[A]])
-; CHECK-NEXT:    ret <2 x i8> [[Y6V]]
+; CHECK-NEXT:    ret <2 x i8> zeroinitializer
 ;
   %y6v = call <2 x i8> @llvm.ssub.sat.v2i8(<2 x i8> %a, <2 x i8> %a)
   ret <2 x i8> %y6v
 }