1 //===- RegionInfo.cpp - SESE region detection analysis --------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 // Detects single entry single exit regions in the control flow graph.
9 //===----------------------------------------------------------------------===//
10
11 #include "llvm/Analysis/RegionInfo.h"
12 #include "llvm/ADT/Statistic.h"
13 #include "llvm/Analysis/DominanceFrontier.h"
14 #include "llvm/InitializePasses.h"
15 #ifndef NDEBUG
16 #include "llvm/Analysis/RegionPrinter.h"
17 #endif
18 #include "llvm/Analysis/RegionInfoImpl.h"
19 #include "llvm/Config/llvm-config.h"
20 #include "llvm/IR/Function.h"
21 #include "llvm/Support/CommandLine.h"
22 #include "llvm/Support/Compiler.h"
23
24 using namespace llvm;
25
26 #define DEBUG_TYPE "region"
27
28 namespace llvm {
29
30 template class RegionBase<RegionTraits<Function>>;
31 template class RegionNodeBase<RegionTraits<Function>>;
32 template class RegionInfoBase<RegionTraits<Function>>;
33
34 } // end namespace llvm
35
36 STATISTIC(numRegions, "The # of regions");
37 STATISTIC(numSimpleRegions, "The # of simple regions");
38
39 // Always verify if expensive checking is enabled.
40
41 static cl::opt<bool,true>
42 VerifyRegionInfoX(
43 "verify-region-info",
44 cl::location(RegionInfoBase<RegionTraits<Function>>::VerifyRegionInfo),
45 cl::desc("Verify region info (time consuming)"));
46
47 static cl::opt<Region::PrintStyle, true> printStyleX("print-region-style",
48 cl::location(RegionInfo::printStyle),
49 cl::Hidden,
50 cl::desc("style of printing regions"),
51 cl::values(
52 clEnumValN(Region::PrintNone, "none", "print no details"),
53 clEnumValN(Region::PrintBB, "bb",
54 "print regions in detail with block_iterator"),
55 clEnumValN(Region::PrintRN, "rn",
56 "print regions in detail with element_iterator")));
57
58 //===----------------------------------------------------------------------===//
59 // Region implementation
60 //
61
Region(BasicBlock * Entry,BasicBlock * Exit,RegionInfo * RI,DominatorTree * DT,Region * Parent)62 Region::Region(BasicBlock *Entry, BasicBlock *Exit,
63 RegionInfo* RI,
64 DominatorTree *DT, Region *Parent) :
65 RegionBase<RegionTraits<Function>>(Entry, Exit, RI, DT, Parent) {
66
67 }
68
69 Region::~Region() = default;
70
71 //===----------------------------------------------------------------------===//
72 // RegionInfo implementation
73 //
74
75 RegionInfo::RegionInfo() = default;
76
77 RegionInfo::~RegionInfo() = default;
78
invalidate(Function & F,const PreservedAnalyses & PA,FunctionAnalysisManager::Invalidator &)79 bool RegionInfo::invalidate(Function &F, const PreservedAnalyses &PA,
80 FunctionAnalysisManager::Invalidator &) {
81 // Check whether the analysis, all analyses on functions, or the function's
82 // CFG has been preserved.
83 auto PAC = PA.getChecker<RegionInfoAnalysis>();
84 return !(PAC.preserved() || PAC.preservedSet<AllAnalysesOn<Function>>() ||
85 PAC.preservedSet<CFGAnalyses>());
86 }
87
updateStatistics(Region * R)88 void RegionInfo::updateStatistics(Region *R) {
89 ++numRegions;
90
91 // TODO: Slow. Should only be enabled if -stats is used.
92 if (R->isSimple())
93 ++numSimpleRegions;
94 }
95
recalculate(Function & F,DominatorTree * DT_,PostDominatorTree * PDT_,DominanceFrontier * DF_)96 void RegionInfo::recalculate(Function &F, DominatorTree *DT_,
97 PostDominatorTree *PDT_, DominanceFrontier *DF_) {
98 DT = DT_;
99 PDT = PDT_;
100 DF = DF_;
101
102 TopLevelRegion = new Region(&F.getEntryBlock(), nullptr,
103 this, DT, nullptr);
104 updateStatistics(TopLevelRegion);
105 calculate(F);
106 }
107
108 #ifndef NDEBUG
view()109 void RegionInfo::view() { viewRegion(this); }
110
viewOnly()111 void RegionInfo::viewOnly() { viewRegionOnly(this); }
112 #endif
113
114 //===----------------------------------------------------------------------===//
115 // RegionInfoPass implementation
116 //
117
RegionInfoPass()118 RegionInfoPass::RegionInfoPass() : FunctionPass(ID) {
119 initializeRegionInfoPassPass(*PassRegistry::getPassRegistry());
120 }
121
122 RegionInfoPass::~RegionInfoPass() = default;
123
runOnFunction(Function & F)124 bool RegionInfoPass::runOnFunction(Function &F) {
125 releaseMemory();
126
127 auto DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
128 auto PDT = &getAnalysis<PostDominatorTreeWrapperPass>().getPostDomTree();
129 auto DF = &getAnalysis<DominanceFrontierWrapperPass>().getDominanceFrontier();
130
131 RI.recalculate(F, DT, PDT, DF);
132 return false;
133 }
134
releaseMemory()135 void RegionInfoPass::releaseMemory() {
136 RI.releaseMemory();
137 }
138
verifyAnalysis() const139 void RegionInfoPass::verifyAnalysis() const {
140 RI.verifyAnalysis();
141 }
142
getAnalysisUsage(AnalysisUsage & AU) const143 void RegionInfoPass::getAnalysisUsage(AnalysisUsage &AU) const {
144 AU.setPreservesAll();
145 AU.addRequiredTransitive<DominatorTreeWrapperPass>();
146 AU.addRequired<PostDominatorTreeWrapperPass>();
147 AU.addRequired<DominanceFrontierWrapperPass>();
148 }
149
print(raw_ostream & OS,const Module *) const150 void RegionInfoPass::print(raw_ostream &OS, const Module *) const {
151 RI.print(OS);
152 }
153
154 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
dump() const155 LLVM_DUMP_METHOD void RegionInfoPass::dump() const {
156 RI.dump();
157 }
158 #endif
159
160 char RegionInfoPass::ID = 0;
161
162 INITIALIZE_PASS_BEGIN(RegionInfoPass, "regions",
163 "Detect single entry single exit regions", true, true)
164 INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
165 INITIALIZE_PASS_DEPENDENCY(PostDominatorTreeWrapperPass)
166 INITIALIZE_PASS_DEPENDENCY(DominanceFrontierWrapperPass)
167 INITIALIZE_PASS_END(RegionInfoPass, "regions",
168 "Detect single entry single exit regions", true, true)
169
170 // Create methods available outside of this file, to use them
171 // "include/llvm/LinkAllPasses.h". Otherwise the pass would be deleted by
172 // the link time optimization.
173
174 namespace llvm {
175
createRegionInfoPass()176 FunctionPass *createRegionInfoPass() {
177 return new RegionInfoPass();
178 }
179
180 } // end namespace llvm
181
182 //===----------------------------------------------------------------------===//
183 // RegionInfoAnalysis implementation
184 //
185
186 AnalysisKey RegionInfoAnalysis::Key;
187
run(Function & F,FunctionAnalysisManager & AM)188 RegionInfo RegionInfoAnalysis::run(Function &F, FunctionAnalysisManager &AM) {
189 RegionInfo RI;
190 auto *DT = &AM.getResult<DominatorTreeAnalysis>(F);
191 auto *PDT = &AM.getResult<PostDominatorTreeAnalysis>(F);
192 auto *DF = &AM.getResult<DominanceFrontierAnalysis>(F);
193
194 RI.recalculate(F, DT, PDT, DF);
195 return RI;
196 }
197
RegionInfoPrinterPass(raw_ostream & OS)198 RegionInfoPrinterPass::RegionInfoPrinterPass(raw_ostream &OS)
199 : OS(OS) {}
200
run(Function & F,FunctionAnalysisManager & AM)201 PreservedAnalyses RegionInfoPrinterPass::run(Function &F,
202 FunctionAnalysisManager &AM) {
203 OS << "Region Tree for function: " << F.getName() << "\n";
204 AM.getResult<RegionInfoAnalysis>(F).print(OS);
205
206 return PreservedAnalyses::all();
207 }
208
run(Function & F,FunctionAnalysisManager & AM)209 PreservedAnalyses RegionInfoVerifierPass::run(Function &F,
210 FunctionAnalysisManager &AM) {
211 AM.getResult<RegionInfoAnalysis>(F).verifyAnalysis();
212
213 return PreservedAnalyses::all();
214 }
215