Index: include/llvm/Analysis/PostDominators.h
===================================================================
--- include/llvm/Analysis/PostDominators.h
+++ include/llvm/Analysis/PostDominators.h
@@ -18,98 +18,85 @@
 
 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);
-  }
-
-  ~PostDominatorTree() override;
+/// PostDominatorTree Class - Concrete subclass of DominatorTreeBase that is
+/// used to compute the post-dominator tree.
+struct PostDominatorTree : public DominatorTreeBase<BasicBlock> {
+public:
+  typedef DominatorTreeBase<BasicBlock> Base;
 
-  bool runOnFunction(Function &F) override;
+  PostDominatorTree() : DominatorTreeBase<BasicBlock>(true) {}
 
-  void getAnalysisUsage(AnalysisUsage &AU) const override {
-    AU.setPreservesAll();
+  PostDominatorTree(PostDominatorTree &&Arg)
+      : Base(std::move(static_cast<Base &>(Arg))) {}
+  PostDominatorTree &operator=(PostDominatorTree &&RHS) {
+    Base::operator=(std::move(static_cast<Base &>(RHS)));
+    return *this;
   }
+};
 
-  inline const std::vector<BasicBlock*> &getRoots() const {
-    return DT->getRoots();
-  }
+FunctionPass *createPostDomTree();
 
-  inline DomTreeNode *getRootNode() const {
+template <>
+struct GraphTraits<PostDominatorTree *> : public GraphTraits<DomTreeNode *> {
+  static NodeType *getEntryNode(PostDominatorTree *DT) {
     return DT->getRootNode();
   }
 
-  inline DomTreeNode *operator[](BasicBlock *BB) const {
-    return DT->getNode(BB);
+  static nodes_iterator nodes_begin(PostDominatorTree *N) {
+    if (getEntryNode(N))
+      return df_begin(getEntryNode(N));
+    else
+      return df_end(getEntryNode(N));
   }
 
-  inline DomTreeNode *getNode(BasicBlock *BB) const {
-    return DT->getNode(BB);
+  static nodes_iterator nodes_end(PostDominatorTree *N) {
+    return df_end(getEntryNode(N));
   }
+};
 
-  inline bool dominates(DomTreeNode* A, DomTreeNode* B) const {
-    return DT->dominates(A, B);
-  }
+/// \brief Analysis pass which computes a \c PostDominatorTree.
+class PostDominatorTreeAnalysis {
+public:
+  /// \brief Provide the result typedef for this analysis pass.
+  typedef PostDominatorTree Result;
 
-  inline bool dominates(const BasicBlock* A, const BasicBlock* B) const {
-    return DT->dominates(A, B);
-  }
+  /// \brief Opaque, unique identifier for this analysis pass.
+  static void *ID() { return (void *)&PassID; }
 
-  inline bool properlyDominates(const DomTreeNode* A, DomTreeNode* B) const {
-    return DT->properlyDominates(A, B);
-  }
+  /// \brief Run the analysis pass over a function and produce a post-dominator
+  /// tree.
+  PostDominatorTree run(Function &F);
 
-  inline bool properlyDominates(BasicBlock* A, BasicBlock* B) const {
-    return DT->properlyDominates(A, B);
-  }
+  /// \brief Provide access to a name for this pass for debugging purposes.
+  static StringRef name() { return "PostDominatorTreeAnalysis"; }
 
-  inline BasicBlock *findNearestCommonDominator(BasicBlock *A, BasicBlock *B) {
-    return DT->findNearestCommonDominator(A, B);
-  }
+private:
+  static char PassID;
+};
 
-  inline const BasicBlock *findNearestCommonDominator(const BasicBlock *A,
-                                                      const BasicBlock *B) {
-    return DT->findNearestCommonDominator(A, B);
-  }
+/// \brief Legacy analysis pass which computes a \c PostDominatorTree.
+class PostDominatorTreePass : public FunctionPass {
+  PostDominatorTree PDT;
 
-  /// Get all nodes post-dominated by R, including R itself.
-  void getDescendants(BasicBlock *R,
-                      SmallVectorImpl<BasicBlock *> &Result) const {
-    DT->getDescendants(R, Result);
-  }
+public:
+  static char ID;
 
-  void releaseMemory() override {
-    DT->releaseMemory();
+  PostDominatorTreePass() : FunctionPass(ID) {
+    initializePostDominatorTreePassPass(*PassRegistry::getPassRegistry());
   }
 
-  void print(raw_ostream &OS, const Module*) const override;
-};
+  PostDominatorTree &getDomTree() { return PDT; }
+  const PostDominatorTree &getDomTree() const { return PDT; }
 
-FunctionPass* createPostDomTree();
+  bool runOnFunction(Function &F) override;
 
-template <> struct GraphTraits<PostDominatorTree*>
-  : public GraphTraits<DomTreeNode*> {
-  static NodeType *getEntryNode(PostDominatorTree *DT) {
-    return DT->getRootNode();
+  void getAnalysisUsage(AnalysisUsage &AU) const override {
+    AU.setPreservesAll();
   }
 
-  static nodes_iterator nodes_begin(PostDominatorTree *N) {
-    if (getEntryNode(N))
-      return df_begin(getEntryNode(N));
-    else
-      return df_end(getEntryNode(N));
-  }
+  void releaseMemory() override { PDT.releaseMemory(); }
 
-  static nodes_iterator nodes_end(PostDominatorTree *N) {
-    return df_end(getEntryNode(N));
-  }
+  void print(raw_ostream &OS, const Module *) const override;
 };
 
 } // End llvm namespace
Index: include/llvm/InitializePasses.h
===================================================================
--- include/llvm/InitializePasses.h
+++ include/llvm/InitializePasses.h
@@ -224,7 +224,7 @@
 void initializePostDomOnlyViewerPass(PassRegistry&);
 void initializePostDomPrinterPass(PassRegistry&);
 void initializePostDomViewerPass(PassRegistry&);
-void initializePostDominatorTreePass(PassRegistry&);
+void initializePostDominatorTreePassPass(PassRegistry &);
 void initializePostRASchedulerPass(PassRegistry&);
 void initializePostMachineSchedulerPass(PassRegistry&);
 void initializePrintFunctionPassWrapperPass(PassRegistry&);
Index: lib/Analysis/Analysis.cpp
===================================================================
--- lib/Analysis/Analysis.cpp
+++ lib/Analysis/Analysis.cpp
@@ -58,7 +58,7 @@
   initializeMemDerefPrinterPass(Registry);
   initializeMemoryDependenceAnalysisPass(Registry);
   initializeModuleDebugInfoPrinterPass(Registry);
-  initializePostDominatorTreePass(Registry);
+  initializePostDominatorTreePassPass(Registry);
   initializeRegionInfoPassPass(Registry);
   initializeRegionViewerPass(Registry);
   initializeRegionPrinterPass(Registry);
Index: lib/Analysis/DivergenceAnalysis.cpp
===================================================================
--- lib/Analysis/DivergenceAnalysis.cpp
+++ lib/Analysis/DivergenceAnalysis.cpp
@@ -94,7 +94,7 @@
 
   void getAnalysisUsage(AnalysisUsage &AU) const override {
     AU.addRequired<DominatorTreeWrapperPass>();
-    AU.addRequired<PostDominatorTree>();
+    AU.addRequired<PostDominatorTreePass>();
     AU.setPreservesAll();
   }
 
@@ -119,7 +119,7 @@
 INITIALIZE_PASS_BEGIN(DivergenceAnalysis, "divergence", "Divergence Analysis",
                       false, true)
 INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
-INITIALIZE_PASS_DEPENDENCY(PostDominatorTree)
+INITIALIZE_PASS_DEPENDENCY(PostDominatorTreePass)
 INITIALIZE_PASS_END(DivergenceAnalysis, "divergence", "Divergence Analysis",
                     false, true)
 
@@ -302,9 +302,9 @@
     return false;
 
   DivergentValues.clear();
-  DivergencePropagator DP(F, TTI,
-                          getAnalysis<DominatorTreeWrapperPass>().getDomTree(),
-                          getAnalysis<PostDominatorTree>(), DivergentValues);
+  DivergencePropagator DP(
+      F, TTI, getAnalysis<DominatorTreeWrapperPass>().getDomTree(),
+      getAnalysis<PostDominatorTreePass>().getDomTree(), DivergentValues);
   DP.populateWithSourcesOfDivergence();
   DP.propagate();
   return false;
Index: lib/Analysis/DomPrinter.cpp
===================================================================
--- lib/Analysis/DomPrinter.cpp
+++ lib/Analysis/DomPrinter.cpp
@@ -87,6 +87,12 @@
   }
 };
 
+struct PostDominatorTreePassAnalysisGraphTraits {
+  static PostDominatorTree *getGraph(PostDominatorTreePass *PDTP) {
+    return &PDTP->getDomTree();
+  }
+};
+
 struct DomViewer : public DOTGraphTraitsViewer<
                        DominatorTreeWrapperPass, false, DominatorTree *,
                        DominatorTreeWrapperPassAnalysisGraphTraits> {
@@ -111,22 +117,28 @@
   }
 };
 
-struct PostDomViewer
-  : public DOTGraphTraitsViewer<PostDominatorTree, false> {
+struct PostDomViewer : public DOTGraphTraitsViewer<
+                           PostDominatorTreePass, false, PostDominatorTree *,
+                           PostDominatorTreePassAnalysisGraphTraits> {
   static char ID;
-  PostDomViewer() :
-    DOTGraphTraitsViewer<PostDominatorTree, false>("postdom", ID){
+  PostDomViewer()
+      : DOTGraphTraitsViewer<PostDominatorTreePass, false, PostDominatorTree *,
+                             PostDominatorTreePassAnalysisGraphTraits>(
+            "postdom", ID) {
       initializePostDomViewerPass(*PassRegistry::getPassRegistry());
     }
 };
 
-struct PostDomOnlyViewer
-  : public DOTGraphTraitsViewer<PostDominatorTree, true> {
+struct PostDomOnlyViewer : public DOTGraphTraitsViewer<
+                               PostDominatorTreePass, true, PostDominatorTree *,
+                               PostDominatorTreePassAnalysisGraphTraits> {
   static char ID;
-  PostDomOnlyViewer() :
-    DOTGraphTraitsViewer<PostDominatorTree, true>("postdomonly", ID){
-      initializePostDomOnlyViewerPass(*PassRegistry::getPassRegistry());
-    }
+  PostDomOnlyViewer()
+      : DOTGraphTraitsViewer<PostDominatorTreePass, true, PostDominatorTree *,
+                             PostDominatorTreePassAnalysisGraphTraits>(
+            "postdomonly", ID) {
+    initializePostDomOnlyViewerPass(*PassRegistry::getPassRegistry());
+  }
 };
 } // end anonymous namespace
 
@@ -174,20 +186,27 @@
   }
 };
 
-struct PostDomPrinter
-  : public DOTGraphTraitsPrinter<PostDominatorTree, false> {
+struct PostDomPrinter : public DOTGraphTraitsPrinter<
+                            PostDominatorTreePass, false, PostDominatorTree *,
+                            PostDominatorTreePassAnalysisGraphTraits> {
   static char ID;
-  PostDomPrinter() :
-    DOTGraphTraitsPrinter<PostDominatorTree, false>("postdom", ID) {
+  PostDomPrinter()
+      : DOTGraphTraitsPrinter<PostDominatorTreePass, false, PostDominatorTree *,
+                              PostDominatorTreePassAnalysisGraphTraits>(
+            "postdom", ID) {
       initializePostDomPrinterPass(*PassRegistry::getPassRegistry());
     }
 };
 
 struct PostDomOnlyPrinter
-  : public DOTGraphTraitsPrinter<PostDominatorTree, true> {
+    : public DOTGraphTraitsPrinter<PostDominatorTreePass, true,
+                                   PostDominatorTree *,
+                                   PostDominatorTreePassAnalysisGraphTraits> {
   static char ID;
-  PostDomOnlyPrinter() :
-    DOTGraphTraitsPrinter<PostDominatorTree, true>("postdomonly", ID) {
+  PostDomOnlyPrinter()
+      : DOTGraphTraitsPrinter<PostDominatorTreePass, true, PostDominatorTree *,
+                              PostDominatorTreePassAnalysisGraphTraits>(
+            "postdomonly", ID) {
       initializePostDomOnlyPrinterPass(*PassRegistry::getPassRegistry());
     }
 };
Index: lib/Analysis/PostDominators.cpp
===================================================================
--- lib/Analysis/PostDominators.cpp
+++ lib/Analysis/PostDominators.cpp
@@ -26,25 +26,29 @@
 //  PostDominatorTree Implementation
 //===----------------------------------------------------------------------===//
 
-char PostDominatorTree::ID = 0;
-INITIALIZE_PASS(PostDominatorTree, "postdomtree",
+char PostDominatorTreePass::ID = 0;
+INITIALIZE_PASS(PostDominatorTreePass, "postdomtree",
                 "Post-Dominator Tree Construction", true, true)
 
-bool PostDominatorTree::runOnFunction(Function &F) {
-  DT->recalculate(F);
+bool PostDominatorTreePass::runOnFunction(Function &F) {
+  PDT.recalculate(F);
   return false;
 }
 
-PostDominatorTree::~PostDominatorTree() {
-  delete DT;
+void PostDominatorTreePass::print(raw_ostream &OS, const Module *) const {
+  PDT.print(OS);
 }
 
-void PostDominatorTree::print(raw_ostream &OS, const Module *) const {
-  DT->print(OS);
-}
+FunctionPass *llvm::createPostDomTree() { return new PostDominatorTreePass(); }
 
+//===----------------------------------------------------------------------===//
+//  PostDominatorTreeAnalysis Implementation
+//===----------------------------------------------------------------------===//
 
-FunctionPass* llvm::createPostDomTree() {
-  return new PostDominatorTree();
+PostDominatorTree PostDominatorTreeAnalysis::run(Function &F) {
+  PostDominatorTree PDT;
+  PDT.recalculate(F);
+  return PDT;
 }
 
+char PostDominatorTreeAnalysis::PassID;
Index: lib/Analysis/RegionInfo.cpp
===================================================================
--- lib/Analysis/RegionInfo.cpp
+++ lib/Analysis/RegionInfo.cpp
@@ -119,7 +119,7 @@
   releaseMemory();
 
   auto DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
-  auto PDT = &getAnalysis<PostDominatorTree>();
+  auto PDT = &getAnalysis<PostDominatorTreePass>().getDomTree();
   auto DF = &getAnalysis<DominanceFrontier>();
 
   RI.recalculate(F, DT, PDT, DF);
@@ -137,7 +137,7 @@
 void RegionInfoPass::getAnalysisUsage(AnalysisUsage &AU) const {
   AU.setPreservesAll();
   AU.addRequiredTransitive<DominatorTreeWrapperPass>();
-  AU.addRequired<PostDominatorTree>();
+  AU.addRequired<PostDominatorTreePass>();
   AU.addRequired<DominanceFrontier>();
 }
 
@@ -156,7 +156,7 @@
 INITIALIZE_PASS_BEGIN(RegionInfoPass, "regions",
                 "Detect single entry single exit regions", true, true)
 INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
-INITIALIZE_PASS_DEPENDENCY(PostDominatorTree)
+INITIALIZE_PASS_DEPENDENCY(PostDominatorTreePass)
 INITIALIZE_PASS_DEPENDENCY(DominanceFrontier)
 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<DominatorTreeWrapperPass>();
-  AU.addRequired<PostDominatorTree>();
+  AU.addRequired<PostDominatorTreePass>();
   AU.addRequired<DominanceFrontier>();
 }
 
Index: lib/Passes/PassBuilder.cpp
===================================================================
--- lib/Passes/PassBuilder.cpp
+++ lib/Passes/PassBuilder.cpp
@@ -20,6 +20,7 @@
 #include "llvm/Analysis/CGSCCPassManager.h"
 #include "llvm/Analysis/LazyCallGraph.h"
 #include "llvm/Analysis/LoopInfo.h"
+#include "llvm/Analysis/PostDominators.h"
 #include "llvm/Analysis/TargetLibraryInfo.h"
 #include "llvm/Analysis/TargetTransformInfo.h"
 #include "llvm/IR/Dominators.h"
Index: lib/Passes/PassRegistry.def
===================================================================
--- lib/Passes/PassRegistry.def
+++ lib/Passes/PassRegistry.def
@@ -52,6 +52,7 @@
 #endif
 FUNCTION_ANALYSIS("assumptions", AssumptionAnalysis())
 FUNCTION_ANALYSIS("domtree", DominatorTreeAnalysis())
+FUNCTION_ANALYSIS("postdomtree", PostDominatorTreeAnalysis())
 FUNCTION_ANALYSIS("loops", LoopAnalysis())
 FUNCTION_ANALYSIS("no-op-function", NoOpFunctionAnalysis())
 FUNCTION_ANALYSIS("targetlibinfo", TargetLibraryAnalysis())
Index: lib/Transforms/Scalar/SampleProfile.cpp
===================================================================
--- lib/Transforms/Scalar/SampleProfile.cpp
+++ lib/Transforms/Scalar/SampleProfile.cpp
@@ -97,7 +97,7 @@
     AU.setPreservesCFG();
     AU.addRequired<LoopInfoWrapperPass>();
     AU.addRequired<DominatorTreeWrapperPass>();
-    AU.addRequired<PostDominatorTree>();
+    AU.addRequired<PostDominatorTreePass>();
   }
 
 protected:
@@ -364,7 +364,7 @@
     // class by making BB2's equivalence class be BB1.
     DominatedBBs.clear();
     DT->getDescendants(BB1, DominatedBBs);
-    findEquivalencesFor(BB1, DominatedBBs, PDT->DT);
+    findEquivalencesFor(BB1, DominatedBBs, PDT);
 
     // Repeat the same logic for all the blocks post-dominated by BB1.
     // We are looking for every basic block BB2 such that:
@@ -732,7 +732,7 @@
 INITIALIZE_PASS_BEGIN(SampleProfileLoader, "sample-profile",
                       "Sample Profile loader", false, false)
 INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
-INITIALIZE_PASS_DEPENDENCY(PostDominatorTree)
+INITIALIZE_PASS_DEPENDENCY(PostDominatorTreePass)
 INITIALIZE_PASS_DEPENDENCY(LoopInfoWrapperPass)
 INITIALIZE_PASS_DEPENDENCY(AddDiscriminators)
 INITIALIZE_PASS_END(SampleProfileLoader, "sample-profile",
@@ -763,7 +763,7 @@
     return false;
 
   DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
-  PDT = &getAnalysis<PostDominatorTree>();
+  PDT = &getAnalysis<PostDominatorTreePass>().getDomTree();
   LI = &getAnalysis<LoopInfoWrapperPass>().getLoopInfo();
   Ctx = &F.getParent()->getContext();
   Samples = Reader->getSamplesFor(F);