[DFAJumpThreading] Unify equivalent states #162447
Merged
Conversation
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
|
@llvm/pr-subscribers-llvm-transforms Author: Hongyu Chen (XChy) ChangesDFAJumpThreading determines the switch destination of a threadable path based on its next state and cannot reuse cloned blocks if their destinations differ. Full diff: https://github.com/llvm/llvm-project/pull/162447.diff 2 Files Affected:
diff --git a/llvm/lib/Transforms/Scalar/DFAJumpThreading.cpp b/llvm/lib/Transforms/Scalar/DFAJumpThreading.cpp
index ae34b4e6fbacf..92c573d53c8ee 100644
--- a/llvm/lib/Transforms/Scalar/DFAJumpThreading.cpp
+++ b/llvm/lib/Transforms/Scalar/DFAJumpThreading.cpp
@@ -384,6 +384,22 @@ inline raw_ostream &operator<<(raw_ostream &OS, const PathType &Path) {
return OS;
}
+/// Helper to get the successor corresponding to a particular case value for
+/// a switch statement.
+static BasicBlock *getNextCaseSuccessor(SwitchInst *Switch,
+ const APInt &NextState) {
+ BasicBlock *NextCase = nullptr;
+ for (auto Case : Switch->cases()) {
+ if (Case.getCaseValue()->getValue() == NextState) {
+ NextCase = Case.getCaseSuccessor();
+ break;
+ }
+ }
+ if (!NextCase)
+ NextCase = Switch->getDefaultDest();
+ return NextCase;
+}
+
namespace {
/// ThreadingPath is a path in the control flow of a loop that can be threaded
/// by cloning necessary basic blocks and replacing conditional branches with
@@ -396,6 +412,10 @@ struct ThreadingPath {
ExitVal = V->getValue();
IsExitValSet = true;
}
+ void setExitValue(const APInt &V) {
+ ExitVal = V;
+ IsExitValSet = true;
+ }
bool isExitValueSet() const { return IsExitValSet; }
/// Determinator is the basic block that determines the next state of the DFA.
@@ -578,44 +598,8 @@ struct AllSwitchPaths {
BasicBlock *getSwitchBlock() { return SwitchBlock; }
void run() {
- StateDefMap StateDef = getStateDefMap();
- if (StateDef.empty()) {
- ORE->emit([&]() {
- return OptimizationRemarkMissed(DEBUG_TYPE, "SwitchNotPredictable",
- Switch)
- << "Switch instruction is not predictable.";
- });
- return;
- }
-
- auto *SwitchPhi = cast<PHINode>(Switch->getOperand(0));
- auto *SwitchPhiDefBB = SwitchPhi->getParent();
- VisitedBlocks VB;
- // Get paths from the determinator BBs to SwitchPhiDefBB
- std::vector<ThreadingPath> PathsToPhiDef =
- getPathsFromStateDefMap(StateDef, SwitchPhi, VB, MaxNumPaths);
- if (SwitchPhiDefBB == SwitchBlock || PathsToPhiDef.empty()) {
- TPaths = std::move(PathsToPhiDef);
- return;
- }
-
- assert(MaxNumPaths >= PathsToPhiDef.size() && !PathsToPhiDef.empty());
- auto PathsLimit = MaxNumPaths / PathsToPhiDef.size();
- // Find and append paths from SwitchPhiDefBB to SwitchBlock.
- PathsType PathsToSwitchBB =
- paths(SwitchPhiDefBB, SwitchBlock, VB, /* PathDepth = */ 1, PathsLimit);
- if (PathsToSwitchBB.empty())
- return;
-
- std::vector<ThreadingPath> TempList;
- for (const ThreadingPath &Path : PathsToPhiDef) {
- for (const PathType &PathToSw : PathsToSwitchBB) {
- ThreadingPath PathCopy(Path);
- PathCopy.appendExcludingFirst(PathToSw);
- TempList.push_back(PathCopy);
- }
- }
- TPaths = std::move(TempList);
+ findTPaths();
+ unifyTPaths();
}
private:
@@ -807,6 +791,69 @@ struct AllSwitchPaths {
return Res;
}
+ // Find all threadable paths.
+ void findTPaths() {
+ StateDefMap StateDef = getStateDefMap();
+ if (StateDef.empty()) {
+ ORE->emit([&]() {
+ return OptimizationRemarkMissed(DEBUG_TYPE, "SwitchNotPredictable",
+ Switch)
+ << "Switch instruction is not predictable.";
+ });
+ return;
+ }
+
+ auto *SwitchPhi = cast<PHINode>(Switch->getOperand(0));
+ auto *SwitchPhiDefBB = SwitchPhi->getParent();
+ VisitedBlocks VB;
+ // Get paths from the determinator BBs to SwitchPhiDefBB
+ std::vector<ThreadingPath> PathsToPhiDef =
+ getPathsFromStateDefMap(StateDef, SwitchPhi, VB, MaxNumPaths);
+ if (SwitchPhiDefBB == SwitchBlock || PathsToPhiDef.empty()) {
+ TPaths = std::move(PathsToPhiDef);
+ return;
+ }
+
+ assert(MaxNumPaths >= PathsToPhiDef.size() && !PathsToPhiDef.empty());
+ auto PathsLimit = MaxNumPaths / PathsToPhiDef.size();
+ // Find and append paths from SwitchPhiDefBB to SwitchBlock.
+ PathsType PathsToSwitchBB =
+ paths(SwitchPhiDefBB, SwitchBlock, VB, /* PathDepth = */ 1, PathsLimit);
+ if (PathsToSwitchBB.empty())
+ return;
+
+ std::vector<ThreadingPath> TempList;
+ for (const ThreadingPath &Path : PathsToPhiDef) {
+ for (const PathType &PathToSw : PathsToSwitchBB) {
+ ThreadingPath PathCopy(Path);
+ PathCopy.appendExcludingFirst(PathToSw);
+ TempList.push_back(PathCopy);
+ }
+ }
+ TPaths = std::move(TempList);
+ }
+
+ // Two states are equivalent if they have the same switch destination.
+ // Unify the states in different threading path if the states are equivalent.
+ void unifyTPaths() {
+ llvm::SmallDenseMap<BasicBlock *, APInt> DestToState;
+ for (ThreadingPath &Path : TPaths) {
+ APInt NextState = Path.getExitValue();
+ BasicBlock *Dest = getNextCaseSuccessor(Switch, NextState);
+ auto StateIt = DestToState.find(Dest);
+ if (StateIt == DestToState.end()) {
+ DestToState.insert({Dest, NextState});
+ continue;
+ }
+
+ if (NextState != StateIt->second) {
+ LLVM_DEBUG(dbgs() << "Next state in " << Path << " is equivalent to "
+ << StateIt->second << "\n");
+ Path.setExitValue(StateIt->second);
+ }
+ }
+ }
+
unsigned NumVisited = 0;
SwitchInst *Switch;
BasicBlock *SwitchBlock;
@@ -1339,21 +1386,6 @@ struct TransformDFA {
return It != ClonedBBs.end() ? (*It).BB : nullptr;
}
- /// Helper to get the successor corresponding to a particular case value for
- /// a switch statement.
- BasicBlock *getNextCaseSuccessor(SwitchInst *Switch, const APInt &NextState) {
- BasicBlock *NextCase = nullptr;
- for (auto Case : Switch->cases()) {
- if (Case.getCaseValue()->getValue() == NextState) {
- NextCase = Case.getCaseSuccessor();
- break;
- }
- }
- if (!NextCase)
- NextCase = Switch->getDefaultDest();
- return NextCase;
- }
-
/// Returns true if IncomingBB is a predecessor of BB.
bool isPredecessor(BasicBlock *BB, BasicBlock *IncomingBB) {
return llvm::is_contained(predecessors(BB), IncomingBB);
diff --git a/llvm/test/Transforms/DFAJumpThreading/equivalent-states.ll b/llvm/test/Transforms/DFAJumpThreading/equivalent-states.ll
new file mode 100644
index 0000000000000..4555dfb87330f
--- /dev/null
+++ b/llvm/test/Transforms/DFAJumpThreading/equivalent-states.ll
@@ -0,0 +1,281 @@
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 3
+; RUN: opt -S -passes=dfa-jump-threading %s | FileCheck %s
+
+declare void @do_something()
+declare void @user(i32)
+
+define void @equivalent_on_default(i1 %c1) {
+; CHECK-LABEL: define void @equivalent_on_default(
+; CHECK-SAME: i1 [[C1:%.*]]) {
+; CHECK-NEXT: entry:
+; CHECK-NEXT: br label [[SWITCH_BB:%.*]]
+; CHECK: switch_bb:
+; CHECK-NEXT: [[PHI:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ poison, [[CASE2END:%.*]] ]
+; CHECK-NEXT: switch i32 [[PHI]], label [[DEFAULT_DEST:%.*]] [
+; CHECK-NEXT: i32 0, label [[CASE1:%.*]]
+; CHECK-NEXT: i32 1, label [[CASE2:%.*]]
+; CHECK-NEXT: ]
+; CHECK: switch_bb.jt2:
+; CHECK-NEXT: [[PHI_JT2:%.*]] = phi i32 [ [[PHI_CASE2_JT2:%.*]], [[CASE2END_JT2:%.*]] ]
+; CHECK-NEXT: br label [[DEFAULT_DEST]]
+; CHECK: switch_bb.jt1:
+; CHECK-NEXT: [[PHI_JT1:%.*]] = phi i32 [ 1, [[CASE1]] ]
+; CHECK-NEXT: br label [[CASE2]]
+; CHECK: case1:
+; CHECK-NEXT: br label [[SWITCH_BB_JT1:%.*]]
+; CHECK: case2:
+; CHECK-NEXT: br i1 [[C1]], label [[CASE2THEN:%.*]], label [[CASE2END_JT2]]
+; CHECK: case2then:
+; CHECK-NEXT: br label [[CASE2END_JT2]]
+; CHECK: case2end:
+; CHECK-NEXT: call void @do_something()
+; CHECK-NEXT: br label [[SWITCH_BB]]
+; CHECK: case2end.jt2:
+; CHECK-NEXT: [[PHI_CASE2_JT2]] = phi i32 [ 2, [[CASE2]] ], [ 3, [[CASE2THEN]] ]
+; CHECK-NEXT: call void @do_something()
+; CHECK-NEXT: br label [[SWITCH_BB_JT2:%.*]]
+; CHECK: default_dest:
+; CHECK-NEXT: ret void
+;
+entry:
+ br label %switch_bb
+
+switch_bb:
+ %phi = phi i32 [ 0, %entry ], [ 1, %case1 ], [ %phi_case2, %case2end ]
+ switch i32 %phi, label %default_dest [
+ i32 0, label %case1
+ i32 1, label %case2
+ ]
+
+case1:
+ br label %switch_bb
+
+case2:
+ br i1 %c1, label %case2then, label %case2end
+
+case2then:
+ br label %case2end
+
+case2end:
+ %phi_case2 = phi i32 [ 2, %case2 ] , [ 3, %case2then ]
+ call void @do_something()
+ br label %switch_bb
+
+default_dest:
+ ret void
+}
+
+define void @equivalent_on_default_user(i1 %c1) {
+; CHECK-LABEL: define void @equivalent_on_default_user(
+; CHECK-SAME: i1 [[C1:%.*]]) {
+; CHECK-NEXT: entry:
+; CHECK-NEXT: br label [[SWITCH_BB:%.*]]
+; CHECK: switch_bb:
+; CHECK-NEXT: [[PHI:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ poison, [[CASE2END:%.*]] ]
+; CHECK-NEXT: switch i32 [[PHI]], label [[DEFAULT_DEST:%.*]] [
+; CHECK-NEXT: i32 0, label [[CASE1:%.*]]
+; CHECK-NEXT: i32 1, label [[CASE2:%.*]]
+; CHECK-NEXT: ]
+; CHECK: switch_bb.jt2:
+; CHECK-NEXT: [[PHI_JT2:%.*]] = phi i32 [ [[PHI_CASE2_JT2:%.*]], [[CASE2END_JT2:%.*]] ]
+; CHECK-NEXT: br label [[DEFAULT_DEST]]
+; CHECK: switch_bb.jt1:
+; CHECK-NEXT: [[PHI_JT1:%.*]] = phi i32 [ 1, [[CASE1]] ]
+; CHECK-NEXT: br label [[CASE2]]
+; CHECK: case1:
+; CHECK-NEXT: br label [[SWITCH_BB_JT1:%.*]]
+; CHECK: case2:
+; CHECK-NEXT: br i1 [[C1]], label [[CASE2THEN:%.*]], label [[CASE2END_JT2]]
+; CHECK: case2then:
+; CHECK-NEXT: br label [[CASE2END_JT2]]
+; CHECK: case2end:
+; CHECK-NEXT: call void @do_something()
+; CHECK-NEXT: call void @user(i32 poison)
+; CHECK-NEXT: br label [[SWITCH_BB]]
+; CHECK: case2end.jt2:
+; CHECK-NEXT: [[PHI_CASE2_JT2]] = phi i32 [ 2, [[CASE2]] ], [ 3, [[CASE2THEN]] ]
+; CHECK-NEXT: call void @do_something()
+; CHECK-NEXT: call void @user(i32 [[PHI_CASE2_JT2]])
+; CHECK-NEXT: br label [[SWITCH_BB_JT2:%.*]]
+; CHECK: default_dest:
+; CHECK-NEXT: ret void
+;
+entry:
+ br label %switch_bb
+
+switch_bb:
+ %phi = phi i32 [ 0, %entry ], [ 1, %case1 ], [ %phi_case2, %case2end ]
+ switch i32 %phi, label %default_dest [
+ i32 0, label %case1
+ i32 1, label %case2
+ ]
+
+case1:
+ br label %switch_bb
+
+case2:
+ br i1 %c1, label %case2then, label %case2end
+
+case2then:
+ br label %case2end
+
+case2end:
+ %phi_case2 = phi i32 [ 2, %case2 ] , [ 3, %case2then ]
+ call void @do_something()
+ call void @user(i32 %phi_case2)
+ br label %switch_bb
+
+default_dest:
+ ret void
+}
+
+define void @equivalent_only_cases(i1 %c1) {
+; CHECK-LABEL: define void @equivalent_only_cases(
+; CHECK-SAME: i1 [[C1:%.*]]) {
+; CHECK-NEXT: entry:
+; CHECK-NEXT: br label [[SWITCH_BB:%.*]]
+; CHECK: switch_bb:
+; CHECK-NEXT: [[PHI:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ poison, [[CASE2END:%.*]] ]
+; CHECK-NEXT: switch i32 [[PHI]], label [[DEFAULT_DEST:%.*]] [
+; CHECK-NEXT: i32 0, label [[CASE1:%.*]]
+; CHECK-NEXT: i32 1, label [[CASE2:%.*]]
+; CHECK-NEXT: i32 2, label [[CASE1]]
+; CHECK-NEXT: i32 3, label [[CASE1]]
+; CHECK-NEXT: ]
+; CHECK: switch_bb.jt2:
+; CHECK-NEXT: [[PHI_JT2:%.*]] = phi i32 [ [[PHI_CASE2_JT2:%.*]], [[CASE2END_JT2:%.*]] ]
+; CHECK-NEXT: br label [[CASE1]]
+; CHECK: switch_bb.jt1:
+; CHECK-NEXT: [[PHI_JT1:%.*]] = phi i32 [ 1, [[CASE1]] ]
+; CHECK-NEXT: br label [[CASE2]]
+; CHECK: case1:
+; CHECK-NEXT: call void @do_something()
+; CHECK-NEXT: br label [[SWITCH_BB_JT1:%.*]]
+; CHECK: case2:
+; CHECK-NEXT: br i1 [[C1]], label [[CASE2THEN:%.*]], label [[CASE2END_JT2]]
+; CHECK: case2then:
+; CHECK-NEXT: br label [[CASE2END_JT2]]
+; CHECK: case2end:
+; CHECK-NEXT: call void @do_something()
+; CHECK-NEXT: br label [[SWITCH_BB]]
+; CHECK: case2end.jt2:
+; CHECK-NEXT: [[PHI_CASE2_JT2]] = phi i32 [ 2, [[CASE2]] ], [ 3, [[CASE2THEN]] ]
+; CHECK-NEXT: call void @do_something()
+; CHECK-NEXT: br label [[SWITCH_BB_JT2:%.*]]
+; CHECK: default_dest:
+; CHECK-NEXT: ret void
+;
+entry:
+ br label %switch_bb
+
+switch_bb:
+ %phi = phi i32 [ 0, %entry ], [ 1, %case1 ], [ %phi_case2, %case2end ]
+ switch i32 %phi, label %default_dest [
+ i32 0, label %case1
+ i32 1, label %case2
+ i32 2, label %case1
+ i32 3, label %case1
+ ]
+
+case1:
+ call void @do_something()
+ br label %switch_bb
+
+case2:
+ br i1 %c1, label %case2then, label %case2end
+
+case2then:
+ br label %case2end
+
+case2end:
+ %phi_case2 = phi i32 [ 2, %case2 ] , [ 3, %case2then ]
+ call void @do_something()
+ br label %switch_bb
+
+default_dest:
+ ret void
+}
+
+define void @equivalent_both_case_and_default(i1 %c1, i1 %c2) {
+; CHECK-LABEL: define void @equivalent_both_case_and_default(
+; CHECK-SAME: i1 [[C1:%.*]], i1 [[C2:%.*]]) {
+; CHECK-NEXT: entry:
+; CHECK-NEXT: br label [[SWITCH_BB:%.*]]
+; CHECK: switch_bb:
+; CHECK-NEXT: [[PHI:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ poison, [[CASE2END:%.*]] ]
+; CHECK-NEXT: switch i32 [[PHI]], label [[DEFAULT_DEST:%.*]] [
+; CHECK-NEXT: i32 0, label [[CASE1:%.*]]
+; CHECK-NEXT: i32 1, label [[CASE2:%.*]]
+; CHECK-NEXT: i32 2, label [[CASE1]]
+; CHECK-NEXT: i32 3, label [[CASE1]]
+; CHECK-NEXT: ]
+; CHECK: switch_bb.jt4:
+; CHECK-NEXT: [[PHI_JT3:%.*]] = phi i32 [ [[PHI_CASE2_JT3:%.*]], [[CASE2END_JT3:%.*]] ]
+; CHECK-NEXT: br label [[DEFAULT_DEST]]
+; CHECK: switch_bb.jt2:
+; CHECK-NEXT: [[PHI_JT2:%.*]] = phi i32 [ [[PHI_CASE2_JT2:%.*]], [[CASE2END_JT2:%.*]] ]
+; CHECK-NEXT: br label [[CASE1]]
+; CHECK: switch_bb.jt1:
+; CHECK-NEXT: [[PHI_JT1:%.*]] = phi i32 [ 1, [[CASE1]] ]
+; CHECK-NEXT: br label [[CASE2]]
+; CHECK: case1:
+; CHECK-NEXT: call void @do_something()
+; CHECK-NEXT: br label [[SWITCH_BB_JT1:%.*]]
+; CHECK: case2:
+; CHECK-NEXT: br i1 [[C1]], label [[CASE2THEN:%.*]], label [[CASE2END_JT2]]
+; CHECK: case2then:
+; CHECK-NEXT: br i1 [[C2]], label [[CASE2THEN2:%.*]], label [[CASE2END_JT2]]
+; CHECK: case2then2:
+; CHECK-NEXT: br i1 [[C2]], label [[CASE2THEN3:%.*]], label [[CASE2END_JT3]]
+; CHECK: case2then3:
+; CHECK-NEXT: br label [[CASE2END_JT3]]
+; CHECK: case2end:
+; CHECK-NEXT: call void @do_something()
+; CHECK-NEXT: br label [[SWITCH_BB]]
+; CHECK: case2end.jt4:
+; CHECK-NEXT: [[PHI_CASE2_JT3]] = phi i32 [ 4, [[CASE2THEN2]] ], [ 5, [[CASE2THEN3]] ]
+; CHECK-NEXT: call void @do_something()
+; CHECK-NEXT: br label [[SWITCH_BB_JT3:%.*]]
+; CHECK: case2end.jt2:
+; CHECK-NEXT: [[PHI_CASE2_JT2]] = phi i32 [ 2, [[CASE2]] ], [ 3, [[CASE2THEN]] ]
+; CHECK-NEXT: call void @do_something()
+; CHECK-NEXT: br label [[SWITCH_BB_JT2:%.*]]
+; CHECK: default_dest:
+; CHECK-NEXT: ret void
+;
+entry:
+ br label %switch_bb
+
+switch_bb:
+ %phi = phi i32 [ 0, %entry ], [ 1, %case1 ], [ %phi_case2, %case2end ]
+ switch i32 %phi, label %default_dest [
+ i32 0, label %case1
+ i32 1, label %case2
+ i32 2, label %case1
+ i32 3, label %case1
+ ]
+
+case1:
+ call void @do_something()
+ br label %switch_bb
+
+case2:
+ br i1 %c1, label %case2then, label %case2end
+
+case2then:
+ br i1 %c2, label %case2then2, label %case2end
+
+case2then2:
+ br i1 %c2, label %case2then3, label %case2end
+
+case2then3:
+ br label %case2end
+
+case2end:
+ %phi_case2 = phi i32 [ 2, %case2 ], [ 3, %case2then ], [ 4, %case2then2 ], [ 5, %case2then3 ]
+ call void @do_something()
+ br label %switch_bb
+
+default_dest:
+ ret void
+}
|
|
Some metrics: |
UsmanNadeem
approved these changes
Oct 10, 2025
|
LLVM Buildbot has detected a new failure on builder Full details are available at: https://lab.llvm.org/buildbot/#/builders/88/builds/16986 Here is the relevant piece of the build log for the reference |
nikic
reviewed
Oct 10, 2025
| BasicBlock *Dest = getNextCaseSuccessor(Switch, NextState); | ||
| auto StateIt = DestToState.find(Dest); | ||
| if (StateIt == DestToState.end()) { | ||
| DestToState.insert({Dest, NextState}); |
There was a problem hiding this comment.
Can avoid the duplicate lookup here by using try_emplace.
There was a problem hiding this comment.
Thanks for the review. I will resolve these problems.
| if (!NextCase) | ||
| NextCase = Switch->getDefaultDest(); | ||
| return NextCase; | ||
| } |
There was a problem hiding this comment.
I realize you only moved this code, but it would probably make sense to compute the value => successor mapping once instead of scanning the whole switch each time.
There was a problem hiding this comment.
Yes, though it may not be the bottleneck, it's worth pre-computing.
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
5 participants
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
DFAJumpThreading determines the switch destination of a threadable path based on its next state and cannot reuse cloned blocks if their destinations differ.
However, different states may lead to the same destination. This patch unifies equivalent states, thereby avoiding redundant duplication of cloned blocks.