1 //===- RegionPass.cpp - Region Pass and Region Pass Manager ---------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
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
15 //===----------------------------------------------------------------------===//
16 #include "llvm/Analysis/RegionPass.h"
17 #include "llvm/Analysis/RegionIterator.h"
18 #include "llvm/Support/Timer.h"
20 #include "llvm/Support/Debug.h"
23 #define DEBUG_TYPE "regionpassmgr"
25 //===----------------------------------------------------------------------===//
29 char RGPassManager::ID = 0;
31 RGPassManager::RGPassManager()
32 : FunctionPass(ID), PMDataManager() {
33 skipThisRegion = false;
34 redoThisRegion = false;
36 CurrentRegion = nullptr;
39 // Recurse through all subregions and all regions into RQ.
40 static void addRegionIntoQueue(Region &R, std::deque<Region *> &RQ) {
42 for (const auto &E : R)
43 addRegionIntoQueue(*E, RQ);
46 /// Pass Manager itself does not invalidate any analysis info.
47 void RGPassManager::getAnalysisUsage(AnalysisUsage &Info) const {
48 Info.addRequired<RegionInfoPass>();
49 Info.setPreservesAll();
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.
54 bool RGPassManager::runOnFunction(Function &F) {
55 RI = &getAnalysis<RegionInfoPass>().getRegionInfo();
58 // Collect inherited analysis from Module level pass manager.
59 populateInheritedAnalysis(TPM->activeStack);
61 addRegionIntoQueue(*RI->getTopLevelRegion(), RQ);
63 if (RQ.empty()) // No regions, skip calling finalizers
67 for (std::deque<Region *>::const_iterator I = RQ.begin(), E = RQ.end();
70 for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) {
71 RegionPass *RP = (RegionPass *)getContainedPass(Index);
72 Changed |= RP->doInitialization(R, *this);
79 CurrentRegion = RQ.back();
80 skipThisRegion = false;
81 redoThisRegion = false;
83 // Run all passes on the current Region.
84 for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) {
85 RegionPass *P = (RegionPass*)getContainedPass(Index);
87 dumpPassInfo(P, EXECUTION_MSG, ON_REGION_MSG,
88 CurrentRegion->getNameStr());
91 initializeAnalysisImpl(P);
94 PassManagerPrettyStackEntry X(P, *CurrentRegion->getEntry());
96 TimeRegion PassTimer(getPassTimer(P));
97 Changed |= P->runOnRegion(CurrentRegion, *this);
101 dumpPassInfo(P, MODIFICATION_MSG, ON_REGION_MSG,
102 skipThisRegion ? "<deleted>" :
103 CurrentRegion->getNameStr());
106 if (!skipThisRegion) {
107 // Manually check that this region is still healthy. This is done
108 // instead of relying on RegionInfo::verifyRegion since RegionInfo
109 // is a function pass and it's really expensive to verify every
110 // Region in the function every time. That level of checking can be
111 // enabled with the -verify-region-info option.
113 TimeRegion PassTimer(getPassTimer(P));
114 CurrentRegion->verifyRegion();
117 // Then call the regular verifyAnalysis functions.
118 verifyPreservedAnalysis(P);
121 removeNotPreservedAnalysis(P);
122 recordAvailableAnalysis(P);
124 skipThisRegion ? "<deleted>" :
125 CurrentRegion->getNameStr(),
129 // Do not run other passes on this region.
133 // If the region was deleted, release all the region passes. This frees up
134 // some memory, and avoids trouble with the pass manager trying to call
135 // verifyAnalysis on them.
137 for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) {
138 Pass *P = getContainedPass(Index);
139 freePass(P, "<deleted>", ON_REGION_MSG);
142 // Pop the region from queue after running all passes.
146 RQ.push_back(CurrentRegion);
148 // Free all region nodes created in region passes.
149 RI->clearNodeCache();
153 for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) {
154 RegionPass *P = (RegionPass*)getContainedPass(Index);
155 Changed |= P->doFinalization();
158 // Print the region tree after all pass.
160 dbgs() << "\nRegion tree of function " << F.getName()
161 << " after all region Pass:\n";
169 /// Print passes managed by this manager
170 void RGPassManager::dumpPassStructure(unsigned Offset) {
171 errs().indent(Offset*2) << "Region Pass Manager\n";
172 for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) {
173 Pass *P = getContainedPass(Index);
174 P->dumpPassStructure(Offset + 1);
175 dumpLastUses(P, Offset+1);
180 //===----------------------------------------------------------------------===//
182 class PrintRegionPass : public RegionPass {
185 raw_ostream &Out; // raw_ostream to print on.
189 PrintRegionPass(const std::string &B, raw_ostream &o)
190 : RegionPass(ID), Banner(B), Out(o) {}
192 void getAnalysisUsage(AnalysisUsage &AU) const override {
193 AU.setPreservesAll();
196 bool runOnRegion(Region *R, RGPassManager &RGM) override {
198 for (const auto &BB : R->blocks()) {
202 Out << "Printing <null> Block";
209 char PrintRegionPass::ID = 0;
210 } //end anonymous namespace
212 //===----------------------------------------------------------------------===//
215 // Check if this pass is suitable for the current RGPassManager, if
216 // available. This pass P is not suitable for a RGPassManager if P
217 // is not preserving higher level analysis info used by other
218 // RGPassManager passes. In such case, pop RGPassManager from the
219 // stack. This will force assignPassManager() to create new
220 // LPPassManger as expected.
221 void RegionPass::preparePassManager(PMStack &PMS) {
223 // Find RGPassManager
224 while (!PMS.empty() &&
225 PMS.top()->getPassManagerType() > PMT_RegionPassManager)
229 // If this pass is destroying high level information that is used
230 // by other passes that are managed by LPM then do not insert
231 // this pass in current LPM. Use new RGPassManager.
232 if (PMS.top()->getPassManagerType() == PMT_RegionPassManager &&
233 !PMS.top()->preserveHigherLevelAnalysis(this))
237 /// Assign pass manager to manage this pass.
238 void RegionPass::assignPassManager(PMStack &PMS,
239 PassManagerType PreferredType) {
240 // Find RGPassManager
241 while (!PMS.empty() &&
242 PMS.top()->getPassManagerType() > PMT_RegionPassManager)
247 // Create new Region Pass Manager if it does not exist.
248 if (PMS.top()->getPassManagerType() == PMT_RegionPassManager)
249 RGPM = (RGPassManager*)PMS.top();
252 assert (!PMS.empty() && "Unable to create Region Pass Manager");
253 PMDataManager *PMD = PMS.top();
255 // [1] Create new Region Pass Manager
256 RGPM = new RGPassManager();
257 RGPM->populateInheritedAnalysis(PMS);
259 // [2] Set up new manager's top level manager
260 PMTopLevelManager *TPM = PMD->getTopLevelManager();
261 TPM->addIndirectPassManager(RGPM);
263 // [3] Assign manager to manage this new manager. This may create
264 // and push new managers into PMS
265 TPM->schedulePass(RGPM);
267 // [4] Push new manager into PMS
274 /// Get the printer pass
275 Pass *RegionPass::createPrinterPass(raw_ostream &O,
276 const std::string &Banner) const {
277 return new PrintRegionPass(Banner, O);