Introduce DominanceFrontierAnalysis to the new PassManager to compute DominanceFrontier. NFC

Differential Revision: http://reviews.llvm.org/D17570

llvm-svn: 261903

2 files changed, 43 insertions, 47 deletions

diff --git a/llvm/include/llvm/Analysis/DominanceFrontier.h b/llvm/include/llvm/Analysis/DominanceFrontier.h
index fb730054a8e..b4b8a6baf0a 100644
--- a/llvm/include/llvm/Analysis/DominanceFrontier.h
+++ b/llvm/include/llvm/Analysis/DominanceFrontier.h
@@ -24,6 +24,11 @@
 
 namespace llvm {
 
+// FIXME: Replace this brittle forward declaration with the include of the new
+// PassManager.h when doing so doesn't break the PassManagerBuilder.
+template <typename IRUnitT> class AnalysisManager;
+class PreservedAnalyses;
+
 //===----------------------------------------------------------------------===//
 /// DominanceFrontierBase - Common base class for computing forward and inverse
 /// dominance frontiers for a function.
@@ -133,78 +138,69 @@ public:
   const DomSetType &calculate(const DomTreeT &DT, const DomTreeNodeT *Node);
 };
 
-class DominanceFrontier : public FunctionPass {
-  ForwardDominanceFrontierBase<BasicBlock> Base;
-
+class DominanceFrontier : public ForwardDominanceFrontierBase<BasicBlock> {
 public:
   typedef DominatorTreeBase<BasicBlock> DomTreeT;
   typedef DomTreeNodeBase<BasicBlock> DomTreeNodeT;
   typedef DominanceFrontierBase<BasicBlock>::DomSetType DomSetType;
   typedef DominanceFrontierBase<BasicBlock>::iterator iterator;
   typedef DominanceFrontierBase<BasicBlock>::const_iterator const_iterator;
+};
 
+class DominanceFrontierWrapperPass : public FunctionPass {
+  DominanceFrontier DF;
+public:
   static char ID; // Pass ID, replacement for typeid
 
-  DominanceFrontier();
-
-  ForwardDominanceFrontierBase<BasicBlock> &getBase() { return Base; }
-
-  inline const std::vector<BasicBlock *> &getRoots() const {
-    return Base.getRoots();
-  }
-
-  BasicBlock *getRoot() const { return Base.getRoot(); }
-
-  bool isPostDominator() const { return Base.isPostDominator(); }
+  DominanceFrontierWrapperPass();
 
-  iterator begin() { return Base.begin(); }
+  DominanceFrontier &getDominanceFrontier() { return DF; }
+  const DominanceFrontier &getDominanceFrontier() const { return DF;  }
 
-  const_iterator begin() const { return Base.begin(); }
-
-  iterator end() { return Base.end(); }
-
-  const_iterator end() const { return Base.end(); }
+  void releaseMemory() override;
 
-  iterator find(BasicBlock *B) { return Base.find(B); }
+  bool runOnFunction(Function &) override;
 
-  const_iterator find(BasicBlock *B) const { return Base.find(B); }
+  void getAnalysisUsage(AnalysisUsage &AU) const override;
 
-  iterator addBasicBlock(BasicBlock *BB, const DomSetType &frontier) {
-    return Base.addBasicBlock(BB, frontier);
-  }
+  void print(raw_ostream &OS, const Module * = nullptr) const override;
 
-  void removeBlock(BasicBlock *BB) { return Base.removeBlock(BB); }
+  void dump() const;
+};
 
-  void addToFrontier(iterator I, BasicBlock *Node) {
-    return Base.addToFrontier(I, Node);
-  }
+extern template class DominanceFrontierBase<BasicBlock>;
+extern template class ForwardDominanceFrontierBase<BasicBlock>;
 
-  void removeFromFrontier(iterator I, BasicBlock *Node) {
-    return Base.removeFromFrontier(I, Node);
-  }
+/// \brief Analysis pass which computes a \c DominanceFrontier.
+class DominanceFrontierAnalysis {
+public:
+  /// \brief Provide the result typedef for this analysis pass.
+  typedef DominanceFrontier Result;
 
-  bool compareDomSet(DomSetType &DS1, const DomSetType &DS2) const {
-    return Base.compareDomSet(DS1, DS2);
-  }
+  /// \brief Opaque, unique identifier for this analysis pass.
+  static void *ID() { return (void *)&PassID; }
 
-  bool compare(DominanceFrontierBase<BasicBlock> &Other) const {
-    return Base.compare(Other);
-  }
+  /// \brief Run the analysis pass over a function and produce a dominator tree.
+  DominanceFrontier run(Function &F, AnalysisManager<Function> *AM);
 
-  void releaseMemory() override;
+  /// \brief Provide access to a name for this pass for debugging purposes.
+  static StringRef name() { return "DominanceFrontierAnalysis"; }
 
-  bool runOnFunction(Function &) override;
+private:
+  static char PassID;
+};
 
-  void getAnalysisUsage(AnalysisUsage &AU) const override;
+/// \brief Printer pass for the \c DominanceFrontier.
+class DominanceFrontierPrinterPass {
+  raw_ostream &OS;
 
-  void print(raw_ostream &OS, const Module * = nullptr) const override;
+public:
+  explicit DominanceFrontierPrinterPass(raw_ostream &OS);
+  PreservedAnalyses run(Function &F, AnalysisManager<Function> *AM);
 
-  void dump() const;
+  static StringRef name() { return "DominanceFrontierAnalysis"; }
 };
 
-extern template class DominanceFrontierBase<BasicBlock>;
-extern template class ForwardDominanceFrontierBase<BasicBlock>;
-
 } // End llvm namespace
 
 #endif
diff --git a/llvm/include/llvm/InitializePasses.h b/llvm/include/llvm/InitializePasses.h
index 5f2b886a18a..c5fae37000d 100644
--- a/llvm/include/llvm/InitializePasses.h
+++ b/llvm/include/llvm/InitializePasses.h
@@ -111,7 +111,7 @@ void initializeDomOnlyPrinterPass(PassRegistry&);
 void initializeDomOnlyViewerPass(PassRegistry&);
 void initializeDomPrinterPass(PassRegistry&);
 void initializeDomViewerPass(PassRegistry&);
-void initializeDominanceFrontierPass(PassRegistry&);
+void initializeDominanceFrontierWrapperPassPass(PassRegistry&);
 void initializeDominatorTreeWrapperPassPass(PassRegistry&);
 void initializeEarlyIfConverterPass(PassRegistry&);
 void initializeEdgeBundlesPass(PassRegistry&);