1 files changed, 41 insertions, 48 deletions

diff --git a/include/llvm/Analysis/PostDominators.h b/include/llvm/Analysis/PostDominators.h
index 0f7e2b88d2d70..99240a40408e3 100644
--- a/include/llvm/Analysis/PostDominators.h
+++ b/include/llvm/Analysis/PostDominators.h
@@ -15,78 +15,71 @@
 #define LLVM_ANALYSIS_POSTDOMINATORS_H
 
 #include "llvm/IR/Dominators.h"
+#include "llvm/IR/PassManager.h"
 
 namespace llvm {
 
 /// 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<BasicBlock>* DT;
-
-  PostDominatorTree() : FunctionPass(ID) {
-    initializePostDominatorTreePass(*PassRegistry::getPassRegistry());
-    DT = new DominatorTreeBase<BasicBlock>(true);
-  }
+struct PostDominatorTree : public DominatorTreeBase<BasicBlock> {
+  typedef DominatorTreeBase<BasicBlock> Base;
 
-  ~PostDominatorTree() override;
+  PostDominatorTree() : DominatorTreeBase<BasicBlock>(true) {}
 
-  bool runOnFunction(Function &F) override;
-
-  void getAnalysisUsage(AnalysisUsage &AU) const override {
-    AU.setPreservesAll();
-  }
+  PostDominatorTree(PostDominatorTree &&Arg)
+    : Base(std::move(static_cast<Base &>(Arg))) {}
 
-  inline const std::vector<BasicBlock*> &getRoots() const {
-    return DT->getRoots();
+  PostDominatorTree &operator=(PostDominatorTree &&RHS) {
+    Base::operator=(std::move(static_cast<Base &>(RHS)));
+    return *this;
   }
+};
 
-  inline DomTreeNode *getRootNode() const {
-    return DT->getRootNode();
-  }
+/// \brief Analysis pass which computes a \c PostDominatorTree.
+class PostDominatorTreeAnalysis
+    : public AnalysisInfoMixin<PostDominatorTreeAnalysis> {
+  friend AnalysisInfoMixin<PostDominatorTreeAnalysis>;
+  static char PassID;
 
-  inline DomTreeNode *operator[](BasicBlock *BB) const {
-    return DT->getNode(BB);
-  }
+public:
+  /// \brief Provide the result typedef for this analysis pass.
+  typedef PostDominatorTree Result;
 
-  inline DomTreeNode *getNode(BasicBlock *BB) const {
-    return DT->getNode(BB);
-  }
+  /// \brief Run the analysis pass over a function and produce a post dominator
+  ///        tree.
+  PostDominatorTree run(Function &F, FunctionAnalysisManager &);
+};
 
-  inline bool dominates(DomTreeNode* A, DomTreeNode* B) const {
-    return DT->dominates(A, B);
-  }
+/// \brief Printer pass for the \c PostDominatorTree.
+class PostDominatorTreePrinterPass
+    : public PassInfoMixin<PostDominatorTreePrinterPass> {
+  raw_ostream &OS;
 
-  inline bool dominates(const BasicBlock* A, const BasicBlock* B) const {
-    return DT->dominates(A, B);
-  }
+public:
+  explicit PostDominatorTreePrinterPass(raw_ostream &OS);
+  PreservedAnalyses run(Function &F, AnalysisManager<Function> &AM);
+};
 
-  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<BasicBlock *> &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;