1. A more concise implementation of the original swap code

2. looser equality constraints, such as nsw/nuw combinations, can be folded

Author: Acthinks

llvm/lib/Transforms/InstCombine/InstCombineCompares.cpp

@@ -7728,36 +7728,41 @@ Instruction *InstCombinerImpl::visitICmpInst(ICmpInst &I) {
     }
   }
 
-  // In case of a comparison with add/sub instructions having the same operands,
-  // check whether cmp operands have same signed no wrap. If so, just compare
-  // the sub's second operand and zero.
-  // For example:
-  //   %tmp1 = sub nsw i8 %x, %y
-  //   %tmp2 = add nsw i8 %x, %y
-  //   %cmp = icmp sgt i8 %tmp1, %tmp2
-  // transform this into:
-  //   %cmp = icmp slt i32 %y, 0
+  // When comparing results of sub and add instructions with identical operands,
+  // optimization is valid when the comparison type and overflow flags satisfy:
+  //   - Signed comparisons (slt/sgt/sle/sge) require 'nsw' flags
+  //   - Unsigned comparisons (ult/ugt/ule/uge) require 'nuw' flags
+  //   - Equality comparisons (eq/ne) accept either 'nsw' or 'nuw'
+  //
+  // If conditions are met, the comparison simplifies to a zero comparison on
+  // the second operand of the sub instruction with the swapped predicate.
+  // Example transformation for signed comparison:
+  //   %sub = sub nsw i8 %x, %y
+  //   %add = add nsw i8 %x, %y
+  //   %cmp = icmp sgt i8 %sub, %add  // (x - y) > (x + y)
+  // becomes:
+  //   %cmp = icmp slt i8 %y, 0      // y < 0
+  //
   // This handles similar cases to transform.
   {
     Value *A, *B;
     auto *I0 = dyn_cast<OverflowingBinaryOperator>(Op0);
     auto *I1 = dyn_cast<OverflowingBinaryOperator>(Op1);
-    bool UnsignedCmp = ICmpInst::isUnsigned(Pred);
-    bool SignedCmp = ICmpInst::isSigned(Pred);
-    bool EqualityCmp = ICmpInst::isEquality(Pred);
-
     if (I0 && I1) {
       bool I0NUW = I0->hasNoUnsignedWrap();
       bool I1NUW = I1->hasNoUnsignedWrap();
       bool I0NSW = I0->hasNoSignedWrap();
       bool I1NSW = I1->hasNoSignedWrap();
+      bool UnsignedCmp = ICmpInst::isUnsigned(Pred);
+      bool SignedCmp = ICmpInst::isSigned(Pred);
+      bool EqualityCmp = ICmpInst::isEquality(Pred);
+      CmpPredicate CmpPred;
       if ((UnsignedCmp && I0NUW && I1NUW) || (SignedCmp && I0NSW && I1NSW) ||
-          (EqualityCmp && ((I0NUW && I1NUW) || (I0NSW && I1NSW)))) {
-        if (match(I0, m_Sub(m_Value(A), m_Value(B))) &&
-            match(I1, m_Add(m_Specific(A), m_Specific(B)))) {
-          return new ICmpInst(I.getSwappedPredicate(), B,
+          (EqualityCmp && ((I0NUW || I0NSW) && (I1NUW || I1NSW)))) {
+        if (match(&I, m_c_ICmp(CmpPred, m_Sub(m_Value(A), m_Value(B)),
+                               m_c_Add(m_Deferred(A), m_Deferred(B)))))
+          return new ICmpInst(CmpPredicate::getSwapped(CmpPred), B,
                               ConstantInt::get(Op0->getType(), 0));
-        }
       }
     }
   }

llvm/test/Transforms/InstCombine/icmp-subadd.ll

@@ -43,8 +43,8 @@ define i1 @test-same-operands-sub-add-nsw-nuw-icmp-eq(i8 %a, i8 %b) {
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i8 [[B]], 0
 ; CHECK-NEXT:    ret i1 [[CMP]]
 ;
-  %sub = sub nuw nsw i8 %a, %b
-  %add = add nuw nsw i8 %a, %b
+  %sub = sub nsw i8 %a, %b
+  %add = add nuw i8 %a, %b
   %cmp = icmp eq i8 %sub, %add
   ret i1 %cmp
 }
@@ -61,13 +61,10 @@ define i1 @test-same-operands-sub-add-nsw-icmp-eq(i8 %a, i8 %b) {
   ret i1 %cmp
 }
 
-; Should floded by foldICmpCommutative in the future
 define i1 @test-add-sub-nsw-icmp-sgt(i8 %a, i8 %b) {
 ; CHECK-LABEL: define i1 @test-add-sub-nsw-icmp-sgt(
 ; CHECK-SAME: i8 [[A:%.*]], i8 [[B:%.*]]) {
-; CHECK-NEXT:    [[SUB:%.*]] = sub nsw i8 [[A]], [[B]]
-; CHECK-NEXT:    [[ADD:%.*]] = add nsw i8 [[A]], [[B]]
-; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt i8 [[ADD]], [[SUB]]
+; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt i8 [[B]], 0
 ; CHECK-NEXT:    ret i1 [[CMP]]
 ;
   %sub = sub nsw i8 %a, %b
@@ -76,14 +73,10 @@ define i1 @test-add-sub-nsw-icmp-sgt(i8 %a, i8 %b) {
   ret i1 %cmp
 }
 
-; Should floded by foldICmpCommutative in the future
 define i1 @test-add-sub-nuw-icmp-uge(i8 %a, i8 %b) {
 ; CHECK-LABEL: define i1 @test-add-sub-nuw-icmp-uge(
 ; CHECK-SAME: i8 [[A:%.*]], i8 [[B:%.*]]) {
-; CHECK-NEXT:    [[SUB:%.*]] = sub nuw i8 [[A]], [[B]]
-; CHECK-NEXT:    [[ADD:%.*]] = add nuw i8 [[A]], [[B]]
-; CHECK-NEXT:    [[CMP:%.*]] = icmp uge i8 [[ADD]], [[SUB]]
-; CHECK-NEXT:    ret i1 [[CMP]]
+; CHECK-NEXT:    ret i1 true
 ;
   %sub = sub nuw i8 %a, %b
   %add = add nuw i8 %a, %b
@@ -106,14 +99,10 @@ define i1 @test-add-sub-nuw-icmp-sge(i8 %a, i8 %b) {
   ret i1 %cmp
 }
 
-; Should floded by foldICmpCommutative in the future
 define i1 @test-add-swap-sub-nuw-icmp-uge(i8 %a, i8 %b) {
 ; CHECK-LABEL: define i1 @test-add-swap-sub-nuw-icmp-uge(
 ; CHECK-SAME: i8 [[A:%.*]], i8 [[B:%.*]]) {
-; CHECK-NEXT:    [[SUB:%.*]] = sub nuw i8 [[A]], [[B]]
-; CHECK-NEXT:    [[ADD:%.*]] = add nuw i8 [[B]], [[A]]
-; CHECK-NEXT:    [[CMP:%.*]] = icmp uge i8 [[ADD]], [[SUB]]
-; CHECK-NEXT:    ret i1 [[CMP]]
+; CHECK-NEXT:    ret i1 true
 ;
   %sub = sub nuw i8 %a, %b
   %add = add nuw i8 %b, %a