RPCSX/llvm
1
0
Fork 0
mirror of https://github.com/RPCSX/llvm.git synced 2024-11-24 04:09:45 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Introduce analysis pass to compute PostDominators in the new pass manager. NFC

Browse Source 
Differential Revision: http://reviews.llvm.org/D17537

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@261902 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Hongbin Zheng 2016-02-25 17:54:07 +00:00
parent dca70119b4
commit 5d7472e863
13 changed files with 132 additions and 93 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

101
include/llvm/Analysis/PostDominators.h
View File

@ -17,20 +17,58 @@
#include "llvm/IR/Dominators.h"
namespace llvm {
// FIXME: Replace this brittle forward declaration with the include of the new
// PassManager.h when doing so doesn't break the PassManagerBuilder.
class PreservedAnalyses;
/// 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;
struct PostDominatorTree : public DominatorTreeBase<BasicBlock> {
PostDominatorTree() : DominatorTreeBase<BasicBlock>(true) {}
};
PostDominatorTree() : FunctionPass(ID) {
initializePostDominatorTreePass(*PassRegistry::getPassRegistry());
DT = new DominatorTreeBase<BasicBlock>(true);
/// \brief Analysis pass which computes a \c PostDominatorTree.
class PostDominatorTreeAnalysis {
public:
/// \brief Provide the result typedef for this analysis pass.
typedef PostDominatorTree 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 post dominator
/// tree.
PostDominatorTree run(Function &F);
/// \brief Provide access to a name for this pass for debugging purposes.
static StringRef name() { return "PostDominatorTreeAnalysis"; }
private:
static char PassID;
};
/// \brief Printer pass for the \c PostDominatorTree.
class PostDominatorTreePrinterPass {
raw_ostream &OS;
public:
explicit PostDominatorTreePrinterPass(raw_ostream &OS);
PreservedAnalyses run(Function &F, AnalysisManager<Function> *AM);
static StringRef name() { return "PostDominatorTreePrinterPass"; }
};
struct PostDominatorTreeWrapperPass : public FunctionPass {
static char ID; // Pass identification, replacement for typeid
PostDominatorTree DT;
PostDominatorTreeWrapperPass() : FunctionPass(ID) {
initializePostDominatorTreeWrapperPassPass(*PassRegistry::getPassRegistry());
}
~PostDominatorTree() override;
PostDominatorTree &getPostDomTree() { return DT; }
const PostDominatorTree &getPostDomTree() const { return DT; }
bool runOnFunction(Function &F) override;
@ -38,55 +76,8 @@ struct PostDominatorTree : public FunctionPass {
AU.setPreservesAll();
}
inline const std::vector<BasicBlock*> &getRoots() const {
return DT->getRoots();
}
inline DomTreeNode *getRootNode() const {
return DT->getRootNode();
}
inline DomTreeNode *operator[](BasicBlock *BB) const {
return DT->getNode(BB);
}
inline DomTreeNode *getNode(BasicBlock *BB) const {
return DT->getNode(BB);
}
inline bool dominates(DomTreeNode* A, DomTreeNode* B) const {
return DT->dominates(A, B);
}
inline bool dominates(const BasicBlock* A, const BasicBlock* B) const {
return DT->dominates(A, B);
}
inline bool properlyDominates(const DomTreeNode* A, DomTreeNode* B) const {
return DT->properlyDominates(A, B);
}
inline bool properlyDominates(BasicBlock* A, BasicBlock* B) const {
return DT->properlyDominates(A, B);
}
inline BasicBlock *findNearestCommonDominator(BasicBlock *A, BasicBlock *B) {
return DT->findNearestCommonDominator(A, B);
}
inline const BasicBlock *findNearestCommonDominator(const BasicBlock *A,
const BasicBlock *B) {
return DT->findNearestCommonDominator(A, B);
}
/// Get all nodes post-dominated by R, including R itself.
void getDescendants(BasicBlock *R,
SmallVectorImpl<BasicBlock *> &Result) const {
DT->getDescendants(R, Result);
}
void releaseMemory() override {
DT->releaseMemory();
DT.releaseMemory();
}
void print(raw_ostream &OS, const Module*) const override;

2
include/llvm/InitializePasses.h
View File

@ -232,7 +232,7 @@ void initializePostDomOnlyPrinterPass(PassRegistry&);
void initializePostDomOnlyViewerPass(PassRegistry&);
void initializePostDomPrinterPass(PassRegistry&);
void initializePostDomViewerPass(PassRegistry&);
void initializePostDominatorTreePass(PassRegistry&);
void initializePostDominatorTreeWrapperPassPass(PassRegistry&);
void initializePostOrderFunctionAttrsLegacyPassPass(PassRegistry&);
void initializePostRASchedulerPass(PassRegistry&);
void initializePostMachineSchedulerPass(PassRegistry&);

2
lib/Analysis/Analysis.cpp
View File

@ -60,7 +60,7 @@ void llvm::initializeAnalysis(PassRegistry &Registry) {
initializeMemoryDependenceAnalysisPass(Registry);
initializeModuleDebugInfoPrinterPass(Registry);
initializeObjCARCAAWrapperPassPass(Registry);
initializePostDominatorTreePass(Registry);
initializePostDominatorTreeWrapperPassPass(Registry);
initializeRegionInfoPassPass(Registry);
initializeRegionViewerPass(Registry);
initializeRegionPrinterPass(Registry);

7
lib/Analysis/DivergenceAnalysis.cpp
View File

@ -258,7 +258,7 @@ char DivergenceAnalysis::ID = 0;
INITIALIZE_PASS_BEGIN(DivergenceAnalysis, "divergence", "Divergence Analysis",
false, true)
INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
INITIALIZE_PASS_DEPENDENCY(PostDominatorTree)
INITIALIZE_PASS_DEPENDENCY(PostDominatorTreeWrapperPass)
INITIALIZE_PASS_END(DivergenceAnalysis, "divergence", "Divergence Analysis",
false, true)
@ -268,7 +268,7 @@ FunctionPass *llvm::createDivergenceAnalysisPass() {
void DivergenceAnalysis::getAnalysisUsage(AnalysisUsage &AU) const {
AU.addRequired<DominatorTreeWrapperPass>();
AU.addRequired<PostDominatorTree>();
AU.addRequired<PostDominatorTreeWrapperPass>();
AU.setPreservesAll();
}
@ -284,9 +284,10 @@ bool DivergenceAnalysis::runOnFunction(Function &F) {
return false;
DivergentValues.clear();
auto &PDT = getAnalysis<PostDominatorTreeWrapperPass>().getPostDomTree();
DivergencePropagator DP(F, TTI,
getAnalysis<DominatorTreeWrapperPass>().getDomTree(),
getAnalysis<PostDominatorTree>(), DivergentValues);
PDT, DivergentValues);
DP.populateWithSourcesOfDivergence();
DP.propagate();
return false;

48
lib/Analysis/DomPrinter.cpp
View File

@ -111,20 +111,36 @@ struct DomOnlyViewer : public DOTGraphTraitsViewer<
}
};
struct PostDomViewer
: public DOTGraphTraitsViewer<PostDominatorTree, false> {
struct PostDominatorTreeWrapperPassAnalysisGraphTraits {
static PostDominatorTree *getGraph(PostDominatorTreeWrapperPass *PDTWP) {
return &PDTWP->getPostDomTree();
}
};
struct PostDomViewer : public DOTGraphTraitsViewer<
PostDominatorTreeWrapperPass, false,
PostDominatorTree *,
PostDominatorTreeWrapperPassAnalysisGraphTraits> {
static char ID;
PostDomViewer() :
DOTGraphTraitsViewer<PostDominatorTree, false>("postdom", ID){
DOTGraphTraitsViewer<PostDominatorTreeWrapperPass, false,
PostDominatorTree *,
PostDominatorTreeWrapperPassAnalysisGraphTraits>(
"postdom", ID){
initializePostDomViewerPass(*PassRegistry::getPassRegistry());
}
};
struct PostDomOnlyViewer
: public DOTGraphTraitsViewer<PostDominatorTree, true> {
struct PostDomOnlyViewer : public DOTGraphTraitsViewer<
PostDominatorTreeWrapperPass, true,
PostDominatorTree *,
PostDominatorTreeWrapperPassAnalysisGraphTraits> {
static char ID;
PostDomOnlyViewer() :
DOTGraphTraitsViewer<PostDominatorTree, true>("postdomonly", ID){
DOTGraphTraitsViewer<PostDominatorTreeWrapperPass, true,
PostDominatorTree *,
PostDominatorTreeWrapperPassAnalysisGraphTraits>(
"postdomonly", ID){
initializePostDomOnlyViewerPass(*PassRegistry::getPassRegistry());
}
};
@ -175,19 +191,31 @@ struct DomOnlyPrinter : public DOTGraphTraitsPrinter<
};
struct PostDomPrinter
: public DOTGraphTraitsPrinter<PostDominatorTree, false> {
: public DOTGraphTraitsPrinter<
PostDominatorTreeWrapperPass, false,
PostDominatorTree *,
PostDominatorTreeWrapperPassAnalysisGraphTraits> {
static char ID;
PostDomPrinter() :
DOTGraphTraitsPrinter<PostDominatorTree, false>("postdom", ID) {
DOTGraphTraitsPrinter<PostDominatorTreeWrapperPass, false,
PostDominatorTree *,
PostDominatorTreeWrapperPassAnalysisGraphTraits>(
"postdom", ID) {
initializePostDomPrinterPass(*PassRegistry::getPassRegistry());
}
};
struct PostDomOnlyPrinter
: public DOTGraphTraitsPrinter<PostDominatorTree, true> {
: public DOTGraphTraitsPrinter<
PostDominatorTreeWrapperPass, true,
PostDominatorTree *,
PostDominatorTreeWrapperPassAnalysisGraphTraits> {
static char ID;
PostDomOnlyPrinter() :
DOTGraphTraitsPrinter<PostDominatorTree, true>("postdomonly", ID) {
DOTGraphTraitsPrinter<PostDominatorTreeWrapperPass, true,
PostDominatorTree *,
PostDominatorTreeWrapperPassAnalysisGraphTraits>(
"postdomonly", ID) {
initializePostDomOnlyPrinterPass(*PassRegistry::getPassRegistry());
}
};

38
lib/Analysis/PostDominators.cpp
View File

@ -16,6 +16,7 @@
#include "llvm/ADT/SetOperations.h"
#include "llvm/IR/CFG.h"
#include "llvm/IR/Instructions.h"
#include "llvm/IR/PassManager.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/GenericDomTreeConstruction.h"
using namespace llvm;
@ -26,25 +27,38 @@ using namespace llvm;
// PostDominatorTree Implementation
//===----------------------------------------------------------------------===//
char PostDominatorTree::ID = 0;
INITIALIZE_PASS(PostDominatorTree, "postdomtree",
char PostDominatorTreeWrapperPass::ID = 0;
INITIALIZE_PASS(PostDominatorTreeWrapperPass, "postdomtree",
"Post-Dominator Tree Construction", true, true)
bool PostDominatorTree::runOnFunction(Function &F) {
DT->recalculate(F);
bool PostDominatorTreeWrapperPass::runOnFunction(Function &F) {
DT.recalculate(F);
return false;
}
PostDominatorTree::~PostDominatorTree() {
delete DT;
void PostDominatorTreeWrapperPass::print(raw_ostream &OS, const Module *) const {
DT.print(OS);
}
void PostDominatorTree::print(raw_ostream &OS, const Module *) const {
DT->print(OS);
}
FunctionPass* llvm::createPostDomTree() {
return new PostDominatorTree();
return new PostDominatorTreeWrapperPass();
}
char PostDominatorTreeAnalysis::PassID;
PostDominatorTree PostDominatorTreeAnalysis::run(Function &F) {
PostDominatorTree PDT;
PDT.recalculate(F);
return PDT;
}
PostDominatorTreePrinterPass::PostDominatorTreePrinterPass(raw_ostream &OS)
: OS(OS) {}
PreservedAnalyses
PostDominatorTreePrinterPass::run(Function &F, FunctionAnalysisManager *AM) {
OS << "PostDominatorTree for function: " << F.getName() << "\n";
AM->getResult<PostDominatorTreeAnalysis>(F).print(OS);
return PreservedAnalyses::all();
}

6
lib/Analysis/RegionInfo.cpp
View File

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

2
lib/CodeGen/MachineRegionInfo.cpp
View File

@ -104,7 +104,7 @@ void MachineRegionInfoPass::verifyAnalysis() const {
void MachineRegionInfoPass::getAnalysisUsage(AnalysisUsage &AU) const {
AU.setPreservesAll();
AU.addRequiredTransitive<DominatorTreeWrapperPass>();
AU.addRequired<PostDominatorTree>();
AU.addRequired<PostDominatorTreeWrapperPass>();
AU.addRequired<DominanceFrontier>();
}

1
lib/Passes/PassBuilder.cpp
View File

@ -24,6 +24,7 @@
#include "llvm/Analysis/CGSCCPassManager.h"
#include "llvm/Analysis/LazyCallGraph.h"
#include "llvm/Analysis/LoopInfo.h"
#include "llvm/Analysis/PostDominators.h"
#include "llvm/Analysis/ScalarEvolution.h"
#include "llvm/Analysis/ScalarEvolutionAliasAnalysis.h"
#include "llvm/Analysis/ScopedNoAliasAA.h"

2
lib/Passes/PassRegistry.def
View File

@ -57,6 +57,7 @@ CGSCC_PASS("no-op-cgscc", NoOpCGSCCPass())
FUNCTION_ANALYSIS("aa", AAManager())
FUNCTION_ANALYSIS("assumptions", AssumptionAnalysis())
FUNCTION_ANALYSIS("domtree", DominatorTreeAnalysis())
FUNCTION_ANALYSIS("postdomtree", PostDominatorTreeAnalysis())
FUNCTION_ANALYSIS("loops", LoopAnalysis())
FUNCTION_ANALYSIS("no-op-function", NoOpFunctionAnalysis())
FUNCTION_ANALYSIS("scalar-evolution", ScalarEvolutionAnalysis())
@ -89,6 +90,7 @@ FUNCTION_PASS("lower-expect", LowerExpectIntrinsicPass())
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<loops>", LoopPrinterPass(dbgs()))
FUNCTION_PASS("print<scalar-evolution>", ScalarEvolutionPrinterPass(dbgs()))
FUNCTION_PASS("simplify-cfg", SimplifyCFGPass())

8
lib/Target/Hexagon/HexagonCommonGEP.cpp
View File

@ -90,8 +90,8 @@ namespace {
virtual void getAnalysisUsage(AnalysisUsage &AU) const {
AU.addRequired<DominatorTreeWrapperPass>();
AU.addPreserved<DominatorTreeWrapperPass>();
AU.addRequired<PostDominatorTree>();
AU.addPreserved<PostDominatorTree>();
AU.addRequired<PostDominatorTreeWrapperPass>();
AU.addPreserved<PostDominatorTreeWrapperPass>();
AU.addRequired<LoopInfoWrapperPass>();
AU.addPreserved<LoopInfoWrapperPass>();
FunctionPass::getAnalysisUsage(AU);
@ -147,7 +147,7 @@ char HexagonCommonGEP::ID = 0;
INITIALIZE_PASS_BEGIN(HexagonCommonGEP, "hcommgep", "Hexagon Common GEP",
false, false)
INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
INITIALIZE_PASS_DEPENDENCY(PostDominatorTree)
INITIALIZE_PASS_DEPENDENCY(PostDominatorTreeWrapperPass)
INITIALIZE_PASS_DEPENDENCY(LoopInfoWrapperPass)
INITIALIZE_PASS_END(HexagonCommonGEP, "hcommgep", "Hexagon Common GEP",
false, false)
@ -1276,7 +1276,7 @@ bool HexagonCommonGEP::runOnFunction(Function &F) {
Fn = &F;
DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
PDT = &getAnalysis<PostDominatorTree>();
PDT = &getAnalysis<PostDominatorTreeWrapperPass>().getPostDomTree();
LI = &getAnalysis<LoopInfoWrapperPass>().getLoopInfo();
Ctx = &F.getContext();

1
test/Analysis/PostDominators/pr1098.ll
View File

@ -1,4 +1,5 @@
; RUN: opt < %s -postdomtree -analyze | FileCheck %s
; RUN: opt < %s -passes='print<postdomtree>' 2>&1 | FileCheck %s
; PR932
define void @foo(i1 %x) {

7
unittests/IR/DominatorTreeTest.cpp
View File

@ -29,7 +29,8 @@ namespace llvm {
bool runOnFunction(Function &F) override {
DominatorTree *DT =
&getAnalysis<DominatorTreeWrapperPass>().getDomTree();
PostDominatorTree *PDT = &getAnalysis<PostDominatorTree>();
PostDominatorTree *PDT =
&getAnalysis<PostDominatorTreeWrapperPass>().getPostDomTree();
Function::iterator FI = F.begin();
BasicBlock *BB0 = &*FI++;
@ -206,7 +207,7 @@ namespace llvm {
}
void getAnalysisUsage(AnalysisUsage &AU) const override {
AU.addRequired<DominatorTreeWrapperPass>();
AU.addRequired<PostDominatorTree>();
AU.addRequired<PostDominatorTreeWrapperPass>();
}
DPass() : FunctionPass(ID) {
initializeDPassPass(*PassRegistry::getPassRegistry());
@ -255,5 +256,5 @@ namespace llvm {
INITIALIZE_PASS_BEGIN(DPass, "dpass", "dpass", false, false)
INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
INITIALIZE_PASS_DEPENDENCY(PostDominatorTree)
INITIALIZE_PASS_DEPENDENCY(PostDominatorTreeWrapperPass)
INITIALIZE_PASS_END(DPass, "dpass", "dpass", false, false)