Revert "Introduce DominanceFrontierAnalysis to the new PassManager to compute DominanceFrontier. NFC"

This reverts commit 109c38b2226a87b0be73fa7a0a8c1a81df20aeb2.

llvm-svn: 261890

llvm/include/llvm/Analysis/DominanceFrontier.h

@@ -24,11 +24,6 @@
 
 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.
@@ -138,24 +133,63 @@ public:
   const DomSetType &calculate(const DomTreeT &DT, const DomTreeNodeT *Node);
 };
 
-class DominanceFrontier : public ForwardDominanceFrontierBase<BasicBlock> {
+class DominanceFrontier : public FunctionPass {
+  ForwardDominanceFrontierBase<BasicBlock> Base;
+
 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
 
-  DominanceFrontierWrapperPass();
+  DominanceFrontier();
 
-  DominanceFrontier &getDominanceFrontier() { return DF; }
+  ForwardDominanceFrontierBase<BasicBlock> &getBase() { return Base; }
-  const DominanceFrontier &getDominanceFrontier() const { return DF;  }
+
+  inline const std::vector<BasicBlock *> &getRoots() const {
+    return Base.getRoots();
+  }
+
+  BasicBlock *getRoot() const { return Base.getRoot(); }
+
+  bool isPostDominator() const { return Base.isPostDominator(); }
+
+  iterator begin() { return Base.begin(); }
+
+  const_iterator begin() const { return Base.begin(); }
+
+  iterator end() { return Base.end(); }
+
+  const_iterator end() const { return Base.end(); }
+
+  iterator find(BasicBlock *B) { return Base.find(B); }
+
+  const_iterator find(BasicBlock *B) const { return Base.find(B); }
+
+  iterator addBasicBlock(BasicBlock *BB, const DomSetType &frontier) {
+    return Base.addBasicBlock(BB, frontier);
+  }
+
+  void removeBlock(BasicBlock *BB) { return Base.removeBlock(BB); }
+
+  void addToFrontier(iterator I, BasicBlock *Node) {
+    return Base.addToFrontier(I, Node);
+  }
+
+  void removeFromFrontier(iterator I, BasicBlock *Node) {
+    return Base.removeFromFrontier(I, Node);
+  }
+
+  bool compareDomSet(DomSetType &DS1, const DomSetType &DS2) const {
+    return Base.compareDomSet(DS1, DS2);
+  }
+
+  bool compare(DominanceFrontierBase<BasicBlock> &Other) const {
+    return Base.compare(Other);
+  }
 
   void releaseMemory() override;
 
@@ -171,36 +205,6 @@ public:
 extern template class DominanceFrontierBase<BasicBlock>;
 extern template class ForwardDominanceFrontierBase<BasicBlock>;
 
-/// \brief Analysis pass which computes a \c DominanceFrontier.
-class DominanceFrontierAnalysis {
-public:
-  /// \brief Provide the result typedef for this analysis pass.
-  typedef DominanceFrontier 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 dominator tree.
-  DominanceFrontier run(Function &F, AnalysisManager<Function> *AM);
-
-  /// \brief Provide access to a name for this pass for debugging purposes.
-  static StringRef name() { return "DominanceFrontierAnalysis"; }
-
-private:
-  static char PassID;
-};
-
-/// \brief Printer pass for the \c DominanceFrontier.
-class DominanceFrontierPrinterPass {
-  raw_ostream &OS;
-
-public:
-  explicit DominanceFrontierPrinterPass(raw_ostream &OS);
-  PreservedAnalyses run(Function &F, AnalysisManager<Function> *AM);
-
-  static StringRef name() { return "DominanceFrontierAnalysis"; }
-};
-
 } // End llvm namespace
 
 #endif

llvm/include/llvm/InitializePasses.h

@@ -111,7 +111,7 @@ void initializeDomOnlyPrinterPass(PassRegistry&);
 void initializeDomOnlyViewerPass(PassRegistry&);
 void initializeDomPrinterPass(PassRegistry&);
 void initializeDomViewerPass(PassRegistry&);
-void initializeDominanceFrontierWrapperPassPass(PassRegistry&);
+void initializeDominanceFrontierPass(PassRegistry&);
 void initializeDominatorTreeWrapperPassPass(PassRegistry&);
 void initializeEarlyIfConverterPass(PassRegistry&);
 void initializeEdgeBundlesPass(PassRegistry&);

llvm/lib/Analysis/Analysis.cpp

@@ -38,7 +38,7 @@ void llvm::initializeAnalysis(PassRegistry &Registry) {
   initializeDelinearizationPass(Registry);
   initializeDemandedBitsPass(Registry);
   initializeDivergenceAnalysisPass(Registry);
-  initializeDominanceFrontierWrapperPassPass(Registry);
+  initializeDominanceFrontierPass(Registry);
   initializeDomViewerPass(Registry);
   initializeDomPrinterPass(Registry);
   initializeDomOnlyViewerPass(Registry);

llvm/lib/Analysis/DominanceFrontier.cpp

@@ -9,7 +9,6 @@
 
 #include "llvm/Analysis/DominanceFrontier.h"
 #include "llvm/Analysis/DominanceFrontierImpl.h"
-#include "llvm/IR/PassManager.h"
 
 using namespace llvm;
 
@@ -18,60 +17,41 @@ template class DominanceFrontierBase<BasicBlock>;
 template class ForwardDominanceFrontierBase<BasicBlock>;
 }
 
-char DominanceFrontierWrapperPass::ID = 0;
+char DominanceFrontier::ID = 0;
 
-INITIALIZE_PASS_BEGIN(DominanceFrontierWrapperPass, "domfrontier",
+INITIALIZE_PASS_BEGIN(DominanceFrontier, "domfrontier",
                 "Dominance Frontier Construction", true, true)
 INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
-INITIALIZE_PASS_END(DominanceFrontierWrapperPass, "domfrontier",
+INITIALIZE_PASS_END(DominanceFrontier, "domfrontier",
                 "Dominance Frontier Construction", true, true)
 
- DominanceFrontierWrapperPass::DominanceFrontierWrapperPass()
+DominanceFrontier::DominanceFrontier()
-    : FunctionPass(ID), DF() {
+  : FunctionPass(ID),
-  initializeDominanceFrontierWrapperPassPass(*PassRegistry::getPassRegistry());
+    Base() {
+  initializeDominanceFrontierPass(*PassRegistry::getPassRegistry());
 }
 
-void DominanceFrontierWrapperPass::releaseMemory() {
+void DominanceFrontier::releaseMemory() {
-  DF.releaseMemory();
+  Base.releaseMemory();
 }
 
-bool DominanceFrontierWrapperPass::runOnFunction(Function &) {
+bool DominanceFrontier::runOnFunction(Function &) {
   releaseMemory();
-  DF.analyze(getAnalysis<DominatorTreeWrapperPass>().getDomTree());
+  Base.analyze(getAnalysis<DominatorTreeWrapperPass>().getDomTree());
   return false;
 }
 
-void DominanceFrontierWrapperPass::getAnalysisUsage(AnalysisUsage &AU) const {
+void DominanceFrontier::getAnalysisUsage(AnalysisUsage &AU) const {
   AU.setPreservesAll();
   AU.addRequired<DominatorTreeWrapperPass>();
 }
 
-void DominanceFrontierWrapperPass::print(raw_ostream &OS, const Module *) const {
+void DominanceFrontier::print(raw_ostream &OS, const Module *) const {
-  DF.print(OS);
+  Base.print(OS);
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void DominanceFrontierWrapperPass::dump() const {
+LLVM_DUMP_METHOD void DominanceFrontier::dump() const {
   print(dbgs());
 }
 #endif
-
-char DominanceFrontierAnalysis::PassID;
-
-DominanceFrontier DominanceFrontierAnalysis::run(Function &F,
-                                                 FunctionAnalysisManager *AM) {
-  DominanceFrontier DF;
-  DF.analyze(AM->getResult<DominatorTreeAnalysis>(F));
-  return DF;
-}
-
-DominanceFrontierPrinterPass::DominanceFrontierPrinterPass(raw_ostream &OS)
-  : OS(OS) {}
-
-PreservedAnalyses
-DominanceFrontierPrinterPass::run(Function &F, FunctionAnalysisManager *AM) {
-  OS << "DominanceFrontier for function: " << F.getName() << "\n";
-  AM->getResult<DominanceFrontierAnalysis>(F).print(OS);
-
-  return PreservedAnalyses::all();
-}

llvm/lib/Analysis/RegionInfo.cpp

@@ -129,7 +129,7 @@ bool RegionInfoPass::runOnFunction(Function &F) {
 
   auto DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
   auto PDT = &getAnalysis<PostDominatorTreeWrapperPass>().getPostDomTree();
-  auto DF = &getAnalysis<DominanceFrontierWrapperPass>().getDominanceFrontier();
+  auto DF = &getAnalysis<DominanceFrontier>();
 
   RI.recalculate(F, DT, PDT, DF);
   return false;
@@ -146,8 +146,8 @@ void RegionInfoPass::verifyAnalysis() const {
 void RegionInfoPass::getAnalysisUsage(AnalysisUsage &AU) const {
   AU.setPreservesAll();
   AU.addRequiredTransitive<DominatorTreeWrapperPass>();
+  AU.addRequired<DominanceFrontier>();
   AU.addRequired<PostDominatorTreeWrapperPass>();
-  AU.addRequired<DominanceFrontierWrapperPass>();
 }
 
 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(DominanceFrontier)
 INITIALIZE_PASS_DEPENDENCY(PostDominatorTreeWrapperPass)
-INITIALIZE_PASS_DEPENDENCY(DominanceFrontierWrapperPass)
 INITIALIZE_PASS_END(RegionInfoPass, "regions",
                 "Detect single entry single exit regions", true, true)
 

llvm/lib/CodeGen/MachineFunctionPass.cpp

@@ -53,7 +53,7 @@ void MachineFunctionPass::getAnalysisUsage(AnalysisUsage &AU) const {
   // because CodeGen overloads that to mean preserving the MachineBasicBlock
   // CFG in addition to the LLVM IR CFG.
   AU.addPreserved<BasicAAWrapperPass>();
-  AU.addPreserved<DominanceFrontierWrapperPass>();
+  AU.addPreserved<DominanceFrontier>();
   AU.addPreserved<DominatorTreeWrapperPass>();
   AU.addPreserved<AAResultsWrapperPass>();
   AU.addPreserved<GlobalsAAWrapperPass>();

llvm/lib/CodeGen/MachineRegionInfo.cpp

@@ -105,7 +105,7 @@ void MachineRegionInfoPass::getAnalysisUsage(AnalysisUsage &AU) const {
   AU.setPreservesAll();
   AU.addRequiredTransitive<DominatorTreeWrapperPass>();
   AU.addRequired<PostDominatorTreeWrapperPass>();
-  AU.addRequired<DominanceFrontierWrapperPass>();
+  AU.addRequired<DominanceFrontier>();
 }
 
 void MachineRegionInfoPass::print(raw_ostream &OS, const Module *) const {

llvm/lib/Passes/PassBuilder.cpp

@@ -22,7 +22,6 @@
 #include "llvm/Analysis/BasicAliasAnalysis.h"
 #include "llvm/Analysis/CFLAliasAnalysis.h"
 #include "llvm/Analysis/CGSCCPassManager.h"
-#include "llvm/Analysis/DominanceFrontier.h"
 #include "llvm/Analysis/LazyCallGraph.h"
 #include "llvm/Analysis/LoopInfo.h"
 #include "llvm/Analysis/PostDominators.h"

llvm/lib/Passes/PassRegistry.def

@@ -58,7 +58,6 @@ FUNCTION_ANALYSIS("aa", AAManager())
 FUNCTION_ANALYSIS("assumptions", AssumptionAnalysis())
 FUNCTION_ANALYSIS("domtree", DominatorTreeAnalysis())
 FUNCTION_ANALYSIS("postdomtree", PostDominatorTreeAnalysis())
-FUNCTION_ANALYSIS("domfrontier", DominanceFrontierAnalysis())
 FUNCTION_ANALYSIS("loops", LoopAnalysis())
 FUNCTION_ANALYSIS("no-op-function", NoOpFunctionAnalysis())
 FUNCTION_ANALYSIS("scalar-evolution", ScalarEvolutionAnalysis())
@@ -92,7 +91,6 @@ FUNCTION_PASS("print", PrintFunctionPass(dbgs()))
 FUNCTION_PASS("print<assumptions>", AssumptionPrinterPass(dbgs()))
 FUNCTION_PASS("print<domtree>", DominatorTreePrinterPass(dbgs()))
 FUNCTION_PASS("print<postdomtree>", PostDominatorTreePrinterPass(dbgs()))
-FUNCTION_PASS("print<domfrontier>", DominanceFrontierPrinterPass(dbgs()))
 FUNCTION_PASS("print<loops>", LoopPrinterPass(dbgs()))
 FUNCTION_PASS("print<scalar-evolution>", ScalarEvolutionPrinterPass(dbgs()))
 FUNCTION_PASS("simplify-cfg", SimplifyCFGPass())

llvm/test/Analysis/DominanceFrontier/new_pm_test.ll

@@ -1,50 +0,0 @@
-; REQUIRES: asserts
-; RUN: opt  < %s -passes='print<domfrontier>'  2>&1 | FileCheck %s
-
-define void @a_linear_impl_fig_1() nounwind {
-0:
-  br label %"1"
-1:
-  br label %"2"
-2:
-  br label %"3"
-3:
-  br i1 1, label %"13", label %"4"
-4:
-  br i1 1, label %"5", label %"1"
-5:
-  br i1 1, label %"8", label %"6"
-6:
-  br i1 1, label %"7", label %"4"
-7:
-  ret void
-8:
-  br i1 1, label %"9", label %"1"
-9:
-  br label %"10"
-10:
-  br i1 1, label %"12", label %"11"
-11:
-  br i1 1, label %"9", label %"8"
-13:
-  br i1 1, label %"2", label %"1"
-12:
-   switch i32 0, label %"1" [ i32 0, label %"9"
-                              i32 1, label %"8"]
-}
-
-; CHECK: DominanceFrontier for function: a_linear_impl_fig_1
-; CHECK-DAG:  DomFrontier for BB %"0" is:
-; CHECK-DAG:  DomFrontier for BB %"11" is:   %"8" %"9"
-; CHECK-DAG:  DomFrontier for BB %"1" is:    %"1"
-; CHECK-DAG:  DomFrontier for BB %"2" is:    %"1" %"2"
-; CHECK-DAG:  DomFrontier for BB %"3" is:    %"1" %"2"
-; CHECK-DAG:  DomFrontier for BB %"13" is:   %"1" %"2"
-; CHECK-DAG:  DomFrontier for BB %"4" is:    %"1" %"4"
-; CHECK-DAG:  DomFrontier for BB %"5" is:    %"1" %"4"
-; CHECK-DAG:  DomFrontier for BB %"8" is:    %"1" %"8"
-; CHECK-DAG:  DomFrontier for BB %"6" is:    %"4"
-; CHECK-DAG:  DomFrontier for BB %"7" is:
-; CHECK-DAG:  DomFrontier for BB %"9" is:    %"1" %"8" %"9"
-; CHECK-DAG:  DomFrontier for BB %"10" is:   %"1" %"8" %"9"
-; CHECK-DAG:  DomFrontier for BB %"12" is:   %"1" %"8" %"9"