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.
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
void initializeDomOnlyViewerPass(PassRegistry&);
void initializeDomPrinterPass(PassRegistry&);
void initializeDomViewerPass(PassRegistry&);
-void initializeDominanceFrontierPass(PassRegistry&);
+void initializeDominanceFrontierWrapperPassPass(PassRegistry&);
void initializeDominatorTreeWrapperPassPass(PassRegistry&);
void initializeEarlyIfConverterPass(PassRegistry&);
void initializeEdgeBundlesPass(PassRegistry&);
initializeDelinearizationPass(Registry);
initializeDemandedBitsPass(Registry);
initializeDivergenceAnalysisPass(Registry);
- initializeDominanceFrontierPass(Registry);
+ initializeDominanceFrontierWrapperPassPass(Registry);
initializeDomViewerPass(Registry);
initializeDomPrinterPass(Registry);
initializeDomOnlyViewerPass(Registry);
#include "llvm/Analysis/DominanceFrontier.h"
#include "llvm/Analysis/DominanceFrontierImpl.h"
+#include "llvm/IR/PassManager.h"
using namespace llvm;
template class ForwardDominanceFrontierBase<BasicBlock>;
}
-char DominanceFrontier::ID = 0;
+char DominanceFrontierWrapperPass::ID = 0;
-INITIALIZE_PASS_BEGIN(DominanceFrontier, "domfrontier",
+INITIALIZE_PASS_BEGIN(DominanceFrontierWrapperPass, "domfrontier",
"Dominance Frontier Construction", true, true)
INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
-INITIALIZE_PASS_END(DominanceFrontier, "domfrontier",
+INITIALIZE_PASS_END(DominanceFrontierWrapperPass, "domfrontier",
"Dominance Frontier Construction", true, true)
-DominanceFrontier::DominanceFrontier()
- : FunctionPass(ID),
- Base() {
- initializeDominanceFrontierPass(*PassRegistry::getPassRegistry());
+ DominanceFrontierWrapperPass::DominanceFrontierWrapperPass()
+ : FunctionPass(ID), DF() {
+ initializeDominanceFrontierWrapperPassPass(*PassRegistry::getPassRegistry());
}
-void DominanceFrontier::releaseMemory() {
- Base.releaseMemory();
+void DominanceFrontierWrapperPass::releaseMemory() {
+ DF.releaseMemory();
}
-bool DominanceFrontier::runOnFunction(Function &) {
+bool DominanceFrontierWrapperPass::runOnFunction(Function &) {
releaseMemory();
- Base.analyze(getAnalysis<DominatorTreeWrapperPass>().getDomTree());
+ DF.analyze(getAnalysis<DominatorTreeWrapperPass>().getDomTree());
return false;
}
-void DominanceFrontier::getAnalysisUsage(AnalysisUsage &AU) const {
+void DominanceFrontierWrapperPass::getAnalysisUsage(AnalysisUsage &AU) const {
AU.setPreservesAll();
AU.addRequired<DominatorTreeWrapperPass>();
}
-void DominanceFrontier::print(raw_ostream &OS, const Module *) const {
- Base.print(OS);
+void DominanceFrontierWrapperPass::print(raw_ostream &OS, const Module *) const {
+ DF.print(OS);
}
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void DominanceFrontier::dump() const {
+LLVM_DUMP_METHOD void DominanceFrontierWrapperPass::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();
+}
auto DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
auto PDT = &getAnalysis<PostDominatorTreeWrapperPass>().getPostDomTree();
- auto DF = &getAnalysis<DominanceFrontier>();
+ auto DF = &getAnalysis<DominanceFrontierWrapperPass>().getDominanceFrontier();
RI.recalculate(F, DT, PDT, DF);
return false;
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 {
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)
// because CodeGen overloads that to mean preserving the MachineBasicBlock
// CFG in addition to the LLVM IR CFG.
AU.addPreserved<BasicAAWrapperPass>();
- AU.addPreserved<DominanceFrontier>();
+ AU.addPreserved<DominanceFrontierWrapperPass>();
AU.addPreserved<DominatorTreeWrapperPass>();
AU.addPreserved<AAResultsWrapperPass>();
AU.addPreserved<GlobalsAAWrapperPass>();
AU.setPreservesAll();
AU.addRequiredTransitive<DominatorTreeWrapperPass>();
AU.addRequired<PostDominatorTreeWrapperPass>();
- AU.addRequired<DominanceFrontier>();
+ AU.addRequired<DominanceFrontierWrapperPass>();
}
void MachineRegionInfoPass::print(raw_ostream &OS, const Module *) const {
#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"
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())
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())
--- /dev/null
+; 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"