[llvm] goldsteinn/add sub reassos (PR #105866)
via llvm-commits
llvm-commits at lists.llvm.org
Fri Aug 23 11:03:43 PDT 2024
llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-llvm-transforms
Author: None (goldsteinn)
<details>
<summary>Changes</summary>
- **[InstCombine] Add tests for reassosiating `(add/sub (sub/add) (sub/add))`; NFC**
- **[InstCombine] Simplify `(add/sub (sub/add) (sub/add))` irrelivant of use-count**
---
Full diff: https://github.com/llvm/llvm-project/pull/105866.diff
5 Files Affected:
- (modified) llvm/lib/Transforms/InstCombine/InstCombineAddSub.cpp (+30)
- (modified) llvm/lib/Transforms/InstCombine/InstCombineAndOrXor.cpp (+3)
- (modified) llvm/lib/Transforms/InstCombine/InstCombineInternal.h (+3)
- (modified) llvm/lib/Transforms/InstCombine/InstructionCombining.cpp (+26)
- (added) llvm/test/Transforms/InstCombine/fold-add-sub.ll (+207)
``````````diff
diff --git a/llvm/lib/Transforms/InstCombine/InstCombineAddSub.cpp b/llvm/lib/Transforms/InstCombine/InstCombineAddSub.cpp
index d7758b5fbf1786..5272bc11865f53 100644
--- a/llvm/lib/Transforms/InstCombine/InstCombineAddSub.cpp
+++ b/llvm/lib/Transforms/InstCombine/InstCombineAddSub.cpp
@@ -1520,6 +1520,9 @@ Instruction *InstCombinerImpl::visitAdd(BinaryOperator &I) {
if (Instruction *R = combineAddSubWithShlAddSub(Builder, I))
return R;
+ if (Instruction *R = foldAddLike(I))
+ return R;
+
Value *LHS = I.getOperand(0), *RHS = I.getOperand(1);
Type *Ty = I.getType();
if (Ty->isIntOrIntVectorTy(1))
@@ -2286,6 +2289,33 @@ Instruction *InstCombinerImpl::visitSub(BinaryOperator &I) {
}
}
+ {
+ Value *W, *Z;
+ if (match(Op0, m_AddLike(m_Value(W), m_Value(X))) &&
+ match(Op1, m_AddLike(m_Value(Y), m_Value(Z)))) {
+ Instruction *R = nullptr;
+ if (W == Y)
+ R = BinaryOperator::CreateSub(X, Z);
+ if (W == Z)
+ R = BinaryOperator::CreateSub(X, Y);
+ if (X == Y)
+ R = BinaryOperator::CreateSub(W, Z);
+ if (X == Z)
+ R = BinaryOperator::CreateSub(W, Y);
+ if (R) {
+ bool NSW = I.hasNoSignedWrap() &&
+ match(Op0, m_NSWAddLike(m_Value(), m_Value())) &&
+ match(Op1, m_NSWAddLike(m_Value(), m_Value()));
+
+ bool NUW = I.hasNoUnsignedWrap() &&
+ match(Op1, m_NUWAddLike(m_Value(), m_Value()));
+ R->setHasNoSignedWrap(NSW);
+ R->setHasNoUnsignedWrap(NUW);
+ return R;
+ }
+ }
+ }
+
// (~X) - (~Y) --> Y - X
{
// Need to ensure we can consume at least one of the `not` instructions,
diff --git a/llvm/lib/Transforms/InstCombine/InstCombineAndOrXor.cpp b/llvm/lib/Transforms/InstCombine/InstCombineAndOrXor.cpp
index b703bc7d04db58..8a2998e1de6430 100644
--- a/llvm/lib/Transforms/InstCombine/InstCombineAndOrXor.cpp
+++ b/llvm/lib/Transforms/InstCombine/InstCombineAndOrXor.cpp
@@ -3576,6 +3576,9 @@ Instruction *InstCombinerImpl::visitOr(BinaryOperator &I) {
if (Instruction *R = tryFoldInstWithCtpopWithNot(&I))
return R;
+ if (Instruction *R = foldAddLike(I))
+ return R;
+
Value *X, *Y;
const APInt *CV;
if (match(&I, m_c_Or(m_OneUse(m_Xor(m_Value(X), m_APInt(CV))), m_Value(Y))) &&
diff --git a/llvm/lib/Transforms/InstCombine/InstCombineInternal.h b/llvm/lib/Transforms/InstCombine/InstCombineInternal.h
index a0e846c3b5a566..e94f118ab3808a 100644
--- a/llvm/lib/Transforms/InstCombine/InstCombineInternal.h
+++ b/llvm/lib/Transforms/InstCombine/InstCombineInternal.h
@@ -585,6 +585,9 @@ class LLVM_LIBRARY_VISIBILITY InstCombinerImpl final
FPClassTest DemandedMask, KnownFPClass &Known,
unsigned Depth = 0);
+ /// Common transforms for add / disjoint or
+ Instruction *foldAddLike(BinaryOperator &I);
+
/// Canonicalize the position of binops relative to shufflevector.
Instruction *foldVectorBinop(BinaryOperator &Inst);
Instruction *foldVectorSelect(SelectInst &Sel);
diff --git a/llvm/lib/Transforms/InstCombine/InstructionCombining.cpp b/llvm/lib/Transforms/InstCombine/InstructionCombining.cpp
index c3f79fe4f901ad..3cdf693b66dfd1 100644
--- a/llvm/lib/Transforms/InstCombine/InstructionCombining.cpp
+++ b/llvm/lib/Transforms/InstCombine/InstructionCombining.cpp
@@ -2008,6 +2008,32 @@ static bool shouldMergeGEPs(GEPOperator &GEP, GEPOperator &Src) {
return true;
}
+Instruction *InstCombinerImpl::foldAddLike(BinaryOperator &I) {
+ Value *LHS = I.getOperand(0);
+ Value *RHS = I.getOperand(1);
+ Value *A, *B, *C, *D;
+ if (match(LHS, m_Sub(m_Value(A), m_Value(B))) &&
+ match(RHS, m_Sub(m_Value(C), m_Value(D)))) {
+ Instruction *R = nullptr;
+ if (A == D)
+ R = BinaryOperator::CreateSub(C, B);
+ if (C == B)
+ R = BinaryOperator::CreateSub(A, D);
+ if (R) {
+ bool NSW = match(&I, m_NSWAddLike(m_Value(), m_Value())) &&
+ match(LHS, m_NSWSub(m_Value(), m_Value())) &&
+ match(RHS, m_NSWSub(m_Value(), m_Value()));
+
+ bool NUW = match(LHS, m_NUWSub(m_Value(), m_Value())) &&
+ match(RHS, m_NUWSub(m_Value(), m_Value()));
+ R->setHasNoSignedWrap(NSW);
+ R->setHasNoUnsignedWrap(NUW);
+ return R;
+ }
+ }
+ return nullptr;
+}
+
Instruction *InstCombinerImpl::foldVectorBinop(BinaryOperator &Inst) {
if (!isa<VectorType>(Inst.getType()))
return nullptr;
diff --git a/llvm/test/Transforms/InstCombine/fold-add-sub.ll b/llvm/test/Transforms/InstCombine/fold-add-sub.ll
new file mode 100644
index 00000000000000..bbb7bb67369e7f
--- /dev/null
+++ b/llvm/test/Transforms/InstCombine/fold-add-sub.ll
@@ -0,0 +1,207 @@
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
+; RUN: opt < %s -passes=instcombine -S | FileCheck %s
+
+declare void @use.i8(i8)
+define i8 @test_add_nsw(i8 %x, i8 %y, i8 %z) {
+; CHECK-LABEL: @test_add_nsw(
+; CHECK-NEXT: [[LHS:%.*]] = add nsw i8 [[X:%.*]], [[Y:%.*]]
+; CHECK-NEXT: [[RHS:%.*]] = add nsw i8 [[X]], [[Z:%.*]]
+; CHECK-NEXT: call void @use.i8(i8 [[LHS]])
+; CHECK-NEXT: call void @use.i8(i8 [[RHS]])
+; CHECK-NEXT: [[R:%.*]] = sub nsw i8 [[Y]], [[Z]]
+; CHECK-NEXT: ret i8 [[R]]
+;
+ %lhs = add nsw i8 %x, %y
+ %rhs = add nsw i8 %x, %z
+ call void @use.i8(i8 %lhs)
+ call void @use.i8(i8 %rhs)
+ %r = sub nsw i8 %lhs, %rhs
+ ret i8 %r
+}
+
+define i8 @test_add_nsw_no_prop(i8 %x, i8 %y, i8 %z) {
+; CHECK-LABEL: @test_add_nsw_no_prop(
+; CHECK-NEXT: [[LHS:%.*]] = add nsw i8 [[X:%.*]], [[Y:%.*]]
+; CHECK-NEXT: [[RHS:%.*]] = add nuw i8 [[X]], [[Z:%.*]]
+; CHECK-NEXT: call void @use.i8(i8 [[LHS]])
+; CHECK-NEXT: call void @use.i8(i8 [[RHS]])
+; CHECK-NEXT: [[R:%.*]] = sub i8 [[Y]], [[Z]]
+; CHECK-NEXT: ret i8 [[R]]
+;
+ %lhs = add nsw i8 %x, %y
+ %rhs = add nuw i8 %x, %z
+ call void @use.i8(i8 %lhs)
+ call void @use.i8(i8 %rhs)
+ %r = sub nsw i8 %lhs, %rhs
+ ret i8 %r
+}
+
+define i8 @test_add(i8 %x, i8 %y, i8 %z) {
+; CHECK-LABEL: @test_add(
+; CHECK-NEXT: [[LHS:%.*]] = add i8 [[X:%.*]], [[Y:%.*]]
+; CHECK-NEXT: [[RHS:%.*]] = add i8 [[X]], [[Z:%.*]]
+; CHECK-NEXT: call void @use.i8(i8 [[LHS]])
+; CHECK-NEXT: call void @use.i8(i8 [[RHS]])
+; CHECK-NEXT: [[R:%.*]] = sub i8 [[Y]], [[Z]]
+; CHECK-NEXT: ret i8 [[R]]
+;
+ %lhs = add i8 %x, %y
+ %rhs = add i8 %x, %z
+ call void @use.i8(i8 %lhs)
+ call void @use.i8(i8 %rhs)
+ %r = sub i8 %lhs, %rhs
+ ret i8 %r
+}
+
+define i8 @test_add_fail(i8 %w, i8 %x, i8 %y, i8 %z) {
+; CHECK-LABEL: @test_add_fail(
+; CHECK-NEXT: [[LHS:%.*]] = add i8 [[W:%.*]], [[Y:%.*]]
+; CHECK-NEXT: [[RHS:%.*]] = add i8 [[X:%.*]], [[Z:%.*]]
+; CHECK-NEXT: call void @use.i8(i8 [[LHS]])
+; CHECK-NEXT: call void @use.i8(i8 [[RHS]])
+; CHECK-NEXT: [[R:%.*]] = sub i8 [[LHS]], [[RHS]]
+; CHECK-NEXT: ret i8 [[R]]
+;
+ %lhs = add i8 %w, %y
+ %rhs = add i8 %x, %z
+ call void @use.i8(i8 %lhs)
+ call void @use.i8(i8 %rhs)
+ %r = sub i8 %lhs, %rhs
+ ret i8 %r
+}
+
+define i8 @test_add_nuw(i8 %x, i8 %y, i8 %z) {
+; CHECK-LABEL: @test_add_nuw(
+; CHECK-NEXT: [[LHS:%.*]] = add i8 [[X:%.*]], [[Y:%.*]]
+; CHECK-NEXT: [[RHS:%.*]] = or disjoint i8 [[X]], [[Z:%.*]]
+; CHECK-NEXT: call void @use.i8(i8 [[LHS]])
+; CHECK-NEXT: call void @use.i8(i8 [[RHS]])
+; CHECK-NEXT: [[R:%.*]] = sub nuw i8 [[Y]], [[Z]]
+; CHECK-NEXT: ret i8 [[R]]
+;
+ %lhs = add i8 %x, %y
+ %rhs = or disjoint i8 %x, %z
+ call void @use.i8(i8 %lhs)
+ call void @use.i8(i8 %rhs)
+ %r = sub nuw i8 %lhs, %rhs
+ ret i8 %r
+}
+
+define i8 @test_add_nuw_no_prop(i8 %x, i8 %y, i8 %z) {
+; CHECK-LABEL: @test_add_nuw_no_prop(
+; CHECK-NEXT: [[LHS:%.*]] = add i8 [[X:%.*]], [[Y:%.*]]
+; CHECK-NEXT: [[RHS:%.*]] = or disjoint i8 [[X]], [[Z:%.*]]
+; CHECK-NEXT: call void @use.i8(i8 [[LHS]])
+; CHECK-NEXT: call void @use.i8(i8 [[RHS]])
+; CHECK-NEXT: [[R:%.*]] = sub i8 [[Y]], [[Z]]
+; CHECK-NEXT: ret i8 [[R]]
+;
+ %lhs = add i8 %x, %y
+ %rhs = or disjoint i8 %x, %z
+ call void @use.i8(i8 %lhs)
+ call void @use.i8(i8 %rhs)
+ %r = sub i8 %lhs, %rhs
+ ret i8 %r
+}
+
+define i8 @test_sub_nuw(i8 %x, i8 %y, i8 %z) {
+; CHECK-LABEL: @test_sub_nuw(
+; CHECK-NEXT: [[LHS:%.*]] = sub nuw i8 [[X:%.*]], [[Y:%.*]]
+; CHECK-NEXT: [[RHS:%.*]] = sub nuw i8 [[Y]], [[Z:%.*]]
+; CHECK-NEXT: call void @use.i8(i8 [[LHS]])
+; CHECK-NEXT: call void @use.i8(i8 [[RHS]])
+; CHECK-NEXT: [[R:%.*]] = sub nuw i8 [[X]], [[Z]]
+; CHECK-NEXT: ret i8 [[R]]
+;
+ %lhs = sub nuw i8 %x, %y
+ %rhs = sub nuw i8 %y, %z
+ call void @use.i8(i8 %lhs)
+ call void @use.i8(i8 %rhs)
+ %r = add i8 %lhs, %rhs
+ ret i8 %r
+}
+
+define i8 @test_sub_nuw_no_prop(i8 %x, i8 %y, i8 %z) {
+; CHECK-LABEL: @test_sub_nuw_no_prop(
+; CHECK-NEXT: [[LHS:%.*]] = sub nuw i8 [[X:%.*]], [[Y:%.*]]
+; CHECK-NEXT: [[RHS:%.*]] = sub i8 [[Y]], [[Z:%.*]]
+; CHECK-NEXT: call void @use.i8(i8 [[LHS]])
+; CHECK-NEXT: call void @use.i8(i8 [[RHS]])
+; CHECK-NEXT: [[R:%.*]] = sub i8 [[X]], [[Z]]
+; CHECK-NEXT: ret i8 [[R]]
+;
+ %lhs = sub nuw i8 %x, %y
+ %rhs = sub i8 %y, %z
+ call void @use.i8(i8 %lhs)
+ call void @use.i8(i8 %rhs)
+ %r = add nuw i8 %lhs, %rhs
+ ret i8 %r
+}
+
+define i8 @test_sub_nsw(i8 %x, i8 %y, i8 %z) {
+; CHECK-LABEL: @test_sub_nsw(
+; CHECK-NEXT: [[LHS:%.*]] = sub nsw i8 [[X:%.*]], [[Y:%.*]]
+; CHECK-NEXT: [[RHS:%.*]] = sub nsw i8 [[Y]], [[Z:%.*]]
+; CHECK-NEXT: call void @use.i8(i8 [[LHS]])
+; CHECK-NEXT: call void @use.i8(i8 [[RHS]])
+; CHECK-NEXT: [[R:%.*]] = sub nsw i8 [[X]], [[Z]]
+; CHECK-NEXT: ret i8 [[R]]
+;
+ %lhs = sub nsw i8 %x, %y
+ %rhs = sub nsw i8 %y, %z
+ call void @use.i8(i8 %lhs)
+ call void @use.i8(i8 %rhs)
+ %r = or disjoint i8 %lhs, %rhs
+ ret i8 %r
+}
+
+define i8 @test_sub_nsw_no_prop(i8 %x, i8 %y, i8 %z) {
+; CHECK-LABEL: @test_sub_nsw_no_prop(
+; CHECK-NEXT: [[LHS:%.*]] = sub i8 [[X:%.*]], [[Y:%.*]]
+; CHECK-NEXT: [[RHS:%.*]] = sub nsw i8 [[Y]], [[Z:%.*]]
+; CHECK-NEXT: call void @use.i8(i8 [[LHS]])
+; CHECK-NEXT: call void @use.i8(i8 [[RHS]])
+; CHECK-NEXT: [[R:%.*]] = sub i8 [[X]], [[Z]]
+; CHECK-NEXT: ret i8 [[R]]
+;
+ %lhs = sub i8 %x, %y
+ %rhs = sub nsw i8 %y, %z
+ call void @use.i8(i8 %lhs)
+ call void @use.i8(i8 %rhs)
+ %r = or disjoint i8 %lhs, %rhs
+ ret i8 %r
+}
+
+define i8 @test_sub_none(i8 %x, i8 %y, i8 %z) {
+; CHECK-LABEL: @test_sub_none(
+; CHECK-NEXT: [[LHS:%.*]] = sub i8 [[X:%.*]], [[Y:%.*]]
+; CHECK-NEXT: [[RHS:%.*]] = sub i8 [[Y]], [[Z:%.*]]
+; CHECK-NEXT: call void @use.i8(i8 [[LHS]])
+; CHECK-NEXT: call void @use.i8(i8 [[RHS]])
+; CHECK-NEXT: [[R:%.*]] = sub i8 [[X]], [[Z]]
+; CHECK-NEXT: ret i8 [[R]]
+;
+ %lhs = sub i8 %x, %y
+ %rhs = sub i8 %y, %z
+ call void @use.i8(i8 %lhs)
+ call void @use.i8(i8 %rhs)
+ %r = add i8 %lhs, %rhs
+ ret i8 %r
+}
+
+define i8 @test_sub_none_fail(i8 %x, i8 %y, i8 %z) {
+; CHECK-LABEL: @test_sub_none_fail(
+; CHECK-NEXT: [[LHS:%.*]] = sub i8 [[X:%.*]], [[Y:%.*]]
+; CHECK-NEXT: [[RHS:%.*]] = sub i8 [[Z:%.*]], [[Y]]
+; CHECK-NEXT: call void @use.i8(i8 [[LHS]])
+; CHECK-NEXT: call void @use.i8(i8 [[RHS]])
+; CHECK-NEXT: [[R:%.*]] = add i8 [[LHS]], [[RHS]]
+; CHECK-NEXT: ret i8 [[R]]
+;
+ %lhs = sub i8 %x, %y
+ %rhs = sub i8 %z, %y
+ call void @use.i8(i8 %lhs)
+ call void @use.i8(i8 %rhs)
+ %r = add i8 %lhs, %rhs
+ ret i8 %r
+}
``````````
</details>
https://github.com/llvm/llvm-project/pull/105866
More information about the llvm-commits
mailing list