[llvm] 4725583 - [ValueTracking] A and (B & ~A) have no common bits set
Nikita Popov via llvm-commits
llvm-commits at lists.llvm.org
Tue May 3 02:33:35 PDT 2022
Author: Nikita Popov
Date: 2022-05-03T11:33:27+02:00
New Revision: 47255834e720b735ff1358a74fdf32345bb4daca
URL: https://github.com/llvm/llvm-project/commit/47255834e720b735ff1358a74fdf32345bb4daca
DIFF: https://github.com/llvm/llvm-project/commit/47255834e720b735ff1358a74fdf32345bb4daca.diff
LOG: [ValueTracking] A and (B & ~A) have no common bits set
This extends haveNoCommonBitsSet() to two additional cases, allowing
the following folds:
* `A + (B & ~A)` --> `A | (B & ~A)`
(https://alive2.llvm.org/ce/z/crxxhN)
* `A + ((A & B) ^ B)` --> `A | ((A & B) ^ B)`
(https://alive2.llvm.org/ce/z/A_wsH_)
These should further fold to just `A | B`, though this currently
only works in the first case.
The reason why the second fold is necessary is that we consider
this to be the canonical form if B is a constant. (I did check
whether we can change that, but it looks like a number of folds
depend on the current canonicalization, so I ended up adding both
patterns here.)
Differential Revision: https://reviews.llvm.org/D124763
Added:
Modified:
llvm/lib/Analysis/ValueTracking.cpp
llvm/test/Transforms/InstCombine/add.ll
Removed:
################################################################################
diff --git a/llvm/lib/Analysis/ValueTracking.cpp b/llvm/lib/Analysis/ValueTracking.cpp
index 75381f5f7e5fb..0144ce4ad7ec4 100644
--- a/llvm/lib/Analysis/ValueTracking.cpp
+++ b/llvm/lib/Analysis/ValueTracking.cpp
@@ -282,6 +282,20 @@ bool llvm::haveNoCommonBitsSet(const Value *LHS, const Value *RHS,
match(LHS, m_c_And(m_Specific(M), m_Value())))
return true;
}
+
+ // X op (Y & ~X)
+ if (match(RHS, m_c_And(m_Not(m_Specific(LHS)), m_Value())) ||
+ match(LHS, m_c_And(m_Not(m_Specific(RHS)), m_Value())))
+ return true;
+
+ // X op ((X & Y) ^ Y) -- this is the canonical form of the previous pattern
+ // for constant Y.
+ Value *Y;
+ if (match(RHS,
+ m_c_Xor(m_c_And(m_Specific(LHS), m_Value(Y)), m_Deferred(Y))) ||
+ match(LHS, m_c_Xor(m_c_And(m_Specific(RHS), m_Value(Y)), m_Deferred(Y))))
+ return true;
+
// Look for: (A & B) op ~(A | B)
{
Value *A, *B;
diff --git a/llvm/test/Transforms/InstCombine/add.ll b/llvm/test/Transforms/InstCombine/add.ll
index 118926c3cd533..9fc7909be489e 100644
--- a/llvm/test/Transforms/InstCombine/add.ll
+++ b/llvm/test/Transforms/InstCombine/add.ll
@@ -1395,9 +1395,7 @@ define i8 @add_like_or_t2_extrause(i8 %x) {
define i8 @add_and_xor(i8 %x, i8 %y) {
; CHECK-LABEL: @add_and_xor(
-; CHECK-NEXT: [[XOR:%.*]] = xor i8 [[X:%.*]], -1
-; CHECK-NEXT: [[AND:%.*]] = and i8 [[XOR]], [[Y:%.*]]
-; CHECK-NEXT: [[ADD:%.*]] = add i8 [[AND]], [[X]]
+; CHECK-NEXT: [[ADD:%.*]] = or i8 [[Y:%.*]], [[X:%.*]]
; CHECK-NEXT: ret i8 [[ADD]]
;
%xor = xor i8 %x, -1
@@ -1435,9 +1433,7 @@ define i8 @add_and_xor_wrong_op(i8 %x, i8 %y, i8 %z) {
define i8 @add_and_xor_commuted1(i8 %x, i8 %_y) {
; CHECK-LABEL: @add_and_xor_commuted1(
; CHECK-NEXT: [[Y:%.*]] = udiv i8 42, [[_Y:%.*]]
-; CHECK-NEXT: [[XOR:%.*]] = xor i8 [[X:%.*]], -1
-; CHECK-NEXT: [[AND:%.*]] = and i8 [[Y]], [[XOR]]
-; CHECK-NEXT: [[ADD:%.*]] = add i8 [[AND]], [[X]]
+; CHECK-NEXT: [[ADD:%.*]] = or i8 [[Y]], [[X:%.*]]
; CHECK-NEXT: ret i8 [[ADD]]
;
%y = udiv i8 42, %_y ; thwart complexity-based canonicalization
@@ -1450,9 +1446,7 @@ define i8 @add_and_xor_commuted1(i8 %x, i8 %_y) {
define i8 @add_and_xor_commuted2(i8 %_x, i8 %y) {
; CHECK-LABEL: @add_and_xor_commuted2(
; CHECK-NEXT: [[X:%.*]] = udiv i8 42, [[_X:%.*]]
-; CHECK-NEXT: [[XOR:%.*]] = xor i8 [[X]], -1
-; CHECK-NEXT: [[AND:%.*]] = and i8 [[XOR]], [[Y:%.*]]
-; CHECK-NEXT: [[ADD:%.*]] = add i8 [[X]], [[AND]]
+; CHECK-NEXT: [[ADD:%.*]] = or i8 [[X]], [[Y:%.*]]
; CHECK-NEXT: ret i8 [[ADD]]
;
%x = udiv i8 42, %_x ; thwart complexity-based canonicalization
@@ -1466,9 +1460,7 @@ define i8 @add_and_xor_commuted3(i8 %_x, i8 %_y) {
; CHECK-LABEL: @add_and_xor_commuted3(
; CHECK-NEXT: [[X:%.*]] = udiv i8 42, [[_X:%.*]]
; CHECK-NEXT: [[Y:%.*]] = udiv i8 42, [[_Y:%.*]]
-; CHECK-NEXT: [[XOR:%.*]] = xor i8 [[X]], -1
-; CHECK-NEXT: [[AND:%.*]] = and i8 [[Y]], [[XOR]]
-; CHECK-NEXT: [[ADD:%.*]] = add nuw nsw i8 [[X]], [[AND]]
+; CHECK-NEXT: [[ADD:%.*]] = or i8 [[X]], [[Y]]
; CHECK-NEXT: ret i8 [[ADD]]
;
%x = udiv i8 42, %_x ; thwart complexity-based canonicalization
@@ -1485,7 +1477,7 @@ define i8 @add_and_xor_extra_use(i8 %x, i8 %y) {
; CHECK-NEXT: call void @use(i8 [[XOR]])
; CHECK-NEXT: [[AND:%.*]] = and i8 [[XOR]], [[Y:%.*]]
; CHECK-NEXT: call void @use(i8 [[AND]])
-; CHECK-NEXT: [[ADD:%.*]] = add i8 [[AND]], [[X]]
+; CHECK-NEXT: [[ADD:%.*]] = or i8 [[Y]], [[X]]
; CHECK-NEXT: ret i8 [[ADD]]
;
%xor = xor i8 %x, -1
@@ -1500,7 +1492,7 @@ define i8 @add_xor_and_const(i8 %x) {
; CHECK-LABEL: @add_xor_and_const(
; CHECK-NEXT: [[AND:%.*]] = and i8 [[X:%.*]], 42
; CHECK-NEXT: [[XOR:%.*]] = xor i8 [[AND]], 42
-; CHECK-NEXT: [[ADD:%.*]] = add i8 [[XOR]], [[X]]
+; CHECK-NEXT: [[ADD:%.*]] = or i8 [[XOR]], [[X]]
; CHECK-NEXT: ret i8 [[ADD]]
;
%and = and i8 %x, 42
@@ -1527,7 +1519,7 @@ define i8 @add_xor_and_var(i8 %x, i8 %y) {
; CHECK-NEXT: [[AND:%.*]] = and i8 [[X:%.*]], [[Y:%.*]]
; CHECK-NEXT: call void @use(i8 [[AND]])
; CHECK-NEXT: [[XOR:%.*]] = xor i8 [[AND]], [[Y]]
-; CHECK-NEXT: [[ADD:%.*]] = add i8 [[XOR]], [[X]]
+; CHECK-NEXT: [[ADD:%.*]] = or i8 [[XOR]], [[X]]
; CHECK-NEXT: ret i8 [[ADD]]
;
%and = and i8 %x, %y
@@ -1572,7 +1564,7 @@ define i8 @add_xor_and_var_commuted1(i8 %x, i8 %y) {
; CHECK-NEXT: [[AND:%.*]] = and i8 [[Y:%.*]], [[X:%.*]]
; CHECK-NEXT: call void @use(i8 [[AND]])
; CHECK-NEXT: [[XOR:%.*]] = xor i8 [[AND]], [[Y]]
-; CHECK-NEXT: [[ADD:%.*]] = add i8 [[XOR]], [[X]]
+; CHECK-NEXT: [[ADD:%.*]] = or i8 [[XOR]], [[X]]
; CHECK-NEXT: ret i8 [[ADD]]
;
%and = and i8 %y, %x
@@ -1588,7 +1580,7 @@ define i8 @add_xor_and_var_commuted2(i8 %x, i8 %_y) {
; CHECK-NEXT: [[AND:%.*]] = and i8 [[Y]], [[X:%.*]]
; CHECK-NEXT: call void @use(i8 [[AND]])
; CHECK-NEXT: [[XOR:%.*]] = xor i8 [[Y]], [[AND]]
-; CHECK-NEXT: [[ADD:%.*]] = add i8 [[XOR]], [[X]]
+; CHECK-NEXT: [[ADD:%.*]] = or i8 [[XOR]], [[X]]
; CHECK-NEXT: ret i8 [[ADD]]
;
%y = udiv i8 42, %_y ; thwart complexity-based canonicalization
@@ -1605,7 +1597,7 @@ define i8 @add_xor_and_var_commuted3(i8 %x, i8 %_y) {
; CHECK-NEXT: [[AND:%.*]] = and i8 [[Y]], [[X:%.*]]
; CHECK-NEXT: call void @use(i8 [[AND]])
; CHECK-NEXT: [[XOR:%.*]] = xor i8 [[Y]], [[AND]]
-; CHECK-NEXT: [[ADD:%.*]] = add i8 [[XOR]], [[X]]
+; CHECK-NEXT: [[ADD:%.*]] = or i8 [[XOR]], [[X]]
; CHECK-NEXT: ret i8 [[ADD]]
;
%y = udiv i8 42, %_y ; thwart complexity-based canonicalization
@@ -1622,7 +1614,7 @@ define i8 @add_xor_and_var_commuted4(i8 %_x, i8 %y) {
; CHECK-NEXT: [[AND:%.*]] = and i8 [[X]], [[Y:%.*]]
; CHECK-NEXT: call void @use(i8 [[AND]])
; CHECK-NEXT: [[XOR:%.*]] = xor i8 [[AND]], [[Y]]
-; CHECK-NEXT: [[ADD:%.*]] = add i8 [[X]], [[XOR]]
+; CHECK-NEXT: [[ADD:%.*]] = or i8 [[X]], [[XOR]]
; CHECK-NEXT: ret i8 [[ADD]]
;
%x = udiv i8 42, %_x ; thwart complexity-based canonicalization
@@ -1639,7 +1631,7 @@ define i8 @add_xor_and_var_commuted5(i8 %_x, i8 %y) {
; CHECK-NEXT: [[AND:%.*]] = and i8 [[X]], [[Y:%.*]]
; CHECK-NEXT: call void @use(i8 [[AND]])
; CHECK-NEXT: [[XOR:%.*]] = xor i8 [[AND]], [[Y]]
-; CHECK-NEXT: [[ADD:%.*]] = add i8 [[X]], [[XOR]]
+; CHECK-NEXT: [[ADD:%.*]] = or i8 [[X]], [[XOR]]
; CHECK-NEXT: ret i8 [[ADD]]
;
%x = udiv i8 42, %_x ; thwart complexity-based canonicalization
@@ -1657,7 +1649,7 @@ define i8 @add_xor_and_var_commuted6(i8 %_x, i8 %_y) {
; CHECK-NEXT: [[AND:%.*]] = and i8 [[X]], [[Y]]
; CHECK-NEXT: call void @use(i8 [[AND]])
; CHECK-NEXT: [[XOR:%.*]] = xor i8 [[Y]], [[AND]]
-; CHECK-NEXT: [[ADD:%.*]] = add nuw nsw i8 [[X]], [[XOR]]
+; CHECK-NEXT: [[ADD:%.*]] = or i8 [[X]], [[XOR]]
; CHECK-NEXT: ret i8 [[ADD]]
;
%x = udiv i8 42, %_x ; thwart complexity-based canonicalization
@@ -1676,7 +1668,7 @@ define i8 @add_xor_and_var_commuted7(i8 %_x, i8 %_y) {
; CHECK-NEXT: [[AND:%.*]] = and i8 [[Y]], [[X]]
; CHECK-NEXT: call void @use(i8 [[AND]])
; CHECK-NEXT: [[XOR:%.*]] = xor i8 [[Y]], [[AND]]
-; CHECK-NEXT: [[ADD:%.*]] = add nuw nsw i8 [[X]], [[XOR]]
+; CHECK-NEXT: [[ADD:%.*]] = or i8 [[X]], [[XOR]]
; CHECK-NEXT: ret i8 [[ADD]]
;
%x = udiv i8 42, %_x ; thwart complexity-based canonicalization
@@ -1694,7 +1686,7 @@ define i8 @add_xor_and_var_extra_use(i8 %x, i8 %y) {
; CHECK-NEXT: call void @use(i8 [[AND]])
; CHECK-NEXT: [[XOR:%.*]] = xor i8 [[AND]], [[Y]]
; CHECK-NEXT: call void @use(i8 [[XOR]])
-; CHECK-NEXT: [[ADD:%.*]] = add i8 [[XOR]], [[X]]
+; CHECK-NEXT: [[ADD:%.*]] = or i8 [[XOR]], [[X]]
; CHECK-NEXT: ret i8 [[ADD]]
;
%and = and i8 %x, %y
More information about the llvm-commits
mailing list