[ValueTracking] Compute knownbits for `(and/or cond0, cond1)` on both sides of branch #82818

goldsteinn · 2024-02-23T19:31:55Z

The false branch for and and true branch for or provide less
information (intersection as opposed to union), but still can give
some useful information.

…h sides of branch; NFC

llvmbot · 2024-02-23T19:32:26Z

@llvm/pr-subscribers-llvm-analysis

Author: None (goldsteinn)

Changes

[ValueTracking] Add tests for tracking `(and/or cond0
[ValueTracking] Compute knownbits for `(and/or cond0

Full diff: https://github.com/llvm/llvm-project/pull/82818.diff

2 Files Affected:

(modified) llvm/lib/Analysis/ValueTracking.cpp (+11-4)
(modified) llvm/test/Transforms/InstCombine/known-bits.ll (+59)

diff --git a/llvm/lib/Analysis/ValueTracking.cpp b/llvm/lib/Analysis/ValueTracking.cpp
index 653b3d4ffd9883..562b1e574aea4d 100644
--- a/llvm/lib/Analysis/ValueTracking.cpp
+++ b/llvm/lib/Analysis/ValueTracking.cpp
@@ -711,10 +711,17 @@ static void computeKnownBitsFromCond(const Value *V, Value *Cond,
                                      const SimplifyQuery &SQ, bool Invert) {
   Value *A, *B;
   if (Depth < MaxAnalysisRecursionDepth &&
-      (Invert ? match(Cond, m_LogicalOr(m_Value(A), m_Value(B)))
-              : match(Cond, m_LogicalAnd(m_Value(A), m_Value(B))))) {
-    computeKnownBitsFromCond(V, A, Known, Depth + 1, SQ, Invert);
-    computeKnownBitsFromCond(V, B, Known, Depth + 1, SQ, Invert);
+      match(Cond, m_LogicalOp(m_Value(A), m_Value(B)))) {
+    KnownBits Known2(Known.getBitWidth());
+    KnownBits Known3(Known.getBitWidth());
+    computeKnownBitsFromCond(V, A, Known2, Depth + 1, SQ, Invert);
+    computeKnownBitsFromCond(V, B, Known3, Depth + 1, SQ, Invert);
+    if (Invert ? match(Cond, m_LogicalOr(m_Value(A), m_Value(B)))
+               : match(Cond, m_LogicalAnd(m_Value(A), m_Value(B))))
+      Known = Known2.unionWith(Known3);
+    else
+      Known2 = Known2.intersectWith(Known3);
+    Known = Known.unionWith(Known2);
   }
 
   if (auto *Cmp = dyn_cast<ICmpInst>(Cond))
diff --git a/llvm/test/Transforms/InstCombine/known-bits.ll b/llvm/test/Transforms/InstCombine/known-bits.ll
index 246579cc4cd0c0..b658ee0d2ef4e2 100644
--- a/llvm/test/Transforms/InstCombine/known-bits.ll
+++ b/llvm/test/Transforms/InstCombine/known-bits.ll
@@ -124,6 +124,65 @@ exit:
   ret i8 %or2
 }
 
+
+define i8 @test_cond_and_bothways(i8 %x) {
+; CHECK-LABEL: @test_cond_and_bothways(
+; CHECK-NEXT:    [[AND:%.*]] = and i8 [[X:%.*]], 91
+; CHECK-NEXT:    [[CMP0:%.*]] = icmp ne i8 [[AND]], 24
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp ne i8 [[X]], 0
+; CHECK-NEXT:    [[COND:%.*]] = and i1 [[CMP0]], [[CMP1]]
+; CHECK-NEXT:    br i1 [[COND]], label [[IF:%.*]], label [[EXIT:%.*]]
+; CHECK:       if:
+; CHECK-NEXT:    [[OR1:%.*]] = or i8 [[X]], -4
+; CHECK-NEXT:    ret i8 [[OR1]]
+; CHECK:       exit:
+; CHECK-NEXT:    ret i8 -4
+;
+  %and = and i8 %x, 91
+  %cmp0 = icmp ne i8 %and, 24
+  %cmp1 = icmp ne i8 %x, 0
+  %cond = and i1 %cmp0, %cmp1
+  br i1 %cond, label %if, label %exit
+
+if:
+  %or1 = or i8 %x, -4
+  ret i8 %or1
+
+exit:
+  %or2 = or i8 %x, -4
+  ret i8 %or2
+}
+
+define i8 @test_cond_or_bothways(i8 %x) {
+; CHECK-LABEL: @test_cond_or_bothways(
+; CHECK-NEXT:    [[AND:%.*]] = and i8 [[X:%.*]], 91
+; CHECK-NEXT:    [[CMP0:%.*]] = icmp eq i8 [[AND]], 24
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp eq i8 [[X]], 0
+; CHECK-NEXT:    [[COND:%.*]] = or i1 [[CMP0]], [[CMP1]]
+; CHECK-NEXT:    br i1 [[COND]], label [[IF:%.*]], label [[EXIT:%.*]]
+; CHECK:       if:
+; CHECK-NEXT:    ret i8 -4
+; CHECK:       exit:
+; CHECK-NEXT:    [[OR2:%.*]] = or i8 [[X]], -4
+; CHECK-NEXT:    ret i8 [[OR2]]
+;
+  %and = and i8 %x, 91
+  %cmp0 = icmp eq i8 %and, 24
+  %cmp1 = icmp eq i8 %x, 0
+  %cond = or i1 %cmp0, %cmp1
+  br i1 %cond, label %if, label %exit
+
+if:
+  %or1 = or i8 %x, -4
+  ret i8 %or1
+
+exit:
+  %or2 = or i8 %x, -4
+  ret i8 %or2
+}
+
+
+
 define i8 @test_cond_and_commuted(i8 %x, i1 %c1, i1 %c2) {
 ; CHECK-LABEL: @test_cond_and_commuted(
 ; CHECK-NEXT:    [[AND:%.*]] = and i8 [[X:%.*]], 3

llvmbot · 2024-02-23T19:32:26Z

@llvm/pr-subscribers-llvm-transforms

Author: None (goldsteinn)

Changes

[ValueTracking] Add tests for tracking `(and/or cond0
[ValueTracking] Compute knownbits for `(and/or cond0

Full diff: https://github.com/llvm/llvm-project/pull/82818.diff

2 Files Affected:

(modified) llvm/lib/Analysis/ValueTracking.cpp (+11-4)
(modified) llvm/test/Transforms/InstCombine/known-bits.ll (+59)

diff --git a/llvm/lib/Analysis/ValueTracking.cpp b/llvm/lib/Analysis/ValueTracking.cpp
index 653b3d4ffd9883..562b1e574aea4d 100644
--- a/llvm/lib/Analysis/ValueTracking.cpp
+++ b/llvm/lib/Analysis/ValueTracking.cpp
@@ -711,10 +711,17 @@ static void computeKnownBitsFromCond(const Value *V, Value *Cond,
                                      const SimplifyQuery &SQ, bool Invert) {
   Value *A, *B;
   if (Depth < MaxAnalysisRecursionDepth &&
-      (Invert ? match(Cond, m_LogicalOr(m_Value(A), m_Value(B)))
-              : match(Cond, m_LogicalAnd(m_Value(A), m_Value(B))))) {
-    computeKnownBitsFromCond(V, A, Known, Depth + 1, SQ, Invert);
-    computeKnownBitsFromCond(V, B, Known, Depth + 1, SQ, Invert);
+      match(Cond, m_LogicalOp(m_Value(A), m_Value(B)))) {
+    KnownBits Known2(Known.getBitWidth());
+    KnownBits Known3(Known.getBitWidth());
+    computeKnownBitsFromCond(V, A, Known2, Depth + 1, SQ, Invert);
+    computeKnownBitsFromCond(V, B, Known3, Depth + 1, SQ, Invert);
+    if (Invert ? match(Cond, m_LogicalOr(m_Value(A), m_Value(B)))
+               : match(Cond, m_LogicalAnd(m_Value(A), m_Value(B))))
+      Known = Known2.unionWith(Known3);
+    else
+      Known2 = Known2.intersectWith(Known3);
+    Known = Known.unionWith(Known2);
   }
 
   if (auto *Cmp = dyn_cast<ICmpInst>(Cond))
diff --git a/llvm/test/Transforms/InstCombine/known-bits.ll b/llvm/test/Transforms/InstCombine/known-bits.ll
index 246579cc4cd0c0..b658ee0d2ef4e2 100644
--- a/llvm/test/Transforms/InstCombine/known-bits.ll
+++ b/llvm/test/Transforms/InstCombine/known-bits.ll
@@ -124,6 +124,65 @@ exit:
   ret i8 %or2
 }
 
+
+define i8 @test_cond_and_bothways(i8 %x) {
+; CHECK-LABEL: @test_cond_and_bothways(
+; CHECK-NEXT:    [[AND:%.*]] = and i8 [[X:%.*]], 91
+; CHECK-NEXT:    [[CMP0:%.*]] = icmp ne i8 [[AND]], 24
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp ne i8 [[X]], 0
+; CHECK-NEXT:    [[COND:%.*]] = and i1 [[CMP0]], [[CMP1]]
+; CHECK-NEXT:    br i1 [[COND]], label [[IF:%.*]], label [[EXIT:%.*]]
+; CHECK:       if:
+; CHECK-NEXT:    [[OR1:%.*]] = or i8 [[X]], -4
+; CHECK-NEXT:    ret i8 [[OR1]]
+; CHECK:       exit:
+; CHECK-NEXT:    ret i8 -4
+;
+  %and = and i8 %x, 91
+  %cmp0 = icmp ne i8 %and, 24
+  %cmp1 = icmp ne i8 %x, 0
+  %cond = and i1 %cmp0, %cmp1
+  br i1 %cond, label %if, label %exit
+
+if:
+  %or1 = or i8 %x, -4
+  ret i8 %or1
+
+exit:
+  %or2 = or i8 %x, -4
+  ret i8 %or2
+}
+
+define i8 @test_cond_or_bothways(i8 %x) {
+; CHECK-LABEL: @test_cond_or_bothways(
+; CHECK-NEXT:    [[AND:%.*]] = and i8 [[X:%.*]], 91
+; CHECK-NEXT:    [[CMP0:%.*]] = icmp eq i8 [[AND]], 24
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp eq i8 [[X]], 0
+; CHECK-NEXT:    [[COND:%.*]] = or i1 [[CMP0]], [[CMP1]]
+; CHECK-NEXT:    br i1 [[COND]], label [[IF:%.*]], label [[EXIT:%.*]]
+; CHECK:       if:
+; CHECK-NEXT:    ret i8 -4
+; CHECK:       exit:
+; CHECK-NEXT:    [[OR2:%.*]] = or i8 [[X]], -4
+; CHECK-NEXT:    ret i8 [[OR2]]
+;
+  %and = and i8 %x, 91
+  %cmp0 = icmp eq i8 %and, 24
+  %cmp1 = icmp eq i8 %x, 0
+  %cond = or i1 %cmp0, %cmp1
+  br i1 %cond, label %if, label %exit
+
+if:
+  %or1 = or i8 %x, -4
+  ret i8 %or1
+
+exit:
+  %or2 = or i8 %x, -4
+  ret i8 %or2
+}
+
+
+
 define i8 @test_cond_and_commuted(i8 %x, i1 %c1, i1 %c2) {
 ; CHECK-LABEL: @test_cond_and_commuted(
 ; CHECK-NEXT:    [[AND:%.*]] = and i8 [[X:%.*]], 3

PR Link: llvm/llvm-project#82818

llvm/lib/Analysis/ValueTracking.cpp

nikic · 2024-02-23T20:05:03Z

@dtcxzyw Can you please rerun the tests?

@goldsteinn What's the compile-time impact?

PR Link: llvm/llvm-project#82818

goldsteinn · 2024-02-23T20:34:25Z

@dtcxzyw Can you please rerun the tests?

@goldsteinn What's the compile-time impact?

No meaningful affect:
https://llvm-compile-time-tracker.com/compare.php?from=55bc0488af077acb47be70542718d1bc17f3de4f&to=a6a7dcd98c13617dfaf0f82614b06cc66a14694c&stat=instructions:u

dtcxzyw

LGTM.

llvm/lib/Analysis/ValueTracking.cpp

nikic

You'll also have to adjust the logic in DomCondCache to recurse into all and/or, not just ones that match the top-level type. Unless you intentionally only want to handle the inverted type at the top level?

Please recheck compile-time impact after doing that.

… sides of branch The false branch for `and` and true branch for `or` provide less information (intersection as opposed to union), but still can give some useful information.

goldsteinn · 2024-02-23T22:23:54Z

You'll also have to adjust the logic in DomCondCache to recurse into all and/or, not just ones that match the top-level type. Unless you intentionally only want to handle the inverted type at the top level?

Please recheck compile-time impact after doing that.

https://llvm-compile-time-tracker.com/compare.php?from=55bc0488af077acb47be70542718d1bc17f3de4f&to=d3e117a04afb14a00686eb689213776b2921154b&stat=instructions%3Au

Mostly minimal with two notable regressions:
Stage2-O0-g: tramp3d-v4 20259M 20310M (+0.25%)
Stage1-ReleaseLTO-g: consumer-typeset 58135M 58200M (+0.11%)

nikic

LGTM

[ValueTracking] Add tests for tracking (and/or cond0, cond1) on bot…

438afe2

…h sides of branch; NFC

goldsteinn requested a review from nikic as a code owner February 23, 2024 19:31

llvmbot added llvm:analysis llvm:transforms labels Feb 23, 2024

goldsteinn requested a review from dtcxzyw February 23, 2024 19:32

goldsteinn changed the title ~~goldsteinn/kb both sides~~ [ValueTracking] Compute knownbits for (and/or cond0, cond1) on both sides of branch Feb 23, 2024

dtcxzyw added a commit to dtcxzyw/llvm-opt-benchmark that referenced this pull request Feb 23, 2024

pre-commit: test PR82818

dcad570

PR Link: llvm/llvm-project#82818

dtcxzyw mentioned this pull request Feb 23, 2024

pre-commit: test PR82818 dtcxzyw/llvm-opt-benchmark#268

Closed

nikic reviewed Feb 23, 2024

View reviewed changes

llvm/lib/Analysis/ValueTracking.cpp Outdated Show resolved Hide resolved

goldsteinn force-pushed the goldsteinn/kb-both-sides branch from b43f0da to a6a7dcd Compare February 23, 2024 20:04

dtcxzyw added a commit to dtcxzyw/llvm-opt-benchmark that referenced this pull request Feb 23, 2024

pre-commit: test PR82818

db42b30

PR Link: llvm/llvm-project#82818

dtcxzyw approved these changes Feb 23, 2024

View reviewed changes

topperc reviewed Feb 23, 2024

View reviewed changes

llvm/lib/Analysis/ValueTracking.cpp Outdated Show resolved Hide resolved

nikic requested changes Feb 23, 2024

View reviewed changes

[ValueTracking] Compute knownbits for (and/or cond0, cond1) on both…

69d7bdd

… sides of branch The false branch for `and` and true branch for `or` provide less information (intersection as opposed to union), but still can give some useful information.

goldsteinn force-pushed the goldsteinn/kb-both-sides branch from a6a7dcd to 69d7bdd Compare February 23, 2024 21:51

nikic approved these changes Feb 25, 2024

View reviewed changes

goldsteinn closed this in 6f9b0a7 Feb 25, 2024

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Uh oh!

[ValueTracking] Compute knownbits for `(and/or cond0, cond1)` on both sides of branch #82818

[ValueTracking] Compute knownbits for `(and/or cond0, cond1)` on both sides of branch #82818

Uh oh!

goldsteinn commented Feb 23, 2024 •

edited

Loading

Uh oh!

llvmbot commented Feb 23, 2024

Uh oh!

llvmbot commented Feb 23, 2024

Uh oh!

Uh oh!

nikic commented Feb 23, 2024

Uh oh!

goldsteinn commented Feb 23, 2024

Uh oh!

dtcxzyw left a comment

Uh oh!

Uh oh!

nikic left a comment

Uh oh!

goldsteinn commented Feb 23, 2024

Uh oh!

nikic left a comment

Uh oh!

Uh oh!

[ValueTracking] Compute knownbits for (and/or cond0, cond1) on both sides of branch #82818

[ValueTracking] Compute knownbits for (and/or cond0, cond1) on both sides of branch #82818

Uh oh!

Conversation

goldsteinn commented Feb 23, 2024 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

llvmbot commented Feb 23, 2024

Uh oh!

llvmbot commented Feb 23, 2024

Uh oh!

Uh oh!

nikic commented Feb 23, 2024

Uh oh!

goldsteinn commented Feb 23, 2024

Uh oh!

dtcxzyw left a comment

Choose a reason for hiding this comment

Uh oh!

Uh oh!

nikic left a comment

Choose a reason for hiding this comment

Uh oh!

goldsteinn commented Feb 23, 2024

Uh oh!

nikic left a comment

Choose a reason for hiding this comment

Uh oh!

Uh oh!

[ValueTracking] Compute knownbits for `(and/or cond0, cond1)` on both sides of branch #82818

[ValueTracking] Compute knownbits for `(and/or cond0, cond1)` on both sides of branch #82818

goldsteinn commented Feb 23, 2024 •

edited

Loading