LLVM  3.7.0
RegionPass.cpp
Go to the documentation of this file.
1 //===- RegionPass.cpp - Region Pass and Region Pass Manager ---------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file implements RegionPass and RGPassManager. All region optimization
11 // and transformation passes are derived from RegionPass. RGPassManager is
12 // responsible for managing RegionPasses.
13 // most of these codes are COPY from LoopPass.cpp
14 //
15 //===----------------------------------------------------------------------===//
18 #include "llvm/Support/Debug.h"
19 #include "llvm/Support/Timer.h"
21 using namespace llvm;
22 
23 #define DEBUG_TYPE "regionpassmgr"
24 
25 //===----------------------------------------------------------------------===//
26 // RGPassManager
27 //
28 
29 char RGPassManager::ID = 0;
30 
33  skipThisRegion = false;
34  redoThisRegion = false;
35  RI = nullptr;
36  CurrentRegion = nullptr;
37 }
38 
39 // Recurse through all subregions and all regions into RQ.
40 static void addRegionIntoQueue(Region &R, std::deque<Region *> &RQ) {
41  RQ.push_back(&R);
42  for (const auto &E : R)
43  addRegionIntoQueue(*E, RQ);
44 }
45 
46 /// Pass Manager itself does not invalidate any analysis info.
49  Info.setPreservesAll();
50 }
51 
52 /// run - Execute all of the passes scheduled for execution. Keep track of
53 /// whether any of the passes modifies the function, and if so, return true.
55  RI = &getAnalysis<RegionInfoPass>().getRegionInfo();
56  bool Changed = false;
57 
58  // Collect inherited analysis from Module level pass manager.
60 
62 
63  if (RQ.empty()) // No regions, skip calling finalizers
64  return false;
65 
66  // Initialization
67  for (std::deque<Region *>::const_iterator I = RQ.begin(), E = RQ.end();
68  I != E; ++I) {
69  Region *R = *I;
70  for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) {
72  Changed |= RP->doInitialization(R, *this);
73  }
74  }
75 
76  // Walk Regions
77  while (!RQ.empty()) {
78 
79  CurrentRegion = RQ.back();
80  skipThisRegion = false;
81  redoThisRegion = false;
82 
83  // Run all passes on the current Region.
84  for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) {
86 
89  CurrentRegion->getNameStr());
90  dumpRequiredSet(P);
91  }
92 
94 
95  {
96  PassManagerPrettyStackEntry X(P, *CurrentRegion->getEntry());
97 
98  TimeRegion PassTimer(getPassTimer(P));
99  Changed |= P->runOnRegion(CurrentRegion, *this);
100  }
101 
103  if (Changed)
105  skipThisRegion ? "<deleted>" :
106  CurrentRegion->getNameStr());
107  dumpPreservedSet(P);
108  }
109 
110  if (!skipThisRegion) {
111  // Manually check that this region is still healthy. This is done
112  // instead of relying on RegionInfo::verifyRegion since RegionInfo
113  // is a function pass and it's really expensive to verify every
114  // Region in the function every time. That level of checking can be
115  // enabled with the -verify-region-info option.
116  {
117  TimeRegion PassTimer(getPassTimer(P));
118  CurrentRegion->verifyRegion();
119  }
120 
121  // Then call the regular verifyAnalysis functions.
123  }
124 
128  (!isPassDebuggingExecutionsOrMore() || skipThisRegion) ?
129  "<deleted>" : CurrentRegion->getNameStr(),
130  ON_REGION_MSG);
131 
132  if (skipThisRegion)
133  // Do not run other passes on this region.
134  break;
135  }
136 
137  // If the region was deleted, release all the region passes. This frees up
138  // some memory, and avoids trouble with the pass manager trying to call
139  // verifyAnalysis on them.
140  if (skipThisRegion)
141  for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) {
142  Pass *P = getContainedPass(Index);
143  freePass(P, "<deleted>", ON_REGION_MSG);
144  }
145 
146  // Pop the region from queue after running all passes.
147  RQ.pop_back();
148 
149  if (redoThisRegion)
150  RQ.push_back(CurrentRegion);
151 
152  // Free all region nodes created in region passes.
153  RI->clearNodeCache();
154  }
155 
156  // Finalization
157  for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) {
159  Changed |= P->doFinalization();
160  }
161 
162  // Print the region tree after all pass.
163  DEBUG(
164  dbgs() << "\nRegion tree of function " << F.getName()
165  << " after all region Pass:\n";
166  RI->dump();
167  dbgs() << "\n";
168  );
169 
170  return Changed;
171 }
172 
173 /// Print passes managed by this manager
174 void RGPassManager::dumpPassStructure(unsigned Offset) {
175  errs().indent(Offset*2) << "Region Pass Manager\n";
176  for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) {
177  Pass *P = getContainedPass(Index);
178  P->dumpPassStructure(Offset + 1);
179  dumpLastUses(P, Offset+1);
180  }
181 }
182 
183 namespace {
184 //===----------------------------------------------------------------------===//
185 // PrintRegionPass
186 class PrintRegionPass : public RegionPass {
187 private:
188  std::string Banner;
189  raw_ostream &Out; // raw_ostream to print on.
190 
191 public:
192  static char ID;
193  PrintRegionPass(const std::string &B, raw_ostream &o)
194  : RegionPass(ID), Banner(B), Out(o) {}
195 
196  void getAnalysisUsage(AnalysisUsage &AU) const override {
197  AU.setPreservesAll();
198  }
199 
200  bool runOnRegion(Region *R, RGPassManager &RGM) override {
201  Out << Banner;
202  for (const auto *BB : R->blocks()) {
203  if (BB)
204  BB->print(Out);
205  else
206  Out << "Printing <null> Block";
207  }
208 
209  return false;
210  }
211 };
212 
213 char PrintRegionPass::ID = 0;
214 } //end anonymous namespace
215 
216 //===----------------------------------------------------------------------===//
217 // RegionPass
218 
219 // Check if this pass is suitable for the current RGPassManager, if
220 // available. This pass P is not suitable for a RGPassManager if P
221 // is not preserving higher level analysis info used by other
222 // RGPassManager passes. In such case, pop RGPassManager from the
223 // stack. This will force assignPassManager() to create new
224 // LPPassManger as expected.
226 
227  // Find RGPassManager
228  while (!PMS.empty() &&
230  PMS.pop();
231 
232 
233  // If this pass is destroying high level information that is used
234  // by other passes that are managed by LPM then do not insert
235  // this pass in current LPM. Use new RGPassManager.
236  if (PMS.top()->getPassManagerType() == PMT_RegionPassManager &&
237  !PMS.top()->preserveHigherLevelAnalysis(this))
238  PMS.pop();
239 }
240 
241 /// Assign pass manager to manage this pass.
243  PassManagerType PreferredType) {
244  // Find RGPassManager
245  while (!PMS.empty() &&
247  PMS.pop();
248 
249  RGPassManager *RGPM;
250 
251  // Create new Region Pass Manager if it does not exist.
253  RGPM = (RGPassManager*)PMS.top();
254  else {
255 
256  assert (!PMS.empty() && "Unable to create Region Pass Manager");
257  PMDataManager *PMD = PMS.top();
258 
259  // [1] Create new Region Pass Manager
260  RGPM = new RGPassManager();
261  RGPM->populateInheritedAnalysis(PMS);
262 
263  // [2] Set up new manager's top level manager
264  PMTopLevelManager *TPM = PMD->getTopLevelManager();
265  TPM->addIndirectPassManager(RGPM);
266 
267  // [3] Assign manager to manage this new manager. This may create
268  // and push new managers into PMS
269  TPM->schedulePass(RGPM);
270 
271  // [4] Push new manager into PMS
272  PMS.push(RGPM);
273  }
274 
275  RGPM->add(this);
276 }
277 
278 /// Get the printer pass
280  const std::string &Banner) const {
281  return new PrintRegionPass(Banner, O);
282 }
PMTopLevelManager * TPM
Pass interface - Implemented by all 'passes'.
Definition: Pass.h:82
bool preserveHigherLevelAnalysis(Pass *P)
PassManagerType
Different types of internal pass managers.
Definition: Pass.h:55
raw_ostream & errs()
This returns a reference to a raw_ostream for standard error.
std::string getNameStr() const
Returns the name of the Region.
void dumpLastUses(Pass *P, unsigned Offset) const
virtual void dumpPassStructure(unsigned Offset=0)
Definition: Pass.cpp:53
Pass * createPrinterPass(raw_ostream &O, const std::string &Banner) const override
Get a pass to print the LLVM IR in the region.
Definition: RegionPass.cpp:279
static void addRegionIntoQueue(Region &R, std::deque< Region * > &RQ)
Definition: RegionPass.cpp:40
raw_ostream & indent(unsigned NumSpaces)
indent - Insert 'NumSpaces' spaces.
void dumpRequiredSet(const Pass *P) const
F(f)
RegionT * getTopLevelRegion() const
Definition: RegionInfo.h:797
void dumpPassInfo(Pass *P, enum PassDebuggingString S1, enum PassDebuggingString S2, StringRef Msg)
The pass manager to schedule RegionPasses.
Definition: RegionPass.h:84
virtual PassManagerType getPassManagerType() const
PMTopLevelManager manages LastUser info and collects common APIs used by top level pass managers...
Timer * getPassTimer(Pass *)
If TimingInfo is enabled then start pass timer.
StringRef getName() const
Return a constant reference to the value's name.
Definition: Value.cpp:188
The TimeRegion class is used as a helper class to call the startTimer() and stopTimer() methods of th...
Definition: Timer.h:126
void schedulePass(Pass *P)
Schedule pass P for execution.
AnalysisUsage & addRequired()
void freePass(Pass *P, StringRef Msg, enum PassDebuggingString)
Remove P.
virtual bool doInitialization(Region *R, RGPassManager &RGM)
Definition: RegionPass.h:64
bool isPassDebuggingExecutionsOrMore() const
isPassDebuggingExecutionsOrMore - Return true if -debug-pass=Executions or higher is specified...
void verifyPreservedAnalysis(Pass *P)
verifyPreservedAnalysis – Verify analysis presreved by pass P.
void populateInheritedAnalysis(PMStack &PMS)
static char ID
Definition: RegionPass.h:92
block_range blocks()
Returns a range view of the basic blocks in the region.
Definition: RegionInfo.h:610
PMStack - This class implements a stack data structure of PMDataManager pointers. ...
void initializeAnalysisImpl(Pass *P)
All Required analyses should be available to the pass as it runs! Here we fill in the AnalysisImpls m...
PassManagerPrettyStackEntry - This is used to print informative information about what pass is runnin...
void add(Pass *P, bool ProcessAnalysis=true)
Add pass P into the PassVector.
unsigned getNumContainedPasses() const
virtual bool doFinalization()
Definition: RegionPass.h:65
void dumpPassStructure(unsigned Offset) override
Print passes managed by this manager.
Definition: RegionPass.cpp:174
#define P(N)
void assignPassManager(PMStack &PMS, PassManagerType PMT=PMT_RegionPassManager) override
Assign pass manager to manage this pass.
Definition: RegionPass.cpp:242
void preparePassManager(PMStack &PMS) override
Check if available pass managers are suitable for this pass or not.
Definition: RegionPass.cpp:225
void dumpPreservedSet(const Pass *P) const
A pass that runs on each Region in a function.
Definition: RegionPass.h:34
void addIndirectPassManager(PMDataManager *Manager)
Represent the analysis usage information of a pass.
bool runOnFunction(Function &F) override
Execute all of the passes scheduled for execution.
Definition: RegionPass.cpp:54
static GCMetadataPrinterRegistry::Add< ErlangGCPrinter > X("erlang","erlang-compatible garbage collector")
FunctionPass class - This class is used to implement most global optimizations.
Definition: Pass.h:294
Pass * getContainedPass(unsigned N)
Get passes contained by this manager.
Definition: RegionPass.h:115
bool empty() const
void recordAvailableAnalysis(Pass *P)
Augment AvailableAnalysis by adding analysis made available by pass P.
void removeNotPreservedAnalysis(Pass *P)
Remove Analysis that is not preserved by the pass.
void removeDeadPasses(Pass *P, StringRef Msg, enum PassDebuggingString)
Remove dead passes used by P.
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:123
PMDataManager * top() const
void setPreservesAll()
Set by analyses that do not transform their input at all.
#define I(x, y, z)
Definition: MD5.cpp:54
RGPassManager.
Definition: Pass.h:61
void verifyRegion() const
Verify if the region is a correct region.
virtual bool runOnRegion(Region *R, RGPassManager &RGM)=0
Run the pass on a specific Region.
void push(PMDataManager *PM)
PMDataManager provides the common place to manage the analysis data used by pass managers.
void clearNodeCache()
Clear the Node Cache for all Regions.
Definition: RegionInfo.h:808
BlockT * getEntry() const
Get the entry BasicBlock of the Region.
Definition: RegionInfo.h:315
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:38
#define DEBUG(X)
Definition: Debug.h:92
void getAnalysisUsage(AnalysisUsage &Info) const override
Pass Manager itself does not invalidate any analysis info.
Definition: RegionPass.cpp:47