[InstCombine] Handle usubo always overflow

[nikic]

Summary

Check AlwaysOverflow condition for usubo. The implementation is the same as the existing handling for uaddo and umulo. Handling for saddo and ssubo will follow (smulo doesn't have the necessary ValueTracking support).

[lebedev.ri]

Looks good, consider landing as two commits.

llvm/lib/Transforms/InstCombine/InstCombineCompares.cpp

3940 ↗

(On Diff #194384)

Hm, i should check if this can be used (or is already used?) for some of the implicit-conversion checks that aren't using overflow intrinsics, but plain ir..

3993 ↗

(On Diff #194384)

And willNotOverflowUnsignedSub() is: (unless i'm looking at the wrong func?)

bool willNotOverflowUnsignedSub(const Value *LHS, const Value *RHS,
                                const Instruction &CxtI) const {
  return computeOverflowForUnsignedSub(LHS, RHS, &CxtI) ==
         OverflowResult::NeverOverflows;
}

So this should ideally be:
patch 0 (nfc)

- if (willNotOverflowUnsignedSub(LHS, RHS, OrigI))
+ OverflowResult OR = computeOverflowForUnsignedSub(LHS, RHS, &OrigI);
+ if (OR == OverflowResult::NeverOverflows)

patch 1 -

+ if (OR == OverflowResult::AlwaysOverflows)
+   return SetResult(Builder.CreateSub(LHS, RHS), Builder.getTrue(), true);

[nikic]

llvm/lib/Transforms/InstCombine/InstCombineCompares.cpp

3940 ↗

(On Diff #194384)

Apart from with.overflow handling this function is used in one more place: https://github.com/llvm-mirror/llvm/blob/29ea2070bd62816674f48ac392a1ee24e5c915cf/lib/Transforms/InstCombine/InstCombineCompares.cpp#L5049-L5060 Not sure if that's the usage you have in mind.

3993 ↗

(On Diff #194384)

I've split out the willNot -> computeOverflow change (for all cases) into rL358051.

llvm/trunk/lib/Transforms/InstCombine/InstCombineCompares.cpp

if (match(RHS, m_Zero()))
       return SetResult(LHS, Builder.getFalse(), false);
 
     OverflowResult OR;
     if (OCF == OCF_UNSIGNED_SUB) {
       OR = computeOverflowForUnsignedSub(LHS, RHS, &OrigI);
       if (OR == OverflowResult::NeverOverflows)
         return SetResult(Builder.CreateNUWSub(LHS, RHS), Builder.getFalse(),
                          true);
+
+      if (OR == OverflowResult::AlwaysOverflows)
+        return SetResult(Builder.CreateSub(LHS, RHS), Builder.getTrue(), true);
     } else {
       OR = computeOverflowForSignedSub(LHS, RHS, &OrigI);
       if (OR == OverflowResult::NeverOverflows)
         return SetResult(Builder.CreateNSWSub(LHS, RHS), Builder.getFalse(),
                          true);
     }
     break;
   }

llvm/trunk/test/Transforms/InstCombine/with_overflow.ll

;
   %y = or i8 %x, 192
   %a = call { i8, i1 } @llvm.uadd.with.overflow.i8(i8 %y, i8 64)
   ret { i8, i1 } %a
 }
 
 define { i8, i1 } @usub_always_overflow(i8 %x) nounwind {
 ; CHECK-LABEL: @usub_always_overflow(
 ; CHECK-NEXT:    [[Y:%.*]] = or i8 [[X:%.*]], 64
-; CHECK-NEXT:    [[A:%.*]] = call { i8, i1 } @llvm.usub.with.overflow.i8(i8 63, i8 [[Y]])
-; CHECK-NEXT:    ret { i8, i1 } [[A]]
+; CHECK-NEXT:    [[A:%.*]] = sub nsw i8 63, [[Y]]
+; CHECK-NEXT:    [[TMP1:%.*]] = insertvalue { i8, i1 } { i8 undef, i1 true }, i8 [[A]], 0
+; CHECK-NEXT:    ret { i8, i1 } [[TMP1]]
 ;
   %y = or i8 %x, 64
   %a = call { i8, i1 } @llvm.usub.with.overflow.i8(i8 63, i8 %y)
   ret { i8, i1 } %a
 }
 
 define { i8, i1 } @umul_always_overflow(i8 %x) nounwind {
 ; CHECK-LABEL: @umul_always_overflow(