diff --git a/include/llvm/Analysis/PostDominators.h b/include/llvm/Analysis/PostDominators.h index 07d1a86f0d1..0f7e2b88d2d 100644 --- a/include/llvm/Analysis/PostDominators.h +++ b/include/llvm/Analysis/PostDominators.h @@ -17,58 +17,20 @@ #include "llvm/IR/Dominators.h" namespace llvm { -// FIXME: Replace this brittle forward declaration with the include of the new -// PassManager.h when doing so doesn't break the PassManagerBuilder. -class PreservedAnalyses; /// PostDominatorTree Class - Concrete subclass of DominatorTree that is used to /// compute the post-dominator tree. /// -struct PostDominatorTree : public DominatorTreeBase { - PostDominatorTree() : DominatorTreeBase(true) {} -}; - -/// \brief Analysis pass which computes a \c PostDominatorTree. -class PostDominatorTreeAnalysis { -public: - /// \brief Provide the result typedef for this analysis pass. - typedef PostDominatorTree Result; - - /// \brief Opaque, unique identifier for this analysis pass. - static void *ID() { return (void *)&PassID; } - - /// \brief Run the analysis pass over a function and produce a post dominator - /// tree. - PostDominatorTree run(Function &F); - - /// \brief Provide access to a name for this pass for debugging purposes. - static StringRef name() { return "PostDominatorTreeAnalysis"; } - -private: - static char PassID; -}; - -/// \brief Printer pass for the \c PostDominatorTree. -class PostDominatorTreePrinterPass { - raw_ostream &OS; - -public: - explicit PostDominatorTreePrinterPass(raw_ostream &OS); - PreservedAnalyses run(Function &F, AnalysisManager *AM); - - static StringRef name() { return "PostDominatorTreePrinterPass"; } -}; - -struct PostDominatorTreeWrapperPass : public FunctionPass { +struct PostDominatorTree : public FunctionPass { static char ID; // Pass identification, replacement for typeid - PostDominatorTree DT; + DominatorTreeBase* DT; - PostDominatorTreeWrapperPass() : FunctionPass(ID) { - initializePostDominatorTreeWrapperPassPass(*PassRegistry::getPassRegistry()); + PostDominatorTree() : FunctionPass(ID) { + initializePostDominatorTreePass(*PassRegistry::getPassRegistry()); + DT = new DominatorTreeBase(true); } - PostDominatorTree &getPostDomTree() { return DT; } - const PostDominatorTree &getPostDomTree() const { return DT; } + ~PostDominatorTree() override; bool runOnFunction(Function &F) override; @@ -76,8 +38,55 @@ struct PostDominatorTreeWrapperPass : public FunctionPass { AU.setPreservesAll(); } + inline const std::vector &getRoots() const { + return DT->getRoots(); + } + + inline DomTreeNode *getRootNode() const { + return DT->getRootNode(); + } + + inline DomTreeNode *operator[](BasicBlock *BB) const { + return DT->getNode(BB); + } + + inline DomTreeNode *getNode(BasicBlock *BB) const { + return DT->getNode(BB); + } + + inline bool dominates(DomTreeNode* A, DomTreeNode* B) const { + return DT->dominates(A, B); + } + + inline bool dominates(const BasicBlock* A, const BasicBlock* B) const { + return DT->dominates(A, B); + } + + inline bool properlyDominates(const DomTreeNode* A, DomTreeNode* B) const { + return DT->properlyDominates(A, B); + } + + inline bool properlyDominates(BasicBlock* A, BasicBlock* B) const { + return DT->properlyDominates(A, B); + } + + inline BasicBlock *findNearestCommonDominator(BasicBlock *A, BasicBlock *B) { + return DT->findNearestCommonDominator(A, B); + } + + inline const BasicBlock *findNearestCommonDominator(const BasicBlock *A, + const BasicBlock *B) { + return DT->findNearestCommonDominator(A, B); + } + + /// Get all nodes post-dominated by R, including R itself. + void getDescendants(BasicBlock *R, + SmallVectorImpl &Result) const { + DT->getDescendants(R, Result); + } + void releaseMemory() override { - DT.releaseMemory(); + DT->releaseMemory(); } void print(raw_ostream &OS, const Module*) const override; diff --git a/include/llvm/InitializePasses.h b/include/llvm/InitializePasses.h index 5f2b886a18a..296962ba2a0 100644 --- a/include/llvm/InitializePasses.h +++ b/include/llvm/InitializePasses.h @@ -232,7 +232,7 @@ void initializePostDomOnlyPrinterPass(PassRegistry&); void initializePostDomOnlyViewerPass(PassRegistry&); void initializePostDomPrinterPass(PassRegistry&); void initializePostDomViewerPass(PassRegistry&); -void initializePostDominatorTreeWrapperPassPass(PassRegistry&); +void initializePostDominatorTreePass(PassRegistry&); void initializePostOrderFunctionAttrsLegacyPassPass(PassRegistry&); void initializePostRASchedulerPass(PassRegistry&); void initializePostMachineSchedulerPass(PassRegistry&); diff --git a/lib/Analysis/Analysis.cpp b/lib/Analysis/Analysis.cpp index 9c53dedad03..811741962aa 100644 --- a/lib/Analysis/Analysis.cpp +++ b/lib/Analysis/Analysis.cpp @@ -60,7 +60,7 @@ void llvm::initializeAnalysis(PassRegistry &Registry) { initializeMemoryDependenceAnalysisPass(Registry); initializeModuleDebugInfoPrinterPass(Registry); initializeObjCARCAAWrapperPassPass(Registry); - initializePostDominatorTreeWrapperPassPass(Registry); + initializePostDominatorTreePass(Registry); initializeRegionInfoPassPass(Registry); initializeRegionViewerPass(Registry); initializeRegionPrinterPass(Registry); diff --git a/lib/Analysis/DivergenceAnalysis.cpp b/lib/Analysis/DivergenceAnalysis.cpp index 0e1cfcfe259..343fe613b7e 100644 --- a/lib/Analysis/DivergenceAnalysis.cpp +++ b/lib/Analysis/DivergenceAnalysis.cpp @@ -258,7 +258,7 @@ char DivergenceAnalysis::ID = 0; INITIALIZE_PASS_BEGIN(DivergenceAnalysis, "divergence", "Divergence Analysis", false, true) INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass) -INITIALIZE_PASS_DEPENDENCY(PostDominatorTreeWrapperPass) +INITIALIZE_PASS_DEPENDENCY(PostDominatorTree) INITIALIZE_PASS_END(DivergenceAnalysis, "divergence", "Divergence Analysis", false, true) @@ -268,7 +268,7 @@ FunctionPass *llvm::createDivergenceAnalysisPass() { void DivergenceAnalysis::getAnalysisUsage(AnalysisUsage &AU) const { AU.addRequired(); - AU.addRequired(); + AU.addRequired(); AU.setPreservesAll(); } @@ -284,10 +284,9 @@ bool DivergenceAnalysis::runOnFunction(Function &F) { return false; DivergentValues.clear(); - auto &PDT = getAnalysis().getPostDomTree(); DivergencePropagator DP(F, TTI, getAnalysis().getDomTree(), - PDT, DivergentValues); + getAnalysis(), DivergentValues); DP.populateWithSourcesOfDivergence(); DP.propagate(); return false; diff --git a/lib/Analysis/DomPrinter.cpp b/lib/Analysis/DomPrinter.cpp index 7acfb41500d..0c880df54f8 100644 --- a/lib/Analysis/DomPrinter.cpp +++ b/lib/Analysis/DomPrinter.cpp @@ -111,36 +111,20 @@ struct DomOnlyViewer : public DOTGraphTraitsViewer< } }; -struct PostDominatorTreeWrapperPassAnalysisGraphTraits { - static PostDominatorTree *getGraph(PostDominatorTreeWrapperPass *PDTWP) { - return &PDTWP->getPostDomTree(); - } -}; - -struct PostDomViewer : public DOTGraphTraitsViewer< - PostDominatorTreeWrapperPass, false, - PostDominatorTree *, - PostDominatorTreeWrapperPassAnalysisGraphTraits> { +struct PostDomViewer + : public DOTGraphTraitsViewer { static char ID; PostDomViewer() : - DOTGraphTraitsViewer( - "postdom", ID){ + DOTGraphTraitsViewer("postdom", ID){ initializePostDomViewerPass(*PassRegistry::getPassRegistry()); } }; -struct PostDomOnlyViewer : public DOTGraphTraitsViewer< - PostDominatorTreeWrapperPass, true, - PostDominatorTree *, - PostDominatorTreeWrapperPassAnalysisGraphTraits> { +struct PostDomOnlyViewer + : public DOTGraphTraitsViewer { static char ID; PostDomOnlyViewer() : - DOTGraphTraitsViewer( - "postdomonly", ID){ + DOTGraphTraitsViewer("postdomonly", ID){ initializePostDomOnlyViewerPass(*PassRegistry::getPassRegistry()); } }; @@ -191,31 +175,19 @@ struct DomOnlyPrinter : public DOTGraphTraitsPrinter< }; struct PostDomPrinter - : public DOTGraphTraitsPrinter< - PostDominatorTreeWrapperPass, false, - PostDominatorTree *, - PostDominatorTreeWrapperPassAnalysisGraphTraits> { + : public DOTGraphTraitsPrinter { static char ID; PostDomPrinter() : - DOTGraphTraitsPrinter( - "postdom", ID) { + DOTGraphTraitsPrinter("postdom", ID) { initializePostDomPrinterPass(*PassRegistry::getPassRegistry()); } }; struct PostDomOnlyPrinter - : public DOTGraphTraitsPrinter< - PostDominatorTreeWrapperPass, true, - PostDominatorTree *, - PostDominatorTreeWrapperPassAnalysisGraphTraits> { + : public DOTGraphTraitsPrinter { static char ID; PostDomOnlyPrinter() : - DOTGraphTraitsPrinter( - "postdomonly", ID) { + DOTGraphTraitsPrinter("postdomonly", ID) { initializePostDomOnlyPrinterPass(*PassRegistry::getPassRegistry()); } }; diff --git a/lib/Analysis/PostDominators.cpp b/lib/Analysis/PostDominators.cpp index b515108fafb..6d929091e3d 100644 --- a/lib/Analysis/PostDominators.cpp +++ b/lib/Analysis/PostDominators.cpp @@ -16,7 +16,6 @@ #include "llvm/ADT/SetOperations.h" #include "llvm/IR/CFG.h" #include "llvm/IR/Instructions.h" -#include "llvm/IR/PassManager.h" #include "llvm/Support/Debug.h" #include "llvm/Support/GenericDomTreeConstruction.h" using namespace llvm; @@ -27,38 +26,25 @@ using namespace llvm; // PostDominatorTree Implementation //===----------------------------------------------------------------------===// -char PostDominatorTreeWrapperPass::ID = 0; -INITIALIZE_PASS(PostDominatorTreeWrapperPass, "postdomtree", +char PostDominatorTree::ID = 0; +INITIALIZE_PASS(PostDominatorTree, "postdomtree", "Post-Dominator Tree Construction", true, true) -bool PostDominatorTreeWrapperPass::runOnFunction(Function &F) { - DT.recalculate(F); +bool PostDominatorTree::runOnFunction(Function &F) { + DT->recalculate(F); return false; } -void PostDominatorTreeWrapperPass::print(raw_ostream &OS, const Module *) const { - DT.print(OS); +PostDominatorTree::~PostDominatorTree() { + delete DT; } +void PostDominatorTree::print(raw_ostream &OS, const Module *) const { + DT->print(OS); +} + + FunctionPass* llvm::createPostDomTree() { - return new PostDominatorTreeWrapperPass(); + return new PostDominatorTree(); } -char PostDominatorTreeAnalysis::PassID; - -PostDominatorTree PostDominatorTreeAnalysis::run(Function &F) { - PostDominatorTree PDT; - PDT.recalculate(F); - return PDT; -} - -PostDominatorTreePrinterPass::PostDominatorTreePrinterPass(raw_ostream &OS) - : OS(OS) {} - -PreservedAnalyses -PostDominatorTreePrinterPass::run(Function &F, FunctionAnalysisManager *AM) { - OS << "PostDominatorTree for function: " << F.getName() << "\n"; - AM->getResult(F).print(OS); - - return PreservedAnalyses::all(); -} diff --git a/lib/Analysis/RegionInfo.cpp b/lib/Analysis/RegionInfo.cpp index dac0cddc168..b6277bb6c12 100644 --- a/lib/Analysis/RegionInfo.cpp +++ b/lib/Analysis/RegionInfo.cpp @@ -128,7 +128,7 @@ bool RegionInfoPass::runOnFunction(Function &F) { releaseMemory(); auto DT = &getAnalysis().getDomTree(); - auto PDT = &getAnalysis().getPostDomTree(); + auto PDT = &getAnalysis(); auto DF = &getAnalysis(); RI.recalculate(F, DT, PDT, DF); @@ -146,8 +146,8 @@ void RegionInfoPass::verifyAnalysis() const { void RegionInfoPass::getAnalysisUsage(AnalysisUsage &AU) const { AU.setPreservesAll(); AU.addRequiredTransitive(); + AU.addRequired(); AU.addRequired(); - AU.addRequired(); } void RegionInfoPass::print(raw_ostream &OS, const Module *) const { @@ -165,8 +165,8 @@ char RegionInfoPass::ID = 0; INITIALIZE_PASS_BEGIN(RegionInfoPass, "regions", "Detect single entry single exit regions", true, true) INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass) +INITIALIZE_PASS_DEPENDENCY(PostDominatorTree) INITIALIZE_PASS_DEPENDENCY(DominanceFrontier) -INITIALIZE_PASS_DEPENDENCY(PostDominatorTreeWrapperPass) INITIALIZE_PASS_END(RegionInfoPass, "regions", "Detect single entry single exit regions", true, true) diff --git a/lib/CodeGen/MachineRegionInfo.cpp b/lib/CodeGen/MachineRegionInfo.cpp index 0f7ebb3da83..7d61792ff68 100644 --- a/lib/CodeGen/MachineRegionInfo.cpp +++ b/lib/CodeGen/MachineRegionInfo.cpp @@ -104,7 +104,7 @@ void MachineRegionInfoPass::verifyAnalysis() const { void MachineRegionInfoPass::getAnalysisUsage(AnalysisUsage &AU) const { AU.setPreservesAll(); AU.addRequiredTransitive(); - AU.addRequired(); + AU.addRequired(); AU.addRequired(); } diff --git a/lib/Passes/PassBuilder.cpp b/lib/Passes/PassBuilder.cpp index bd30fce7dc9..f043c92fd4f 100644 --- a/lib/Passes/PassBuilder.cpp +++ b/lib/Passes/PassBuilder.cpp @@ -24,7 +24,6 @@ #include "llvm/Analysis/CGSCCPassManager.h" #include "llvm/Analysis/LazyCallGraph.h" #include "llvm/Analysis/LoopInfo.h" -#include "llvm/Analysis/PostDominators.h" #include "llvm/Analysis/ScalarEvolution.h" #include "llvm/Analysis/ScalarEvolutionAliasAnalysis.h" #include "llvm/Analysis/ScopedNoAliasAA.h" diff --git a/lib/Passes/PassRegistry.def b/lib/Passes/PassRegistry.def index ccb40064cc8..1721fa1bc23 100644 --- a/lib/Passes/PassRegistry.def +++ b/lib/Passes/PassRegistry.def @@ -57,7 +57,6 @@ CGSCC_PASS("no-op-cgscc", NoOpCGSCCPass()) FUNCTION_ANALYSIS("aa", AAManager()) FUNCTION_ANALYSIS("assumptions", AssumptionAnalysis()) FUNCTION_ANALYSIS("domtree", DominatorTreeAnalysis()) -FUNCTION_ANALYSIS("postdomtree", PostDominatorTreeAnalysis()) FUNCTION_ANALYSIS("loops", LoopAnalysis()) FUNCTION_ANALYSIS("no-op-function", NoOpFunctionAnalysis()) FUNCTION_ANALYSIS("scalar-evolution", ScalarEvolutionAnalysis()) @@ -90,7 +89,6 @@ FUNCTION_PASS("lower-expect", LowerExpectIntrinsicPass()) FUNCTION_PASS("print", PrintFunctionPass(dbgs())) FUNCTION_PASS("print", AssumptionPrinterPass(dbgs())) FUNCTION_PASS("print", DominatorTreePrinterPass(dbgs())) -FUNCTION_PASS("print", PostDominatorTreePrinterPass(dbgs())) FUNCTION_PASS("print", LoopPrinterPass(dbgs())) FUNCTION_PASS("print", ScalarEvolutionPrinterPass(dbgs())) FUNCTION_PASS("simplify-cfg", SimplifyCFGPass()) diff --git a/test/Analysis/PostDominators/pr1098.ll b/test/Analysis/PostDominators/pr1098.ll index 1dae0c566f0..2eed2137127 100644 --- a/test/Analysis/PostDominators/pr1098.ll +++ b/test/Analysis/PostDominators/pr1098.ll @@ -1,5 +1,4 @@ ; RUN: opt < %s -postdomtree -analyze | FileCheck %s -; RUN: opt < %s -passes='print' 2>&1 | FileCheck %s ; PR932 define void @foo(i1 %x) { diff --git a/unittests/IR/DominatorTreeTest.cpp b/unittests/IR/DominatorTreeTest.cpp index fcd6b9c65b4..3aef4d64cbc 100644 --- a/unittests/IR/DominatorTreeTest.cpp +++ b/unittests/IR/DominatorTreeTest.cpp @@ -29,8 +29,7 @@ namespace llvm { bool runOnFunction(Function &F) override { DominatorTree *DT = &getAnalysis().getDomTree(); - PostDominatorTree *PDT = - &getAnalysis().getPostDomTree(); + PostDominatorTree *PDT = &getAnalysis(); Function::iterator FI = F.begin(); BasicBlock *BB0 = &*FI++; @@ -207,7 +206,7 @@ namespace llvm { } void getAnalysisUsage(AnalysisUsage &AU) const override { AU.addRequired(); - AU.addRequired(); + AU.addRequired(); } DPass() : FunctionPass(ID) { initializeDPassPass(*PassRegistry::getPassRegistry()); @@ -256,5 +255,5 @@ namespace llvm { INITIALIZE_PASS_BEGIN(DPass, "dpass", "dpass", false, false) INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass) -INITIALIZE_PASS_DEPENDENCY(PostDominatorTreeWrapperPass) +INITIALIZE_PASS_DEPENDENCY(PostDominatorTree) INITIALIZE_PASS_END(DPass, "dpass", "dpass", false, false)