[llvm] r373117 - Revert [Dominators][CodeGen] Clean up MachineDominators
Jakub Kuderski via llvm-commits
llvm-commits at lists.llvm.org
Fri Sep 27 12:33:39 PDT 2019
Author: kuhar
Date: Fri Sep 27 12:33:39 2019
New Revision: 373117
URL: http://llvm.org/viewvc/llvm-project?rev=373117&view=rev
Log:
Revert [Dominators][CodeGen] Clean up MachineDominators
This reverts r373101 (git commit 72c57ec3e6b320c31274dadb888dc16772b8e7b6)
Modified:
llvm/trunk/include/llvm/CodeGen/MachineDominators.h
llvm/trunk/lib/CodeGen/MachineDominators.cpp
Modified: llvm/trunk/include/llvm/CodeGen/MachineDominators.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/CodeGen/MachineDominators.h?rev=373117&r1=373116&r2=373117&view=diff
==============================================================================
--- llvm/trunk/include/llvm/CodeGen/MachineDominators.h (original)
+++ llvm/trunk/include/llvm/CodeGen/MachineDominators.h Fri Sep 27 12:33:39 2019
@@ -44,8 +44,6 @@ using MachineDomTreeNode = DomTreeNodeBa
/// compute a normal dominator tree.
///
class MachineDominatorTree : public MachineFunctionPass {
- using DomTreeT = DomTreeBase<MachineBasicBlock>;
-
/// Helper structure used to hold all the basic blocks
/// involved in the split of a critical edge.
struct CriticalEdge {
@@ -67,8 +65,8 @@ class MachineDominatorTree : public Mach
/// such as BB == elt.NewBB.
mutable SmallSet<MachineBasicBlock *, 32> NewBBs;
- /// The DominatorTreeBase that is used to compute a normal dominator tree.
- std::unique_ptr<DomTreeT> DT;
+ /// The DominatorTreeBase that is used to compute a normal dominator tree
+ std::unique_ptr<DomTreeBase<MachineBasicBlock>> DT;
/// Apply all the recorded critical edges to the DT.
/// This updates the underlying DT information in a way that uses
@@ -82,8 +80,8 @@ public:
MachineDominatorTree();
- DomTreeT &getBase() {
- if (!DT) DT.reset(new DomTreeT());
+ DomTreeBase<MachineBasicBlock> &getBase() {
+ if (!DT) DT.reset(new DomTreeBase<MachineBasicBlock>());
applySplitCriticalEdges();
return *DT;
}
@@ -94,30 +92,31 @@ public:
/// multiple blocks if we are computing post dominators. For forward
/// dominators, this will always be a single block (the entry node).
///
- const SmallVectorImpl<MachineBasicBlock*> &getRoots() const {
+ inline const SmallVectorImpl<MachineBasicBlock*> &getRoots() const {
applySplitCriticalEdges();
return DT->getRoots();
}
- MachineBasicBlock *getRoot() const {
+ inline MachineBasicBlock *getRoot() const {
applySplitCriticalEdges();
return DT->getRoot();
}
- MachineDomTreeNode *getRootNode() const {
+ inline MachineDomTreeNode *getRootNode() const {
applySplitCriticalEdges();
return DT->getRootNode();
}
bool runOnMachineFunction(MachineFunction &F) override;
- bool dominates(const MachineDomTreeNode *A,
- const MachineDomTreeNode *B) const {
+ inline bool dominates(const MachineDomTreeNode* A,
+ const MachineDomTreeNode* B) const {
applySplitCriticalEdges();
return DT->dominates(A, B);
}
- bool dominates(const MachineBasicBlock *A, const MachineBasicBlock *B) const {
+ inline bool dominates(const MachineBasicBlock* A,
+ const MachineBasicBlock* B) const {
applySplitCriticalEdges();
return DT->dominates(A, B);
}
@@ -134,30 +133,36 @@ public:
for (; &*I != A && &*I != B; ++I)
/*empty*/ ;
- return &*I == A;
+ //if(!DT.IsPostDominators) {
+ // A dominates B if it is found first in the basic block.
+ return &*I == A;
+ //} else {
+ // // A post-dominates B if B is found first in the basic block.
+ // return &*I == B;
+ //}
}
- bool properlyDominates(const MachineDomTreeNode *A,
- const MachineDomTreeNode *B) const {
+ inline bool properlyDominates(const MachineDomTreeNode* A,
+ const MachineDomTreeNode* B) const {
applySplitCriticalEdges();
return DT->properlyDominates(A, B);
}
- bool properlyDominates(const MachineBasicBlock *A,
- const MachineBasicBlock *B) const {
+ inline bool properlyDominates(const MachineBasicBlock* A,
+ const MachineBasicBlock* B) const {
applySplitCriticalEdges();
return DT->properlyDominates(A, B);
}
/// findNearestCommonDominator - Find nearest common dominator basic block
/// for basic block A and B. If there is no such block then return NULL.
- MachineBasicBlock *findNearestCommonDominator(MachineBasicBlock *A,
- MachineBasicBlock *B) {
+ inline MachineBasicBlock *findNearestCommonDominator(MachineBasicBlock *A,
+ MachineBasicBlock *B) {
applySplitCriticalEdges();
return DT->findNearestCommonDominator(A, B);
}
- MachineDomTreeNode *operator[](MachineBasicBlock *BB) const {
+ inline MachineDomTreeNode *operator[](MachineBasicBlock *BB) const {
applySplitCriticalEdges();
return DT->getNode(BB);
}
@@ -165,7 +170,7 @@ public:
/// getNode - return the (Post)DominatorTree node for the specified basic
/// block. This is the same as using operator[] on this class.
///
- MachineDomTreeNode *getNode(MachineBasicBlock *BB) const {
+ inline MachineDomTreeNode *getNode(MachineBasicBlock *BB) const {
applySplitCriticalEdges();
return DT->getNode(BB);
}
@@ -173,8 +178,8 @@ public:
/// addNewBlock - Add a new node to the dominator tree information. This
/// creates a new node as a child of DomBB dominator node,linking it into
/// the children list of the immediate dominator.
- MachineDomTreeNode *addNewBlock(MachineBasicBlock *BB,
- MachineBasicBlock *DomBB) {
+ inline MachineDomTreeNode *addNewBlock(MachineBasicBlock *BB,
+ MachineBasicBlock *DomBB) {
applySplitCriticalEdges();
return DT->addNewBlock(BB, DomBB);
}
@@ -182,14 +187,14 @@ public:
/// changeImmediateDominator - This method is used to update the dominator
/// tree information when a node's immediate dominator changes.
///
- void changeImmediateDominator(MachineBasicBlock *N,
- MachineBasicBlock *NewIDom) {
+ inline void changeImmediateDominator(MachineBasicBlock *N,
+ MachineBasicBlock* NewIDom) {
applySplitCriticalEdges();
DT->changeImmediateDominator(N, NewIDom);
}
- void changeImmediateDominator(MachineDomTreeNode *N,
- MachineDomTreeNode *NewIDom) {
+ inline void changeImmediateDominator(MachineDomTreeNode *N,
+ MachineDomTreeNode* NewIDom) {
applySplitCriticalEdges();
DT->changeImmediateDominator(N, NewIDom);
}
@@ -197,14 +202,14 @@ public:
/// eraseNode - Removes a node from the dominator tree. Block must not
/// dominate any other blocks. Removes node from its immediate dominator's
/// children list. Deletes dominator node associated with basic block BB.
- void eraseNode(MachineBasicBlock *BB) {
+ inline void eraseNode(MachineBasicBlock *BB) {
applySplitCriticalEdges();
DT->eraseNode(BB);
}
/// splitBlock - BB is split and now it has one successor. Update dominator
/// tree to reflect this change.
- void splitBlock(MachineBasicBlock* NewBB) {
+ inline void splitBlock(MachineBasicBlock* NewBB) {
applySplitCriticalEdges();
DT->splitBlock(NewBB);
}
Modified: llvm/trunk/lib/CodeGen/MachineDominators.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/CodeGen/MachineDominators.cpp?rev=373117&r1=373116&r2=373117&view=diff
==============================================================================
--- llvm/trunk/lib/CodeGen/MachineDominators.cpp (original)
+++ llvm/trunk/lib/CodeGen/MachineDominators.cpp Fri Sep 27 12:33:39 2019
@@ -64,11 +64,21 @@ void MachineDominatorTree::releaseMemory
}
void MachineDominatorTree::verifyAnalysis() const {
- if (DT && VerifyMachineDomInfo)
- if (!DT->verify(DomTreeT::VerificationLevel::Basic)) {
- errs() << "MachineDominatorTree verification failed\n";
+ if (DT && VerifyMachineDomInfo) {
+ MachineFunction &F = *getRoot()->getParent();
+
+ DomTreeBase<MachineBasicBlock> OtherDT;
+ OtherDT.recalculate(F);
+ if (getRootNode()->getBlock() != OtherDT.getRootNode()->getBlock() ||
+ DT->compare(OtherDT)) {
+ errs() << "MachineDominatorTree for function " << F.getName()
+ << " is not up to date!\nComputed:\n";
+ DT->print(errs());
+ errs() << "\nActual:\n";
+ OtherDT.print(errs());
abort();
}
+ }
}
void MachineDominatorTree::print(raw_ostream &OS, const Module*) const {
More information about the llvm-commits
mailing list