[ConstraintElimination] Simplify usub(a,b) if a s>=b.

[zjaffal]

Summary

This optimization follows the work from D125264

[zjaffal]

ping

[nikic]

Looks fine, but I think you need to rebase and adjust this line to check for WithOverflowInst instead: https://github.com/llvm/llvm-project/blob/286ae63e168b5e5249bf52e2f1610057d604bab4/llvm/lib/Transforms/Scalar/ConstraintElimination.cpp#L665

[zjaffal]

In D134048#3981480, @nikic wrote:

Looks fine, but I think you need to rebase and adjust this line to check for WithOverflowInst instead: https://github.com/llvm/llvm-project/blob/286ae63e168b5e5249bf52e2f1610057d604bab4/llvm/lib/Transforms/Scalar/ConstraintElimination.cpp#L665

We check for WithOverflowInst before we call tryToSimplifyOverflowMath so I don't think it is needed there

[nikic]

In D134048#3984917, @zjaffal wrote:

In D134048#3981480, @nikic wrote:

Looks fine, but I think you need to rebase and adjust this line to check for WithOverflowInst instead: https://github.com/llvm/llvm-project/blob/286ae63e168b5e5249bf52e2f1610057d604bab4/llvm/lib/Transforms/Scalar/ConstraintElimination.cpp#L665

We check for WithOverflowInst before we call tryToSimplifyOverflowMath so I don't think it is needed there

What I meant is, if this code is not adjusted the condition will not get queued up for simplification in the first place.

llvm/lib/Transforms/Scalar/ConstraintElimination.cpp

if (II->getIntrinsicID() == Intrinsic::ssub_with_overflow) {
     Value *A = II->getArgOperand(0);
     Value *B = II->getArgOperand(1);
     if (!DoesConditionHold(CmpInst::ICMP_SGE, A, B, Info) ||
         !DoesConditionHold(CmpInst::ICMP_SGE, B,
                            ConstantInt::get(A->getType(), 0), Info))
       return;
     replaceSubOverflowUses(II, A, B, ToRemove);
   }
+  if (II->getIntrinsicID() == Intrinsic::usub_with_overflow) {
+    // if A >= B usub_with_overflow(a, b) should not overflow and
+    // can be simplified to a regular sub
+    Value *A = II->getArgOperand(0);
+    Value *B = II->getArgOperand(1);
+    if (!DoesConditionHold(CmpInst::ICMP_UGE, A, B, Info))
+      return;
+    replaceSubOverflowUses(II, A, B, ToRemove);
+  }
 }
 
 static bool eliminateConstraints(Function &F, DominatorTree &DT) {
   bool Changed = false;
   DT.updateDFSNumbers();
 
   ConstraintInfo Info;
   State S(DT);

llvm/test/Transforms/ConstraintElimination/usub-with-overflow.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -passes=constraint-elimination -S %s | FileCheck %s
 
 declare { i8, i1 } @llvm.usub.with.overflow.i8(i8, i8)
 
 define i8 @usub_no_overflow_due_to_cmp_condition(i8 %a, i8 %b) {
 ; CHECK-LABEL: @usub_no_overflow_due_to_cmp_condition(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp uge i8 [[B:%.*]], [[A:%.*]]
 ; CHECK-NEXT:    br i1 [[C_1]], label [[MATH:%.*]], label [[EXIT_FAIL:%.*]]
 ; CHECK:       math:
-; CHECK-NEXT:    [[OP:%.*]] = tail call { i8, i1 } @llvm.usub.with.overflow.i8(i8 [[B]], i8 [[A]])
-; CHECK-NEXT:    [[STATUS:%.*]] = extractvalue { i8, i1 } [[OP]], 1
-; CHECK-NEXT:    br i1 [[STATUS]], label [[EXIT_FAIL]], label [[EXIT_OK:%.*]]
+; CHECK-NEXT:    [[TMP0:%.*]] = sub i8 [[B]], [[A]]
+; CHECK-NEXT:    br i1 false, label [[EXIT_FAIL]], label [[EXIT_OK:%.*]]
 ; CHECK:       exit.ok:
-; CHECK-NEXT:    [[RES:%.*]] = extractvalue { i8, i1 } [[OP]], 0
-; CHECK-NEXT:    ret i8 [[RES]]
+; CHECK-NEXT:    ret i8 [[TMP0]]
 ; CHECK:       exit.fail:
 ; CHECK-NEXT:    ret i8 0
 ;
 entry:
   %c.1 = icmp uge i8 %b, %a
   br i1 %c.1, label %math, label %exit.fail
 
 math:

 }
 
 define i8 @usub_no_overflow_due_to_cmp_condition2(i8 %a, i8 %b) {
 ; CHECK-LABEL: @usub_no_overflow_due_to_cmp_condition2(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ule i8 [[B:%.*]], [[A:%.*]]
 ; CHECK-NEXT:    br i1 [[C_1]], label [[EXIT_FAIL:%.*]], label [[MATH:%.*]]
 ; CHECK:       math:
-; CHECK-NEXT:    [[OP:%.*]] = tail call { i8, i1 } @llvm.usub.with.overflow.i8(i8 [[B]], i8 [[A]])
-; CHECK-NEXT:    [[STATUS:%.*]] = extractvalue { i8, i1 } [[OP]], 1
-; CHECK-NEXT:    br i1 [[STATUS]], label [[EXIT_FAIL]], label [[EXIT_OK:%.*]]
+; CHECK-NEXT:    [[TMP0:%.*]] = sub i8 [[B]], [[A]]
+; CHECK-NEXT:    br i1 false, label [[EXIT_FAIL]], label [[EXIT_OK:%.*]]
 ; CHECK:       exit.ok:
-; CHECK-NEXT:    [[RES:%.*]] = extractvalue { i8, i1 } [[OP]], 0
-; CHECK-NEXT:    ret i8 [[RES]]
+; CHECK-NEXT:    ret i8 [[TMP0]]
 ; CHECK:       exit.fail:
 ; CHECK-NEXT:    ret i8 0
 ;
 entry:
   %c.1 = icmp ule i8 %b, %a
   br i1 %c.1, label %exit.fail, label %math
 
 math:

 declare void @use_res({ i8, i1 })
 
 define i8 @sub_no_overflow_due_to_cmp_condition_result_used(i8 %a, i8 %b) {
 ; CHECK-LABEL: @sub_no_overflow_due_to_cmp_condition_result_used(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ule i8 [[B:%.*]], [[A:%.*]]
 ; CHECK-NEXT:    br i1 [[C_1]], label [[EXIT_FAIL:%.*]], label [[MATH:%.*]]
 ; CHECK:       math:
+; CHECK-NEXT:    [[TMP0:%.*]] = sub i8 [[B]], [[A]]
 ; CHECK-NEXT:    [[OP:%.*]] = tail call { i8, i1 } @llvm.usub.with.overflow.i8(i8 [[B]], i8 [[A]])
 ; CHECK-NEXT:    call void @use_res({ i8, i1 } [[OP]])
-; CHECK-NEXT:    [[STATUS:%.*]] = extractvalue { i8, i1 } [[OP]], 1
-; CHECK-NEXT:    br i1 [[STATUS]], label [[EXIT_FAIL]], label [[EXIT_OK:%.*]]
+; CHECK-NEXT:    br i1 false, label [[EXIT_FAIL]], label [[EXIT_OK:%.*]]
 ; CHECK:       exit.ok:
-; CHECK-NEXT:    [[RES:%.*]] = extractvalue { i8, i1 } [[OP]], 0
-; CHECK-NEXT:    ret i8 [[RES]]
+; CHECK-NEXT:    ret i8 [[TMP0]]
 ; CHECK:       exit.fail:
 ; CHECK-NEXT:    ret i8 0
 ;
 entry:
   %c.1 = icmp ule i8 %b, %a
   br i1 %c.1, label %exit.fail, label %math
 
 math:

 define i8 @usub_no_overflow_due_to_or_conds(i8 %a, i8 %b) {
 ; CHECK-LABEL: @usub_no_overflow_due_to_or_conds(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ule i8 [[B:%.*]], [[A:%.*]]
 ; CHECK-NEXT:    [[C_2:%.*]] = icmp ule i8 [[A]], 0
 ; CHECK-NEXT:    [[OR:%.*]] = or i1 [[C_2]], [[C_1]]
 ; CHECK-NEXT:    br i1 [[OR]], label [[EXIT_FAIL:%.*]], label [[MATH:%.*]]
 ; CHECK:       math:
-; CHECK-NEXT:    [[OP:%.*]] = tail call { i8, i1 } @llvm.usub.with.overflow.i8(i8 [[B]], i8 [[A]])
-; CHECK-NEXT:    [[STATUS:%.*]] = extractvalue { i8, i1 } [[OP]], 1
-; CHECK-NEXT:    br i1 [[STATUS]], label [[EXIT_FAIL]], label [[EXIT_OK:%.*]]
+; CHECK-NEXT:    [[TMP0:%.*]] = sub i8 [[B]], [[A]]
+; CHECK-NEXT:    br i1 false, label [[EXIT_FAIL]], label [[EXIT_OK:%.*]]
 ; CHECK:       exit.ok:
-; CHECK-NEXT:    [[RES:%.*]] = extractvalue { i8, i1 } [[OP]], 0
-; CHECK-NEXT:    ret i8 [[RES]]
+; CHECK-NEXT:    ret i8 [[TMP0]]
 ; CHECK:       exit.fail:
 ; CHECK-NEXT:    ret i8 0
 ;
 entry:
   %c.1 = icmp ule i8 %b, %a
   %c.2 = icmp ule i8 %a, 0
   %or = or i1 %c.2, %c.1
   br i1 %or, label %exit.fail, label %math

 define i8 @usub_no_overflow_due_to_or_conds_sub_result_not_used(i8 %a, i8 %b) {
 ; CHECK-LABEL: @usub_no_overflow_due_to_or_conds_sub_result_not_used(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp ule i8 [[B:%.*]], [[A:%.*]]
 ; CHECK-NEXT:    [[C_2:%.*]] = icmp ule i8 [[A]], 0
 ; CHECK-NEXT:    [[OR:%.*]] = or i1 [[C_2]], [[C_1]]
 ; CHECK-NEXT:    br i1 [[OR]], label [[EXIT_FAIL:%.*]], label [[MATH:%.*]]
 ; CHECK:       math:
-; CHECK-NEXT:    [[OP:%.*]] = tail call { i8, i1 } @llvm.usub.with.overflow.i8(i8 [[B]], i8 [[A]])
-; CHECK-NEXT:    [[STATUS:%.*]] = extractvalue { i8, i1 } [[OP]], 1
-; CHECK-NEXT:    br i1 [[STATUS]], label [[EXIT_FAIL]], label [[EXIT_OK:%.*]]
+; CHECK-NEXT:    br i1 false, label [[EXIT_FAIL]], label [[EXIT_OK:%.*]]
 ; CHECK:       exit.ok:
 ; CHECK-NEXT:    ret i8 20
 ; CHECK:       exit.fail:
 ; CHECK-NEXT:    ret i8 0
 ;
 entry:
   %c.1 = icmp ule i8 %b, %a
   %c.2 = icmp ule i8 %a, 0

 define i8 @usub_no_overflow_due_to_and_conds(i8 %a, i8 %b) {
 ; CHECK-LABEL: @usub_no_overflow_due_to_and_conds(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp uge i8 [[B:%.*]], [[A:%.*]]
 ; CHECK-NEXT:    [[C_2:%.*]] = icmp uge i8 [[A]], -1
 ; CHECK-NEXT:    [[AND:%.*]] = and i1 [[C_2]], [[C_1]]
 ; CHECK-NEXT:    br i1 [[AND]], label [[MATH:%.*]], label [[EXIT_FAIL:%.*]]
 ; CHECK:       math:
-; CHECK-NEXT:    [[OP:%.*]] = tail call { i8, i1 } @llvm.usub.with.overflow.i8(i8 [[B]], i8 [[A]])
-; CHECK-NEXT:    [[STATUS:%.*]] = extractvalue { i8, i1 } [[OP]], 1
-; CHECK-NEXT:    br i1 [[STATUS]], label [[EXIT_FAIL]], label [[EXIT_OK:%.*]]
+; CHECK-NEXT:    [[TMP0:%.*]] = sub i8 [[B]], [[A]]
+; CHECK-NEXT:    br i1 false, label [[EXIT_FAIL]], label [[EXIT_OK:%.*]]
 ; CHECK:       exit.ok:
-; CHECK-NEXT:    [[RES:%.*]] = extractvalue { i8, i1 } [[OP]], 0
-; CHECK-NEXT:    ret i8 [[RES]]
+; CHECK-NEXT:    ret i8 [[TMP0]]
 ; CHECK:       exit.fail:
 ; CHECK-NEXT:    ret i8 0
 ;
 entry:
   %c.1 = icmp uge i8 %b, %a
   %c.2 = icmp uge i8 %a, -1
   %and = and i1 %c.2, %c.1
   br i1 %and, label %math, label %exit.fail