Index: include/llvm/Analysis/PostDominators.h =================================================================== --- include/llvm/Analysis/PostDominators.h +++ include/llvm/Analysis/PostDominators.h @@ -17,76 +17,67 @@ #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 FunctionPass { - static char ID; // Pass identification, replacement for typeid - DominatorTreeBase* DT; +struct PostDominatorTree : public DominatorTreeBase { + PostDominatorTree() : DominatorTreeBase(true) {} +}; - PostDominatorTree() : FunctionPass(ID) { - initializePostDominatorTreePass(*PassRegistry::getPassRegistry()); - DT = new 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; - ~PostDominatorTree() override; + /// \brief Opaque, unique identifier for this analysis pass. + static void *ID() { return (void *)&PassID; } - bool runOnFunction(Function &F) override; + /// \brief Run the analysis pass over a function and produce a post dominator + /// tree. + PostDominatorTree run(Function &F); - void getAnalysisUsage(AnalysisUsage &AU) const override { - AU.setPreservesAll(); - } + /// \brief Provide access to a name for this pass for debugging purposes. + static StringRef name() { return "PostDominatorTreeAnalysis"; } - 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); - } +private: + static char PassID; +}; - inline DomTreeNode *getNode(BasicBlock *BB) const { - return DT->getNode(BB); - } +/// \brief Printer pass for the \c PostDominatorTree. +class PostDominatorTreePrinterPass { + raw_ostream &OS; - inline bool dominates(DomTreeNode* A, DomTreeNode* B) const { - return DT->dominates(A, B); - } +public: + explicit PostDominatorTreePrinterPass(raw_ostream &OS); + PreservedAnalyses run(Function &F, AnalysisManager *AM); - inline bool dominates(const BasicBlock* A, const BasicBlock* B) const { - return DT->dominates(A, B); - } + static StringRef name() { return "PostDominatorTreePrinterPass"; } +}; - inline bool properlyDominates(const DomTreeNode* A, DomTreeNode* B) const { - return DT->properlyDominates(A, B); - } +struct PostDominatorTreeWrapperPass : public FunctionPass { + static char ID; // Pass identification, replacement for typeid + PostDominatorTree DT; - inline bool properlyDominates(BasicBlock* A, BasicBlock* B) const { - return DT->properlyDominates(A, B); + PostDominatorTreeWrapperPass() : FunctionPass(ID) { + initializePostDominatorTreeWrapperPassPass(*PassRegistry::getPassRegistry()); } - inline BasicBlock *findNearestCommonDominator(BasicBlock *A, BasicBlock *B) { - return DT->findNearestCommonDominator(A, B); - } + PostDominatorTree &getPostDomTree() { return DT; } + const PostDominatorTree &getPostDomTree() const { return DT; } - inline const BasicBlock *findNearestCommonDominator(const BasicBlock *A, - const BasicBlock *B) { - return DT->findNearestCommonDominator(A, B); - } + bool runOnFunction(Function &F) override; - /// Get all nodes post-dominated by R, including R itself. - void getDescendants(BasicBlock *R, - SmallVectorImpl &Result) const { - DT->getDescendants(R, Result); + void getAnalysisUsage(AnalysisUsage &AU) const override { + AU.setPreservesAll(); } void releaseMemory() override { - DT->releaseMemory(); + DT.releaseMemory(); } void print(raw_ostream &OS, const Module*) const override; Index: include/llvm/InitializePasses.h =================================================================== --- include/llvm/InitializePasses.h +++ include/llvm/InitializePasses.h @@ -232,7 +232,7 @@ void initializePostDomOnlyViewerPass(PassRegistry&); void initializePostDomPrinterPass(PassRegistry&); void initializePostDomViewerPass(PassRegistry&); -void initializePostDominatorTreePass(PassRegistry&); +void initializePostDominatorTreeWrapperPassPass(PassRegistry&); void initializePostOrderFunctionAttrsLegacyPassPass(PassRegistry&); void initializePostRASchedulerPass(PassRegistry&); void initializePostMachineSchedulerPass(PassRegistry&); Index: lib/Analysis/Analysis.cpp =================================================================== --- lib/Analysis/Analysis.cpp +++ lib/Analysis/Analysis.cpp @@ -60,7 +60,7 @@ initializeMemoryDependenceAnalysisPass(Registry); initializeModuleDebugInfoPrinterPass(Registry); initializeObjCARCAAWrapperPassPass(Registry); - initializePostDominatorTreePass(Registry); + initializePostDominatorTreeWrapperPassPass(Registry); initializeRegionInfoPassPass(Registry); initializeRegionViewerPass(Registry); initializeRegionPrinterPass(Registry); Index: lib/Analysis/DivergenceAnalysis.cpp =================================================================== --- lib/Analysis/DivergenceAnalysis.cpp +++ lib/Analysis/DivergenceAnalysis.cpp @@ -258,7 +258,7 @@ INITIALIZE_PASS_BEGIN(DivergenceAnalysis, "divergence", "Divergence Analysis", false, true) INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass) -INITIALIZE_PASS_DEPENDENCY(PostDominatorTree) +INITIALIZE_PASS_DEPENDENCY(PostDominatorTreeWrapperPass) INITIALIZE_PASS_END(DivergenceAnalysis, "divergence", "Divergence Analysis", false, true) @@ -268,7 +268,7 @@ void DivergenceAnalysis::getAnalysisUsage(AnalysisUsage &AU) const { AU.addRequired(); - AU.addRequired(); + AU.addRequired(); AU.setPreservesAll(); } @@ -284,9 +284,10 @@ return false; DivergentValues.clear(); + auto &PDT = getAnalysis().getPostDomTree(); DivergencePropagator DP(F, TTI, getAnalysis().getDomTree(), - getAnalysis(), DivergentValues); + PDT, DivergentValues); DP.populateWithSourcesOfDivergence(); DP.propagate(); return false; Index: lib/Analysis/DomPrinter.cpp =================================================================== --- lib/Analysis/DomPrinter.cpp +++ lib/Analysis/DomPrinter.cpp @@ -111,20 +111,36 @@ } }; -struct PostDomViewer - : public DOTGraphTraitsViewer { +struct PostDominatorTreeWrapperPassAnalysisGraphTraits { + static PostDominatorTree *getGraph(PostDominatorTreeWrapperPass *PDTWP) { + return &PDTWP->getPostDomTree(); + } +}; + +struct PostDomViewer : public DOTGraphTraitsViewer< + PostDominatorTreeWrapperPass, false, + PostDominatorTree *, + PostDominatorTreeWrapperPassAnalysisGraphTraits> { static char ID; PostDomViewer() : - DOTGraphTraitsViewer("postdom", ID){ + DOTGraphTraitsViewer( + "postdom", ID){ initializePostDomViewerPass(*PassRegistry::getPassRegistry()); } }; -struct PostDomOnlyViewer - : public DOTGraphTraitsViewer { +struct PostDomOnlyViewer : public DOTGraphTraitsViewer< + PostDominatorTreeWrapperPass, true, + PostDominatorTree *, + PostDominatorTreeWrapperPassAnalysisGraphTraits> { static char ID; PostDomOnlyViewer() : - DOTGraphTraitsViewer("postdomonly", ID){ + DOTGraphTraitsViewer( + "postdomonly", ID){ initializePostDomOnlyViewerPass(*PassRegistry::getPassRegistry()); } }; @@ -175,19 +191,31 @@ }; struct PostDomPrinter - : public DOTGraphTraitsPrinter { + : public DOTGraphTraitsPrinter< + PostDominatorTreeWrapperPass, false, + PostDominatorTree *, + PostDominatorTreeWrapperPassAnalysisGraphTraits> { static char ID; PostDomPrinter() : - DOTGraphTraitsPrinter("postdom", ID) { + DOTGraphTraitsPrinter( + "postdom", ID) { initializePostDomPrinterPass(*PassRegistry::getPassRegistry()); } }; struct PostDomOnlyPrinter - : public DOTGraphTraitsPrinter { + : public DOTGraphTraitsPrinter< + PostDominatorTreeWrapperPass, true, + PostDominatorTree *, + PostDominatorTreeWrapperPassAnalysisGraphTraits> { static char ID; PostDomOnlyPrinter() : - DOTGraphTraitsPrinter("postdomonly", ID) { + DOTGraphTraitsPrinter( + "postdomonly", ID) { initializePostDomOnlyPrinterPass(*PassRegistry::getPassRegistry()); } }; Index: lib/Analysis/PostDominators.cpp =================================================================== --- lib/Analysis/PostDominators.cpp +++ lib/Analysis/PostDominators.cpp @@ -16,6 +16,7 @@ #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; @@ -26,25 +27,38 @@ // PostDominatorTree Implementation //===----------------------------------------------------------------------===// -char PostDominatorTree::ID = 0; -INITIALIZE_PASS(PostDominatorTree, "postdomtree", +char PostDominatorTreeWrapperPass::ID = 0; +INITIALIZE_PASS(PostDominatorTreeWrapperPass, "postdomtree", "Post-Dominator Tree Construction", true, true) -bool PostDominatorTree::runOnFunction(Function &F) { - DT->recalculate(F); +bool PostDominatorTreeWrapperPass::runOnFunction(Function &F) { + DT.recalculate(F); return false; } -PostDominatorTree::~PostDominatorTree() { - delete DT; +void PostDominatorTreeWrapperPass::print(raw_ostream &OS, const Module *) const { + DT.print(OS); } -void PostDominatorTree::print(raw_ostream &OS, const Module *) const { - DT->print(OS); +FunctionPass* llvm::createPostDomTree() { + return new PostDominatorTreeWrapperPass(); } +char PostDominatorTreeAnalysis::PassID; -FunctionPass* llvm::createPostDomTree() { - return new PostDominatorTree(); +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(); +} Index: lib/Analysis/RegionInfo.cpp =================================================================== --- lib/Analysis/RegionInfo.cpp +++ lib/Analysis/RegionInfo.cpp @@ -128,7 +128,7 @@ releaseMemory(); auto DT = &getAnalysis().getDomTree(); - auto PDT = &getAnalysis(); + auto PDT = &getAnalysis().getPostDomTree(); auto DF = &getAnalysis(); RI.recalculate(F, DT, PDT, DF); @@ -146,8 +146,8 @@ 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 @@ 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) Index: lib/CodeGen/MachineRegionInfo.cpp =================================================================== --- lib/CodeGen/MachineRegionInfo.cpp +++ lib/CodeGen/MachineRegionInfo.cpp @@ -104,7 +104,7 @@ void MachineRegionInfoPass::getAnalysisUsage(AnalysisUsage &AU) const { AU.setPreservesAll(); AU.addRequiredTransitive(); - AU.addRequired(); + AU.addRequired(); AU.addRequired(); } Index: lib/Passes/PassBuilder.cpp =================================================================== --- lib/Passes/PassBuilder.cpp +++ lib/Passes/PassBuilder.cpp @@ -24,6 +24,7 @@ #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" Index: lib/Passes/PassRegistry.def =================================================================== --- lib/Passes/PassRegistry.def +++ lib/Passes/PassRegistry.def @@ -57,6 +57,7 @@ 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()) @@ -89,6 +90,7 @@ 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()) Index: test/Analysis/PostDominators/pr1098.ll =================================================================== --- test/Analysis/PostDominators/pr1098.ll +++ test/Analysis/PostDominators/pr1098.ll @@ -1,4 +1,5 @@ ; RUN: opt < %s -postdomtree -analyze | FileCheck %s +; RUN: opt < %s -passes='print' 2>&1 | FileCheck %s ; PR932 define void @foo(i1 %x) { Index: unittests/IR/DominatorTreeTest.cpp =================================================================== --- unittests/IR/DominatorTreeTest.cpp +++ unittests/IR/DominatorTreeTest.cpp @@ -29,7 +29,8 @@ bool runOnFunction(Function &F) override { DominatorTree *DT = &getAnalysis().getDomTree(); - PostDominatorTree *PDT = &getAnalysis(); + PostDominatorTree *PDT = + &getAnalysis().getPostDomTree(); Function::iterator FI = F.begin(); BasicBlock *BB0 = &*FI++; @@ -206,7 +207,7 @@ } void getAnalysisUsage(AnalysisUsage &AU) const override { AU.addRequired(); - AU.addRequired(); + AU.addRequired(); } DPass() : FunctionPass(ID) { initializeDPassPass(*PassRegistry::getPassRegistry()); @@ -255,5 +256,5 @@ INITIALIZE_PASS_BEGIN(DPass, "dpass", "dpass", false, false) INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass) -INITIALIZE_PASS_DEPENDENCY(PostDominatorTree) +INITIALIZE_PASS_DEPENDENCY(PostDominatorTreeWrapperPass) INITIALIZE_PASS_END(DPass, "dpass", "dpass", false, false)