[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

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

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

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

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

llvm/lib/Transforms/InstCombine/InstCombineCompares.cpp

Instruction *InstCombiner::foldICmpWithCastAndCast(ICmpInst &ICmp) {
   // Finally, return the value computed.
   if (ICmp.getPredicate() == ICmpInst::ICMP_ULT)
     return replaceInstUsesWith(ICmp, Result);
 
   assert(ICmp.getPredicate() == ICmpInst::ICMP_UGT && "ICmp should be folded!");
   return BinaryOperator::CreateNot(Result);
 }
 
 bool InstCombiner::OptimizeOverflowCheck(OverflowCheckFlavor OCF, Value *LHS,
                                          Value *RHS, Instruction &OrigI,
                                          Value *&Result, Constant *&Overflow) {
   if (OrigI.isCommutative() && isa<Constant>(LHS) && !isa<Constant>(RHS))
     std::swap(LHS, RHS);
 
   auto SetResult = [&](Value *OpResult, Constant *OverflowVal, bool ReuseName) {
     Result = OpResult;
     Overflow = OverflowVal;
bool InstCombiner::OptimizeOverflowCheck(OverflowCheckFlavor OCF, Value *LHS,
 
   case OCF_UNSIGNED_SUB:
   case OCF_SIGNED_SUB: {
     // X - 0 -> {X, false}
     if (match(RHS, m_Zero()))
       return SetResult(LHS, Builder.getFalse(), false);
 
     if (OCF == OCF_UNSIGNED_SUB) {
-      if (willNotOverflowUnsignedSub(LHS, RHS, OrigI))
+      OverflowResult 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 {
       if (willNotOverflowSignedSub(LHS, RHS, OrigI))
         return SetResult(Builder.CreateNSWSub(LHS, RHS), Builder.getFalse(),
                          true);
     }
     break;
   }
 

llvm/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(