PassManager.cpp revision c32cf54101ecaf336d161fecd58667870149169c
1c16257f05391b8aeccef62d6b543f1cb5a8185feChris Lattner//===- PassManager.cpp - LLVM Pass Infrastructure Implementation ----------===// 2b5f662fa0314f7e7e690aae8ebff7136cc3a5ab0Misha Brukman// 3f2ccb77ee9d8ab35866dae111fa36929689c7511Misha Brukman// The LLVM Compiler Infrastructure 4f2ccb77ee9d8ab35866dae111fa36929689c7511Misha Brukman// 54ee451de366474b9c228b4e5fa573795a715216dChris Lattner// This file was developed by Devang Patel and is distributed under 64ee451de366474b9c228b4e5fa573795a715216dChris Lattner// the University of Illinois Open Source License. See LICENSE.TXT for details. 7b5f662fa0314f7e7e690aae8ebff7136cc3a5ab0Misha Brukman// 8f2ccb77ee9d8ab35866dae111fa36929689c7511Misha Brukman//===----------------------------------------------------------------------===// 9f2ccb77ee9d8ab35866dae111fa36929689c7511Misha Brukman// 10f2ccb77ee9d8ab35866dae111fa36929689c7511Misha Brukman// This file implements the LLVM Pass Manager infrastructure. 11f2ccb77ee9d8ab35866dae111fa36929689c7511Misha Brukman// 12f2ccb77ee9d8ab35866dae111fa36929689c7511Misha Brukman//===----------------------------------------------------------------------===// 13f2ccb77ee9d8ab35866dae111fa36929689c7511Misha Brukman 14f2ccb77ee9d8ab35866dae111fa36929689c7511Misha Brukman 15f2ccb77ee9d8ab35866dae111fa36929689c7511Misha Brukman#include "llvm/PassManager.h" 16f2ccb77ee9d8ab35866dae111fa36929689c7511Misha Brukman#include "llvm/Support/CommandLine.h" 172668959b8879097db368aec7d76c455260abc75bChris Lattner#include "llvm/Module.h" 18617742b1b8b7fbb07b4ab5db7c292bff78d709f6Chris Lattner#include "llvm/ModuleProvider.h" 1916e71f2f70811c69c56052dd146324fe20e31db5Chris Lattner#include "llvm/Support/Streams.h" 20f2ccb77ee9d8ab35866dae111fa36929689c7511Misha Brukman#include <vector> 21f2ccb77ee9d8ab35866dae111fa36929689c7511Misha Brukman#include <map> 2288d211f82304e53694ece666d4a2507b170e4582Chris Lattnerusing namespace llvm; 2388d211f82304e53694ece666d4a2507b170e4582Chris Lattner 2488d211f82304e53694ece666d4a2507b170e4582Chris Lattner//===----------------------------------------------------------------------===// 2588d211f82304e53694ece666d4a2507b170e4582Chris Lattner// Overview: 2688d211f82304e53694ece666d4a2507b170e4582Chris Lattner// The Pass Manager Infrastructure manages passes. It's responsibilities are: 2788d211f82304e53694ece666d4a2507b170e4582Chris Lattner// 2888d211f82304e53694ece666d4a2507b170e4582Chris Lattner// o Manage optimization pass execution order 2988d211f82304e53694ece666d4a2507b170e4582Chris Lattner// o Make required Analysis information available before pass P is run 3088d211f82304e53694ece666d4a2507b170e4582Chris Lattner// o Release memory occupied by dead passes 3188d211f82304e53694ece666d4a2507b170e4582Chris Lattner// o If Analysis information is dirtied by a pass then regenerate Analysis 3288d211f82304e53694ece666d4a2507b170e4582Chris Lattner// information before it is consumed by another pass. 3388d211f82304e53694ece666d4a2507b170e4582Chris Lattner// 3488d211f82304e53694ece666d4a2507b170e4582Chris Lattner// Pass Manager Infrastructure uses multipe pass managers. They are PassManager, 3588d211f82304e53694ece666d4a2507b170e4582Chris Lattner// FunctionPassManager, ModulePassManager, BasicBlockPassManager. This class 3688d211f82304e53694ece666d4a2507b170e4582Chris Lattner// hierarcy uses multiple inheritance but pass managers do not derive from 3788d211f82304e53694ece666d4a2507b170e4582Chris Lattner// another pass manager. 3888d211f82304e53694ece666d4a2507b170e4582Chris Lattner// 3988d211f82304e53694ece666d4a2507b170e4582Chris Lattner// PassManager and FunctionPassManager are two top level pass manager that 40fd97734f3636f54a86890918096d3d692df0b939Chris Lattner// represents the external interface of this entire pass manager infrastucture. 41fd97734f3636f54a86890918096d3d692df0b939Chris Lattner// 42fd97734f3636f54a86890918096d3d692df0b939Chris Lattner// Important classes : 43fd97734f3636f54a86890918096d3d692df0b939Chris Lattner// 4488d211f82304e53694ece666d4a2507b170e4582Chris Lattner// [o] class PMTopLevelManager; 4588d211f82304e53694ece666d4a2507b170e4582Chris Lattner// 46fd97734f3636f54a86890918096d3d692df0b939Chris Lattner// Two top level managers, PassManager and FunctionPassManager, derive from 47d74ea2bbd8bb630331f35ead42d385249bd42af8Chris Lattner// PMTopLevelManager. PMTopLevelManager manages information used by top level 4888d211f82304e53694ece666d4a2507b170e4582Chris Lattner// managers such as last user info. 4988d211f82304e53694ece666d4a2507b170e4582Chris Lattner// 5088d211f82304e53694ece666d4a2507b170e4582Chris Lattner// [o] class PMDataManager; 5188d211f82304e53694ece666d4a2507b170e4582Chris Lattner// 5288d211f82304e53694ece666d4a2507b170e4582Chris Lattner// PMDataManager manages information, e.g. list of available analysis info, 5388d211f82304e53694ece666d4a2507b170e4582Chris Lattner// used by a pass manager to manage execution order of passes. It also provides 5488d211f82304e53694ece666d4a2507b170e4582Chris Lattner// a place to implement common pass manager APIs. All pass managers derive from 5588d211f82304e53694ece666d4a2507b170e4582Chris Lattner// PMDataManager. 5688d211f82304e53694ece666d4a2507b170e4582Chris Lattner// 5788d211f82304e53694ece666d4a2507b170e4582Chris Lattner// [o] class BasicBlockPassManager : public FunctionPass, public PMDataManager; 5888d211f82304e53694ece666d4a2507b170e4582Chris Lattner// 59d74ea2bbd8bb630331f35ead42d385249bd42af8Chris Lattner// BasicBlockPassManager manages BasicBlockPasses. 6088d211f82304e53694ece666d4a2507b170e4582Chris Lattner// 6188d211f82304e53694ece666d4a2507b170e4582Chris Lattner// [o] class FunctionPassManager; 6288d211f82304e53694ece666d4a2507b170e4582Chris Lattner// 63617742b1b8b7fbb07b4ab5db7c292bff78d709f6Chris Lattner// This is a external interface used by JIT to manage FunctionPasses. This 64641055225092833197efe8e5bce01d50bcf1daaeChris Lattner// interface relies on FunctionPassManagerImpl to do all the tasks. 65b1d26f66658cff3ceb7d44a72fbc8c8e975532f9Chris Lattner// 6621e463b2bf864671a87ebe386cb100ef9349a540Nate Begeman// [o] class FunctionPassManagerImpl : public ModulePass, PMDataManager, 674a66e9a57e679b4f3243bf2061daf53c70102030Bill Wendling// public PMTopLevelManager; 684a66e9a57e679b4f3243bf2061daf53c70102030Bill Wendling// 694a66e9a57e679b4f3243bf2061daf53c70102030Bill Wendling// FunctionPassManagerImpl is a top level manager. It manages FunctionPasses 704a66e9a57e679b4f3243bf2061daf53c70102030Bill Wendling// and BasicBlockPassManagers. 714a66e9a57e679b4f3243bf2061daf53c70102030Bill Wendling// 724a66e9a57e679b4f3243bf2061daf53c70102030Bill Wendling// [o] class ModulePassManager : public Pass, public PMDataManager; 734a66e9a57e679b4f3243bf2061daf53c70102030Bill Wendling// 74f2ccb77ee9d8ab35866dae111fa36929689c7511Misha Brukman// ModulePassManager manages ModulePasses and FunctionPassManagerImpls. 75b1d26f66658cff3ceb7d44a72fbc8c8e975532f9Chris Lattner// 76f2ccb77ee9d8ab35866dae111fa36929689c7511Misha Brukman// [o] class PassManager; 77f2ccb77ee9d8ab35866dae111fa36929689c7511Misha Brukman// 78f2ccb77ee9d8ab35866dae111fa36929689c7511Misha Brukman// This is a external interface used by various tools to manages passes. It 79f2ccb77ee9d8ab35866dae111fa36929689c7511Misha Brukman// relies on PassManagerImpl to do all the tasks. 80f2ccb77ee9d8ab35866dae111fa36929689c7511Misha Brukman// 816f0d024a534af18d9e60b3ea757376cd8a3a980eDan Gohman// [o] class PassManagerImpl : public Pass, public PMDataManager, 82f2ccb77ee9d8ab35866dae111fa36929689c7511Misha Brukman// public PMDTopLevelManager 83b1d26f66658cff3ceb7d44a72fbc8c8e975532f9Chris Lattner// 84b1d26f66658cff3ceb7d44a72fbc8c8e975532f9Chris Lattner// PassManagerImpl is a top level pass manager responsible for managing 85b1d26f66658cff3ceb7d44a72fbc8c8e975532f9Chris Lattner// ModulePassManagers. 86b1d26f66658cff3ceb7d44a72fbc8c8e975532f9Chris Lattner//===----------------------------------------------------------------------===// 87f2ccb77ee9d8ab35866dae111fa36929689c7511Misha Brukman 88f2ccb77ee9d8ab35866dae111fa36929689c7511Misha Brukmannamespace llvm { 89f2ccb77ee9d8ab35866dae111fa36929689c7511Misha Brukman 90f2ccb77ee9d8ab35866dae111fa36929689c7511Misha Brukman//===----------------------------------------------------------------------===// 91f2ccb77ee9d8ab35866dae111fa36929689c7511Misha Brukman// Pass debugging information. Often it is useful to find out what pass is 92f2ccb77ee9d8ab35866dae111fa36929689c7511Misha Brukman// running when a crash occurs in a utility. When this library is compiled with 93f2ccb77ee9d8ab35866dae111fa36929689c7511Misha Brukman// debugging on, a command line option (--debug-pass) is enabled that causes the 94408396014742a05cad1c91949d2226169e3f9d80Chris Lattner// pass name to be printed before it executes. 956524287c53cf727a8ef33517403fcb1bbd7adff9Chris Lattner// 96408396014742a05cad1c91949d2226169e3f9d80Chris Lattner 97043870dd85ea41e8972c304b122070a417c8a4bcChris Lattner// Different debug levels that can be enabled... 98043870dd85ea41e8972c304b122070a417c8a4bcChris Lattnerenum PassDebugLevel { 99043870dd85ea41e8972c304b122070a417c8a4bcChris Lattner None, Arguments, Structure, Executions, Details 100043870dd85ea41e8972c304b122070a417c8a4bcChris Lattner}; 101bbf1c72d51a77bf54c9c684b90a78e59f0b70b2fChris Lattner 102bbf1c72d51a77bf54c9c684b90a78e59f0b70b2fChris Lattnerstatic cl::opt<enum PassDebugLevel> 103bbf1c72d51a77bf54c9c684b90a78e59f0b70b2fChris LattnerPassDebugging_New("debug-pass", cl::Hidden, 104c50e2bcdf7bff1f9681ab80e52691f274950fab5Chris Lattner cl::desc("Print PassManager debugging information"), 105c50e2bcdf7bff1f9681ab80e52691f274950fab5Chris Lattner cl::values( 106c50e2bcdf7bff1f9681ab80e52691f274950fab5Chris Lattner clEnumVal(None , "disable debug output"), 107c50e2bcdf7bff1f9681ab80e52691f274950fab5Chris Lattner clEnumVal(Arguments , "print pass arguments to pass to 'opt'"), 108c50e2bcdf7bff1f9681ab80e52691f274950fab5Chris Lattner clEnumVal(Structure , "print pass structure before run()"), 109b5cdaa257e167a08a8a54ea9249d847ccc415ce0Evan Cheng clEnumVal(Executions, "print pass name before it is executed"), 110b5cdaa257e167a08a8a54ea9249d847ccc415ce0Evan Cheng clEnumVal(Details , "print pass details when it is executed"), 111b5cdaa257e167a08a8a54ea9249d847ccc415ce0Evan Cheng clEnumValEnd)); 112b5cdaa257e167a08a8a54ea9249d847ccc415ce0Evan Cheng} // End of llvm namespace 113f6372aa1cc568df19da7c5023e83c75aa9404a07Owen Anderson 114f6372aa1cc568df19da7c5023e83c75aa9404a07Owen Anderson#ifndef USE_OLD_PASSMANAGER 115f6372aa1cc568df19da7c5023e83c75aa9404a07Owen Andersonnamespace llvm { 116f6372aa1cc568df19da7c5023e83c75aa9404a07Owen Anderson 117f6372aa1cc568df19da7c5023e83c75aa9404a07Owen Andersonclass PMDataManager; 118f6372aa1cc568df19da7c5023e83c75aa9404a07Owen Anderson 119f6372aa1cc568df19da7c5023e83c75aa9404a07Owen Anderson//===----------------------------------------------------------------------===// 120f6372aa1cc568df19da7c5023e83c75aa9404a07Owen Anderson// PMTopLevelManager 121f6372aa1cc568df19da7c5023e83c75aa9404a07Owen Anderson// 122f6372aa1cc568df19da7c5023e83c75aa9404a07Owen Anderson/// PMTopLevelManager manages LastUser info and collects common APIs used by 123f6372aa1cc568df19da7c5023e83c75aa9404a07Owen Anderson/// top level pass managers. 124f6372aa1cc568df19da7c5023e83c75aa9404a07Owen Andersonclass PMTopLevelManager { 125f6372aa1cc568df19da7c5023e83c75aa9404a07Owen Anderson 126f6372aa1cc568df19da7c5023e83c75aa9404a07Owen Andersonpublic: 127f6372aa1cc568df19da7c5023e83c75aa9404a07Owen Anderson 128f6372aa1cc568df19da7c5023e83c75aa9404a07Owen Anderson inline std::vector<Pass *>::iterator passManagersBegin() { 129f6372aa1cc568df19da7c5023e83c75aa9404a07Owen Anderson return PassManagers.begin(); 130f6372aa1cc568df19da7c5023e83c75aa9404a07Owen Anderson } 131f6372aa1cc568df19da7c5023e83c75aa9404a07Owen Anderson 132f6372aa1cc568df19da7c5023e83c75aa9404a07Owen Anderson inline std::vector<Pass *>::iterator passManagersEnd() { 133f6372aa1cc568df19da7c5023e83c75aa9404a07Owen Anderson return PassManagers.end(); 134f6372aa1cc568df19da7c5023e83c75aa9404a07Owen Anderson } 135f6372aa1cc568df19da7c5023e83c75aa9404a07Owen Anderson 136f6372aa1cc568df19da7c5023e83c75aa9404a07Owen Anderson /// Schedule pass P for execution. Make sure that passes required by 137f6372aa1cc568df19da7c5023e83c75aa9404a07Owen Anderson /// P are run before P is run. Update analysis info maintained by 138f6372aa1cc568df19da7c5023e83c75aa9404a07Owen Anderson /// the manager. Remove dead passes. This is a recursive function. 13943dbe05279b753aabda571d9c83eaeb36987001aOwen Anderson void schedulePass(Pass *P); 14043dbe05279b753aabda571d9c83eaeb36987001aOwen Anderson 1415fd79d0560570fed977788a86fa038b898564dfaEvan Cheng /// This is implemented by top level pass manager and used by 1425fd79d0560570fed977788a86fa038b898564dfaEvan Cheng /// schedulePass() to add analysis info passes that are not available. 14343dbe05279b753aabda571d9c83eaeb36987001aOwen Anderson virtual void addTopLevelPass(Pass *P) = 0; 14443dbe05279b753aabda571d9c83eaeb36987001aOwen Anderson 14543dbe05279b753aabda571d9c83eaeb36987001aOwen Anderson /// Set pass P as the last user of the given analysis passes. 1465fd79d0560570fed977788a86fa038b898564dfaEvan Cheng void setLastUser(std::vector<Pass *> &AnalysisPasses, Pass *P); 1475fd79d0560570fed977788a86fa038b898564dfaEvan Cheng 14843dbe05279b753aabda571d9c83eaeb36987001aOwen Anderson /// Collect passes whose last user is P 14943dbe05279b753aabda571d9c83eaeb36987001aOwen Anderson void collectLastUses(std::vector<Pass *> &LastUses, Pass *P); 15043dbe05279b753aabda571d9c83eaeb36987001aOwen Anderson 15143dbe05279b753aabda571d9c83eaeb36987001aOwen Anderson /// Find the pass that implements Analysis AID. Search immutable 15243dbe05279b753aabda571d9c83eaeb36987001aOwen Anderson /// passes and all pass managers. If desired pass is not found 15343dbe05279b753aabda571d9c83eaeb36987001aOwen Anderson /// then return NULL. 15443dbe05279b753aabda571d9c83eaeb36987001aOwen Anderson Pass *findAnalysisPass(AnalysisID AID); 15543dbe05279b753aabda571d9c83eaeb36987001aOwen Anderson 156ef13982aa7f3e57e82cd48370e79033dff0da295Chris Lattner inline void clearManagers() { 157c50e2bcdf7bff1f9681ab80e52691f274950fab5Chris Lattner PassManagers.clear(); 158f2ccb77ee9d8ab35866dae111fa36929689c7511Misha Brukman } 159f2ccb77ee9d8ab35866dae111fa36929689c7511Misha Brukman 160f2ccb77ee9d8ab35866dae111fa36929689c7511Misha Brukman virtual ~PMTopLevelManager() { 161f2ccb77ee9d8ab35866dae111fa36929689c7511Misha Brukman 162f2ccb77ee9d8ab35866dae111fa36929689c7511Misha Brukman for (std::vector<Pass *>::iterator I = PassManagers.begin(), 163 E = PassManagers.end(); I != E; ++I) 164 delete *I; 165 166 for (std::vector<ImmutablePass *>::iterator 167 I = ImmutablePasses.begin(), E = ImmutablePasses.end(); I != E; ++I) 168 delete *I; 169 170 PassManagers.clear(); 171 } 172 173 /// Add immutable pass and initialize it. 174 inline void addImmutablePass(ImmutablePass *P) { 175 P->initializePass(); 176 ImmutablePasses.push_back(P); 177 } 178 179 inline std::vector<ImmutablePass *>& getImmutablePasses() { 180 return ImmutablePasses; 181 } 182 183 void addPassManager(Pass *Manager) { 184 PassManagers.push_back(Manager); 185 } 186 187 // Add Manager into the list of managers that are not directly 188 // maintained by this top level pass manager 189 inline void addIndirectPassManager(PMDataManager *Manager) { 190 IndirectPassManagers.push_back(Manager); 191 } 192 193 // Print passes managed by this top level manager. 194 void dumpPasses(); 195 void dumpArguments(); 196 197private: 198 199 /// Collection of pass managers 200 std::vector<Pass *> PassManagers; 201 202 /// Collection of pass managers that are not directly maintained 203 /// by this pass manager 204 std::vector<PMDataManager *> IndirectPassManagers; 205 206 // Map to keep track of last user of the analysis pass. 207 // LastUser->second is the last user of Lastuser->first. 208 std::map<Pass *, Pass *> LastUser; 209 210 /// Immutable passes are managed by top level manager. 211 std::vector<ImmutablePass *> ImmutablePasses; 212}; 213 214//===----------------------------------------------------------------------===// 215// PMDataManager 216 217/// PMDataManager provides the common place to manage the analysis data 218/// used by pass managers. 219class PMDataManager { 220 221public: 222 223 PMDataManager(int D) : TPM(NULL), Depth(D) { 224 initializeAnalysisInfo(); 225 } 226 227 virtual ~PMDataManager() { 228 229 for (std::vector<Pass *>::iterator I = PassVector.begin(), 230 E = PassVector.end(); I != E; ++I) 231 delete *I; 232 233 PassVector.clear(); 234 } 235 236 /// Return true IFF pass P's required analysis set does not required new 237 /// manager. 238 bool manageablePass(Pass *P); 239 240 /// Augment AvailableAnalysis by adding analysis made available by pass P. 241 void recordAvailableAnalysis(Pass *P); 242 243 /// Remove Analysis that is not preserved by the pass 244 void removeNotPreservedAnalysis(Pass *P); 245 246 /// Remove dead passes 247 void removeDeadPasses(Pass *P); 248 249 /// Add pass P into the PassVector. Update 250 /// AvailableAnalysis appropriately if ProcessAnalysis is true. 251 void addPassToManager (Pass *P, bool ProcessAnalysis = true); 252 253 /// Initialize available analysis information. 254 void initializeAnalysisInfo() { 255 ForcedLastUses.clear(); 256 AvailableAnalysis.clear(); 257 } 258 259 /// Populate RequiredPasses with the analysis pass that are required by 260 /// pass P. 261 void collectRequiredAnalysisPasses(std::vector<Pass *> &RequiredPasses, 262 Pass *P); 263 264 /// All Required analyses should be available to the pass as it runs! Here 265 /// we fill in the AnalysisImpls member of the pass so that it can 266 /// successfully use the getAnalysis() method to retrieve the 267 /// implementations it needs. 268 void initializeAnalysisImpl(Pass *P); 269 270 /// Find the pass that implements Analysis AID. If desired pass is not found 271 /// then return NULL. 272 Pass *findAnalysisPass(AnalysisID AID, bool Direction); 273 274 inline std::vector<Pass *>::iterator passVectorBegin() { 275 return PassVector.begin(); 276 } 277 278 inline std::vector<Pass *>::iterator passVectorEnd() { 279 return PassVector.end(); 280 } 281 282 // Access toplevel manager 283 PMTopLevelManager *getTopLevelManager() { return TPM; } 284 void setTopLevelManager(PMTopLevelManager *T) { TPM = T; } 285 286 unsigned getDepth() { return Depth; } 287 288 // Print list of passes that are last used by P. 289 void dumpLastUses(Pass *P, unsigned Offset) { 290 291 std::vector<Pass *> LUses; 292 293 assert (TPM && "Top Level Manager is missing"); 294 TPM->collectLastUses(LUses, P); 295 296 for (std::vector<Pass *>::iterator I = LUses.begin(), 297 E = LUses.end(); I != E; ++I) { 298 llvm::cerr << "--" << std::string(Offset*2, ' '); 299 (*I)->dumpPassStructure(0); 300 } 301 } 302 303 void dumpPassArguments() { 304 for(std::vector<Pass *>::iterator I = PassVector.begin(), 305 E = PassVector.end(); I != E; ++I) { 306 if (PMDataManager *PMD = dynamic_cast<PMDataManager *>(*I)) 307 PMD->dumpPassArguments(); 308 else 309 if (const PassInfo *PI = (*I)->getPassInfo()) 310 if (!PI->isAnalysisGroup()) 311 cerr << " -" << PI->getPassArgument(); 312 } 313 } 314 315protected: 316 317 // Collection of pass whose last user asked this manager to claim 318 // last use. If a FunctionPass F is the last user of ModulePass info M 319 // then the F's manager, not F, records itself as a last user of M. 320 std::vector<Pass *> ForcedLastUses; 321 322 // Top level manager. 323 PMTopLevelManager *TPM; 324 325private: 326 // Set of available Analysis. This information is used while scheduling 327 // pass. If a pass requires an analysis which is not not available then 328 // equired analysis pass is scheduled to run before the pass itself is 329 // scheduled to run. 330 std::map<AnalysisID, Pass*> AvailableAnalysis; 331 332 // Collection of pass that are managed by this manager 333 std::vector<Pass *> PassVector; 334 335 unsigned Depth; 336}; 337 338//===----------------------------------------------------------------------===// 339// BasicBlockPassManager 340// 341/// BasicBlockPassManager manages BasicBlockPass. It batches all the 342/// pass together and sequence them to process one basic block before 343/// processing next basic block. 344class BasicBlockPassManager : public PMDataManager, 345 public FunctionPass { 346 347public: 348 BasicBlockPassManager(int D) : PMDataManager(D) { } 349 350 /// Add a pass into a passmanager queue. 351 bool addPass(Pass *p); 352 353 /// Execute all of the passes scheduled for execution. Keep track of 354 /// whether any of the passes modifies the function, and if so, return true. 355 bool runOnFunction(Function &F); 356 357 /// Pass Manager itself does not invalidate any analysis info. 358 void getAnalysisUsage(AnalysisUsage &Info) const { 359 Info.setPreservesAll(); 360 } 361 362 bool doInitialization(Module &M); 363 bool doInitialization(Function &F); 364 bool doFinalization(Module &M); 365 bool doFinalization(Function &F); 366 367 // Print passes managed by this manager 368 void dumpPassStructure(unsigned Offset) { 369 llvm::cerr << std::string(Offset*2, ' ') << "BasicBLockPass Manager\n"; 370 for (std::vector<Pass *>::iterator I = passVectorBegin(), 371 E = passVectorEnd(); I != E; ++I) { 372 (*I)->dumpPassStructure(Offset + 1); 373 dumpLastUses(*I, Offset+1); 374 } 375 } 376}; 377 378//===----------------------------------------------------------------------===// 379// FunctionPassManagerImpl_New 380// 381/// FunctionPassManagerImpl_New manages FunctionPasses and 382/// BasicBlockPassManagers. It batches all function passes and basic block pass 383/// managers together and sequence them to process one function at a time before 384/// processing next function. 385class FunctionPassManagerImpl_New : public ModulePass, 386 public PMDataManager, 387 public PMTopLevelManager { 388public: 389 FunctionPassManagerImpl_New(int D) : PMDataManager(D) { 390 activeBBPassManager = NULL; 391 } 392 ~FunctionPassManagerImpl_New() { /* TODO */ }; 393 394 inline void addTopLevelPass(Pass *P) { 395 396 if (ImmutablePass *IP = dynamic_cast<ImmutablePass *> (P)) { 397 398 // P is a immutable pass then it will be managed by this 399 // top level manager. Set up analysis resolver to connect them. 400 AnalysisResolver_New *AR = new AnalysisResolver_New(*this); 401 P->setResolver(AR); 402 initializeAnalysisImpl(P); 403 addImmutablePass(IP); 404 recordAvailableAnalysis(IP); 405 } 406 else 407 addPass(P); 408 } 409 410 /// add - Add a pass to the queue of passes to run. This passes 411 /// ownership of the Pass to the PassManager. When the 412 /// PassManager_X is destroyed, the pass will be destroyed as well, so 413 /// there is no need to delete the pass. (TODO delete passes.) 414 /// This implies that all passes MUST be allocated with 'new'. 415 void add(Pass *P) { 416 schedulePass(P); 417 } 418 419 /// Add pass into the pass manager queue. 420 bool addPass(Pass *P); 421 422 /// Execute all of the passes scheduled for execution. Keep 423 /// track of whether any of the passes modifies the function, and if 424 /// so, return true. 425 bool runOnModule(Module &M); 426 bool runOnFunction(Function &F); 427 bool run(Function &F); 428 429 /// doInitialization - Run all of the initializers for the function passes. 430 /// 431 bool doInitialization(Module &M); 432 433 /// doFinalization - Run all of the initializers for the function passes. 434 /// 435 bool doFinalization(Module &M); 436 437 /// Pass Manager itself does not invalidate any analysis info. 438 void getAnalysisUsage(AnalysisUsage &Info) const { 439 Info.setPreservesAll(); 440 } 441 442 // Print passes managed by this manager 443 void dumpPassStructure(unsigned Offset) { 444 llvm::cerr << std::string(Offset*2, ' ') << "FunctionPass Manager\n"; 445 for (std::vector<Pass *>::iterator I = passVectorBegin(), 446 E = passVectorEnd(); I != E; ++I) { 447 (*I)->dumpPassStructure(Offset + 1); 448 dumpLastUses(*I, Offset+1); 449 } 450 } 451 452private: 453 // Active Pass Managers 454 BasicBlockPassManager *activeBBPassManager; 455}; 456 457//===----------------------------------------------------------------------===// 458// ModulePassManager 459// 460/// ModulePassManager manages ModulePasses and function pass managers. 461/// It batches all Module passes passes and function pass managers together and 462/// sequence them to process one module. 463class ModulePassManager : public Pass, 464 public PMDataManager { 465 466public: 467 ModulePassManager(int D) : PMDataManager(D) { 468 activeFunctionPassManager = NULL; 469 } 470 471 /// Add a pass into a passmanager queue. 472 bool addPass(Pass *p); 473 474 /// run - Execute all of the passes scheduled for execution. Keep track of 475 /// whether any of the passes modifies the module, and if so, return true. 476 bool runOnModule(Module &M); 477 478 /// Pass Manager itself does not invalidate any analysis info. 479 void getAnalysisUsage(AnalysisUsage &Info) const { 480 Info.setPreservesAll(); 481 } 482 483 // Print passes managed by this manager 484 void dumpPassStructure(unsigned Offset) { 485 llvm::cerr << std::string(Offset*2, ' ') << "ModulePass Manager\n"; 486 for (std::vector<Pass *>::iterator I = passVectorBegin(), 487 E = passVectorEnd(); I != E; ++I) { 488 (*I)->dumpPassStructure(Offset + 1); 489 dumpLastUses(*I, Offset+1); 490 } 491 } 492 493private: 494 // Active Pass Manager 495 FunctionPassManagerImpl_New *activeFunctionPassManager; 496}; 497 498//===----------------------------------------------------------------------===// 499// PassManagerImpl_New 500// 501/// PassManagerImpl_New manages ModulePassManagers 502class PassManagerImpl_New : public Pass, 503 public PMDataManager, 504 public PMTopLevelManager { 505 506public: 507 508 PassManagerImpl_New(int D) : PMDataManager(D) { 509 activeManager = NULL; 510 } 511 512 /// add - Add a pass to the queue of passes to run. This passes ownership of 513 /// the Pass to the PassManager. When the PassManager is destroyed, the pass 514 /// will be destroyed as well, so there is no need to delete the pass. This 515 /// implies that all passes MUST be allocated with 'new'. 516 void add(Pass *P) { 517 schedulePass(P); 518 } 519 520 /// run - Execute all of the passes scheduled for execution. Keep track of 521 /// whether any of the passes modifies the module, and if so, return true. 522 bool run(Module &M); 523 524 /// Pass Manager itself does not invalidate any analysis info. 525 void getAnalysisUsage(AnalysisUsage &Info) const { 526 Info.setPreservesAll(); 527 } 528 529 inline void addTopLevelPass(Pass *P) { 530 531 if (ImmutablePass *IP = dynamic_cast<ImmutablePass *> (P)) { 532 533 // P is a immutable pass and it will be managed by this 534 // top level manager. Set up analysis resolver to connect them. 535 AnalysisResolver_New *AR = new AnalysisResolver_New(*this); 536 P->setResolver(AR); 537 initializeAnalysisImpl(P); 538 addImmutablePass(IP); 539 recordAvailableAnalysis(IP); 540 } 541 else 542 addPass(P); 543 } 544 545private: 546 547 /// Add a pass into a passmanager queue. 548 bool addPass(Pass *p); 549 550 // Active Pass Manager 551 ModulePassManager *activeManager; 552}; 553 554} // End of llvm namespace 555 556//===----------------------------------------------------------------------===// 557// PMTopLevelManager implementation 558 559/// Set pass P as the last user of the given analysis passes. 560void PMTopLevelManager::setLastUser(std::vector<Pass *> &AnalysisPasses, 561 Pass *P) { 562 563 for (std::vector<Pass *>::iterator I = AnalysisPasses.begin(), 564 E = AnalysisPasses.end(); I != E; ++I) { 565 Pass *AP = *I; 566 LastUser[AP] = P; 567 // If AP is the last user of other passes then make P last user of 568 // such passes. 569 for (std::map<Pass *, Pass *>::iterator LUI = LastUser.begin(), 570 LUE = LastUser.end(); LUI != LUE; ++LUI) { 571 if (LUI->second == AP) 572 LastUser[LUI->first] = P; 573 } 574 } 575 576} 577 578/// Collect passes whose last user is P 579void PMTopLevelManager::collectLastUses(std::vector<Pass *> &LastUses, 580 Pass *P) { 581 for (std::map<Pass *, Pass *>::iterator LUI = LastUser.begin(), 582 LUE = LastUser.end(); LUI != LUE; ++LUI) 583 if (LUI->second == P) 584 LastUses.push_back(LUI->first); 585} 586 587/// Schedule pass P for execution. Make sure that passes required by 588/// P are run before P is run. Update analysis info maintained by 589/// the manager. Remove dead passes. This is a recursive function. 590void PMTopLevelManager::schedulePass(Pass *P) { 591 592 // TODO : Allocate function manager for this pass, other wise required set 593 // may be inserted into previous function manager 594 595 AnalysisUsage AnUsage; 596 P->getAnalysisUsage(AnUsage); 597 const std::vector<AnalysisID> &RequiredSet = AnUsage.getRequiredSet(); 598 for (std::vector<AnalysisID>::const_iterator I = RequiredSet.begin(), 599 E = RequiredSet.end(); I != E; ++I) { 600 601 Pass *AnalysisPass = findAnalysisPass(*I); 602 if (!AnalysisPass) { 603 // Schedule this analysis run first. 604 AnalysisPass = (*I)->createPass(); 605 schedulePass(AnalysisPass); 606 } 607 } 608 609 // Now all required passes are available. 610 addTopLevelPass(P); 611} 612 613/// Find the pass that implements Analysis AID. Search immutable 614/// passes and all pass managers. If desired pass is not found 615/// then return NULL. 616Pass *PMTopLevelManager::findAnalysisPass(AnalysisID AID) { 617 618 Pass *P = NULL; 619 // Check pass managers 620 for (std::vector<Pass *>::iterator I = PassManagers.begin(), 621 E = PassManagers.end(); P == NULL && I != E; ++I) { 622 PMDataManager *PMD = dynamic_cast<PMDataManager *>(*I); 623 assert(PMD && "This is not a PassManager"); 624 P = PMD->findAnalysisPass(AID, false); 625 } 626 627 // Check other pass managers 628 for (std::vector<PMDataManager *>::iterator I = IndirectPassManagers.begin(), 629 E = IndirectPassManagers.end(); P == NULL && I != E; ++I) 630 P = (*I)->findAnalysisPass(AID, false); 631 632 for (std::vector<ImmutablePass *>::iterator I = ImmutablePasses.begin(), 633 E = ImmutablePasses.end(); P == NULL && I != E; ++I) { 634 const PassInfo *PI = (*I)->getPassInfo(); 635 if (PI == AID) 636 P = *I; 637 638 // If Pass not found then check the interfaces implemented by Immutable Pass 639 if (!P) { 640 const std::vector<const PassInfo*> &ImmPI = 641 PI->getInterfacesImplemented(); 642 for (unsigned Index = 0, End = ImmPI.size(); 643 P == NULL && Index != End; ++Index) 644 if (ImmPI[Index] == AID) 645 P = *I; 646 } 647 } 648 649 return P; 650} 651 652// Print passes managed by this top level manager. 653void PMTopLevelManager::dumpPasses() { 654 655 // Print out the immutable passes 656 for (unsigned i = 0, e = ImmutablePasses.size(); i != e; ++i) { 657 ImmutablePasses[i]->dumpPassStructure(0); 658 } 659 660 for (std::vector<Pass *>::iterator I = PassManagers.begin(), 661 E = PassManagers.end(); I != E; ++I) 662 (*I)->dumpPassStructure(1); 663 664} 665 666void PMTopLevelManager::dumpArguments() { 667 668 if (PassDebugging_New < Arguments) 669 return; 670 671 cerr << "Pass Arguments: "; 672 for (std::vector<Pass *>::iterator I = PassManagers.begin(), 673 E = PassManagers.end(); I != E; ++I) { 674 PMDataManager *PMD = dynamic_cast<PMDataManager *>(*I); 675 assert(PMD && "This is not a PassManager"); 676 PMD->dumpPassArguments(); 677 } 678 cerr << "\n"; 679} 680 681//===----------------------------------------------------------------------===// 682// PMDataManager implementation 683 684/// Return true IFF pass P's required analysis set does not required new 685/// manager. 686bool PMDataManager::manageablePass(Pass *P) { 687 688 // TODO 689 // If this pass is not preserving information that is required by a 690 // pass maintained by higher level pass manager then do not insert 691 // this pass into current manager. Use new manager. For example, 692 // For example, If FunctionPass F is not preserving ModulePass Info M1 693 // that is used by another ModulePass M2 then do not insert F in 694 // current function pass manager. 695 return true; 696} 697 698/// Augement AvailableAnalysis by adding analysis made available by pass P. 699void PMDataManager::recordAvailableAnalysis(Pass *P) { 700 701 if (const PassInfo *PI = P->getPassInfo()) { 702 AvailableAnalysis[PI] = P; 703 704 //This pass is the current implementation of all of the interfaces it 705 //implements as well. 706 const std::vector<const PassInfo*> &II = PI->getInterfacesImplemented(); 707 for (unsigned i = 0, e = II.size(); i != e; ++i) 708 AvailableAnalysis[II[i]] = P; 709 } 710} 711 712/// Remove Analyss not preserved by Pass P 713void PMDataManager::removeNotPreservedAnalysis(Pass *P) { 714 AnalysisUsage AnUsage; 715 P->getAnalysisUsage(AnUsage); 716 717 if (AnUsage.getPreservesAll()) 718 return; 719 720 const std::vector<AnalysisID> &PreservedSet = AnUsage.getPreservedSet(); 721 for (std::map<AnalysisID, Pass*>::iterator I = AvailableAnalysis.begin(), 722 E = AvailableAnalysis.end(); I != E; ) { 723 if (std::find(PreservedSet.begin(), PreservedSet.end(), I->first) == 724 PreservedSet.end()) { 725 // Remove this analysis 726 if (!dynamic_cast<ImmutablePass*>(I->second)) { 727 std::map<AnalysisID, Pass*>::iterator J = I++; 728 AvailableAnalysis.erase(J); 729 } else 730 ++I; 731 } else 732 ++I; 733 } 734} 735 736/// Remove analysis passes that are not used any longer 737void PMDataManager::removeDeadPasses(Pass *P) { 738 739 std::vector<Pass *> DeadPasses; 740 TPM->collectLastUses(DeadPasses, P); 741 742 for (std::vector<Pass *>::iterator I = DeadPasses.begin(), 743 E = DeadPasses.end(); I != E; ++I) { 744 (*I)->releaseMemory(); 745 746 std::map<AnalysisID, Pass*>::iterator Pos = 747 AvailableAnalysis.find((*I)->getPassInfo()); 748 749 // It is possible that pass is already removed from the AvailableAnalysis 750 if (Pos != AvailableAnalysis.end()) 751 AvailableAnalysis.erase(Pos); 752 } 753} 754 755/// Add pass P into the PassVector. Update 756/// AvailableAnalysis appropriately if ProcessAnalysis is true. 757void PMDataManager::addPassToManager(Pass *P, 758 bool ProcessAnalysis) { 759 760 // This manager is going to manage pass P. Set up analysis resolver 761 // to connect them. 762 AnalysisResolver_New *AR = new AnalysisResolver_New(*this); 763 P->setResolver(AR); 764 765 if (ProcessAnalysis) { 766 767 // At the moment, this pass is the last user of all required passes. 768 std::vector<Pass *> LastUses; 769 std::vector<Pass *> RequiredPasses; 770 unsigned PDepth = this->getDepth(); 771 772 collectRequiredAnalysisPasses(RequiredPasses, P); 773 for (std::vector<Pass *>::iterator I = RequiredPasses.begin(), 774 E = RequiredPasses.end(); I != E; ++I) { 775 Pass *PRequired = *I; 776 unsigned RDepth = 0; 777 778 PMDataManager &DM = PRequired->getResolver()->getPMDataManager(); 779 RDepth = DM.getDepth(); 780 781 if (PDepth == RDepth) 782 LastUses.push_back(PRequired); 783 else if (PDepth > RDepth) { 784 // Let the parent claim responsibility of last use 785 ForcedLastUses.push_back(PRequired); 786 } else { 787 // Note : This feature is not yet implemented 788 assert (0 && 789 "Unable to handle Pass that requires lower level Analysis pass"); 790 } 791 } 792 793 if (!LastUses.empty()) 794 TPM->setLastUser(LastUses, P); 795 796 // Take a note of analysis required and made available by this pass. 797 // Remove the analysis not preserved by this pass 798 removeNotPreservedAnalysis(P); 799 recordAvailableAnalysis(P); 800 } 801 802 // Add pass 803 PassVector.push_back(P); 804} 805 806/// Populate RequiredPasses with the analysis pass that are required by 807/// pass P. 808void PMDataManager::collectRequiredAnalysisPasses(std::vector<Pass *> &RP, 809 Pass *P) { 810 AnalysisUsage AnUsage; 811 P->getAnalysisUsage(AnUsage); 812 const std::vector<AnalysisID> &RequiredSet = AnUsage.getRequiredSet(); 813 for (std::vector<AnalysisID>::const_iterator 814 I = RequiredSet.begin(), E = RequiredSet.end(); 815 I != E; ++I) { 816 Pass *AnalysisPass = findAnalysisPass(*I, true); 817 assert (AnalysisPass && "Analysis pass is not available"); 818 RP.push_back(AnalysisPass); 819 } 820 821 const std::vector<AnalysisID> &IDs = AnUsage.getRequiredTransitiveSet(); 822 for (std::vector<AnalysisID>::const_iterator I = IDs.begin(), 823 E = IDs.end(); I != E; ++I) { 824 Pass *AnalysisPass = findAnalysisPass(*I, true); 825 assert (AnalysisPass && "Analysis pass is not available"); 826 RP.push_back(AnalysisPass); 827 } 828} 829 830// All Required analyses should be available to the pass as it runs! Here 831// we fill in the AnalysisImpls member of the pass so that it can 832// successfully use the getAnalysis() method to retrieve the 833// implementations it needs. 834// 835void PMDataManager::initializeAnalysisImpl(Pass *P) { 836 AnalysisUsage AnUsage; 837 P->getAnalysisUsage(AnUsage); 838 839 for (std::vector<const PassInfo *>::const_iterator 840 I = AnUsage.getRequiredSet().begin(), 841 E = AnUsage.getRequiredSet().end(); I != E; ++I) { 842 Pass *Impl = findAnalysisPass(*I, true); 843 if (Impl == 0) 844 assert(0 && "Analysis used but not available!"); 845 AnalysisResolver_New *AR = P->getResolver(); 846 AR->addAnalysisImplsPair(*I, Impl); 847 } 848} 849 850/// Find the pass that implements Analysis AID. If desired pass is not found 851/// then return NULL. 852Pass *PMDataManager::findAnalysisPass(AnalysisID AID, bool SearchParent) { 853 854 // Check if AvailableAnalysis map has one entry. 855 std::map<AnalysisID, Pass*>::const_iterator I = AvailableAnalysis.find(AID); 856 857 if (I != AvailableAnalysis.end()) 858 return I->second; 859 860 // Search Parents through TopLevelManager 861 if (SearchParent) 862 return TPM->findAnalysisPass(AID); 863 864 return NULL; 865} 866 867 868//===----------------------------------------------------------------------===// 869// NOTE: Is this the right place to define this method ? 870// getAnalysisToUpdate - Return an analysis result or null if it doesn't exist 871Pass *AnalysisResolver_New::getAnalysisToUpdate(AnalysisID ID, bool dir) const { 872 return PM.findAnalysisPass(ID, dir); 873} 874 875//===----------------------------------------------------------------------===// 876// BasicBlockPassManager implementation 877 878/// Add pass P into PassVector and return true. If this pass is not 879/// manageable by this manager then return false. 880bool 881BasicBlockPassManager::addPass(Pass *P) { 882 883 BasicBlockPass *BP = dynamic_cast<BasicBlockPass*>(P); 884 if (!BP) 885 return false; 886 887 // If this pass does not preserve anlysis that is used by other passes 888 // managed by this manager than it is not a suiable pass for this manager. 889 if (!manageablePass(P)) 890 return false; 891 892 addPassToManager (BP); 893 894 return true; 895} 896 897/// Execute all of the passes scheduled for execution by invoking 898/// runOnBasicBlock method. Keep track of whether any of the passes modifies 899/// the function, and if so, return true. 900bool 901BasicBlockPassManager::runOnFunction(Function &F) { 902 903 if (F.isExternal()) 904 return false; 905 906 bool Changed = doInitialization(F); 907 initializeAnalysisInfo(); 908 909 for (Function::iterator I = F.begin(), E = F.end(); I != E; ++I) 910 for (std::vector<Pass *>::iterator itr = passVectorBegin(), 911 e = passVectorEnd(); itr != e; ++itr) { 912 Pass *P = *itr; 913 initializeAnalysisImpl(P); 914 BasicBlockPass *BP = dynamic_cast<BasicBlockPass*>(P); 915 Changed |= BP->runOnBasicBlock(*I); 916 removeNotPreservedAnalysis(P); 917 recordAvailableAnalysis(P); 918 removeDeadPasses(P); 919 } 920 return Changed | doFinalization(F); 921} 922 923// Implement doInitialization and doFinalization 924inline bool BasicBlockPassManager::doInitialization(Module &M) { 925 bool Changed = false; 926 927 for (std::vector<Pass *>::iterator itr = passVectorBegin(), 928 e = passVectorEnd(); itr != e; ++itr) { 929 Pass *P = *itr; 930 BasicBlockPass *BP = dynamic_cast<BasicBlockPass*>(P); 931 Changed |= BP->doInitialization(M); 932 } 933 934 return Changed; 935} 936 937inline bool BasicBlockPassManager::doFinalization(Module &M) { 938 bool Changed = false; 939 940 for (std::vector<Pass *>::iterator itr = passVectorBegin(), 941 e = passVectorEnd(); itr != e; ++itr) { 942 Pass *P = *itr; 943 BasicBlockPass *BP = dynamic_cast<BasicBlockPass*>(P); 944 Changed |= BP->doFinalization(M); 945 } 946 947 return Changed; 948} 949 950inline bool BasicBlockPassManager::doInitialization(Function &F) { 951 bool Changed = false; 952 953 for (std::vector<Pass *>::iterator itr = passVectorBegin(), 954 e = passVectorEnd(); itr != e; ++itr) { 955 Pass *P = *itr; 956 BasicBlockPass *BP = dynamic_cast<BasicBlockPass*>(P); 957 Changed |= BP->doInitialization(F); 958 } 959 960 return Changed; 961} 962 963inline bool BasicBlockPassManager::doFinalization(Function &F) { 964 bool Changed = false; 965 966 for (std::vector<Pass *>::iterator itr = passVectorBegin(), 967 e = passVectorEnd(); itr != e; ++itr) { 968 Pass *P = *itr; 969 BasicBlockPass *BP = dynamic_cast<BasicBlockPass*>(P); 970 Changed |= BP->doFinalization(F); 971 } 972 973 return Changed; 974} 975 976 977//===----------------------------------------------------------------------===// 978// FunctionPassManager implementation 979 980/// Create new Function pass manager 981FunctionPassManager::FunctionPassManager(ModuleProvider *P) { 982 FPM = new FunctionPassManagerImpl_New(0); 983 // FPM is the top level manager. 984 FPM->setTopLevelManager(FPM); 985 986 PMDataManager *PMD = dynamic_cast<PMDataManager *>(FPM); 987 AnalysisResolver_New *AR = new AnalysisResolver_New(*PMD); 988 FPM->setResolver(AR); 989 990 FPM->addPassManager(FPM); 991 MP = P; 992} 993 994FunctionPassManager::~FunctionPassManager() { 995 // Note : FPM maintains one entry in PassManagers vector. 996 // This one entry is FPM itself. This is not ideal. One 997 // alternative is have one additional layer between 998 // FunctionPassManager and FunctionPassManagerImpl. 999 // Meanwhile, to avoid going into infinte loop, first 1000 // remove FPM from its PassMangers vector. 1001 FPM->clearManagers(); 1002 delete FPM; 1003} 1004 1005/// add - Add a pass to the queue of passes to run. This passes 1006/// ownership of the Pass to the PassManager. When the 1007/// PassManager_X is destroyed, the pass will be destroyed as well, so 1008/// there is no need to delete the pass. (TODO delete passes.) 1009/// This implies that all passes MUST be allocated with 'new'. 1010void FunctionPassManager::add(Pass *P) { 1011 FPM->add(P); 1012} 1013 1014/// run - Execute all of the passes scheduled for execution. Keep 1015/// track of whether any of the passes modifies the function, and if 1016/// so, return true. 1017/// 1018bool FunctionPassManager::run(Function &F) { 1019 std::string errstr; 1020 if (MP->materializeFunction(&F, &errstr)) { 1021 cerr << "Error reading bytecode file: " << errstr << "\n"; 1022 abort(); 1023 } 1024 return FPM->run(F); 1025} 1026 1027 1028/// doInitialization - Run all of the initializers for the function passes. 1029/// 1030bool FunctionPassManager::doInitialization() { 1031 return FPM->doInitialization(*MP->getModule()); 1032} 1033 1034/// doFinalization - Run all of the initializers for the function passes. 1035/// 1036bool FunctionPassManager::doFinalization() { 1037 return FPM->doFinalization(*MP->getModule()); 1038} 1039 1040//===----------------------------------------------------------------------===// 1041// FunctionPassManagerImpl_New implementation 1042 1043/// Add pass P into the pass manager queue. If P is a BasicBlockPass then 1044/// either use it into active basic block pass manager or create new basic 1045/// block pass manager to handle pass P. 1046bool 1047FunctionPassManagerImpl_New::addPass(Pass *P) { 1048 1049 // If P is a BasicBlockPass then use BasicBlockPassManager. 1050 if (BasicBlockPass *BP = dynamic_cast<BasicBlockPass*>(P)) { 1051 1052 if (!activeBBPassManager || !activeBBPassManager->addPass(BP)) { 1053 1054 // If active manager exists then clear its analysis info. 1055 if (activeBBPassManager) 1056 activeBBPassManager->initializeAnalysisInfo(); 1057 1058 // Create and add new manager 1059 activeBBPassManager = 1060 new BasicBlockPassManager(getDepth() + 1); 1061 // Inherit top level manager 1062 activeBBPassManager->setTopLevelManager(this->getTopLevelManager()); 1063 1064 // Add new manager into current manager's list. 1065 addPassToManager(activeBBPassManager, false); 1066 1067 // Add new manager into top level manager's indirect passes list 1068 PMDataManager *PMD = dynamic_cast<PMDataManager *>(activeBBPassManager); 1069 assert (PMD && "Manager is not Pass Manager"); 1070 TPM->addIndirectPassManager(PMD); 1071 1072 // Add pass into new manager. This time it must succeed. 1073 if (!activeBBPassManager->addPass(BP)) 1074 assert(0 && "Unable to add Pass"); 1075 } 1076 1077 if (!ForcedLastUses.empty()) 1078 TPM->setLastUser(ForcedLastUses, this); 1079 1080 return true; 1081 } 1082 1083 FunctionPass *FP = dynamic_cast<FunctionPass *>(P); 1084 if (!FP) 1085 return false; 1086 1087 // If this pass does not preserve anlysis that is used by other passes 1088 // managed by this manager than it is not a suiable pass for this manager. 1089 if (!manageablePass(P)) 1090 return false; 1091 1092 addPassToManager (FP); 1093 1094 // If active manager exists then clear its analysis info. 1095 if (activeBBPassManager) { 1096 activeBBPassManager->initializeAnalysisInfo(); 1097 activeBBPassManager = NULL; 1098 } 1099 1100 return true; 1101} 1102 1103/// Execute all of the passes scheduled for execution by invoking 1104/// runOnFunction method. Keep track of whether any of the passes modifies 1105/// the function, and if so, return true. 1106bool FunctionPassManagerImpl_New::runOnModule(Module &M) { 1107 1108 bool Changed = doInitialization(M); 1109 initializeAnalysisInfo(); 1110 1111 for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) 1112 this->runOnFunction(*I); 1113 1114 return Changed | doFinalization(M); 1115} 1116 1117/// Execute all of the passes scheduled for execution by invoking 1118/// runOnFunction method. Keep track of whether any of the passes modifies 1119/// the function, and if so, return true. 1120bool FunctionPassManagerImpl_New::runOnFunction(Function &F) { 1121 1122 bool Changed = false; 1123 1124 if (F.isExternal()) 1125 return false; 1126 1127 initializeAnalysisInfo(); 1128 1129 for (std::vector<Pass *>::iterator itr = passVectorBegin(), 1130 e = passVectorEnd(); itr != e; ++itr) { 1131 Pass *P = *itr; 1132 initializeAnalysisImpl(P); 1133 FunctionPass *FP = dynamic_cast<FunctionPass*>(P); 1134 Changed |= FP->runOnFunction(F); 1135 removeNotPreservedAnalysis(P); 1136 recordAvailableAnalysis(P); 1137 removeDeadPasses(P); 1138 } 1139 return Changed; 1140} 1141 1142 1143inline bool FunctionPassManagerImpl_New::doInitialization(Module &M) { 1144 bool Changed = false; 1145 1146 for (std::vector<Pass *>::iterator itr = passVectorBegin(), 1147 e = passVectorEnd(); itr != e; ++itr) { 1148 Pass *P = *itr; 1149 1150 FunctionPass *FP = dynamic_cast<FunctionPass*>(P); 1151 Changed |= FP->doInitialization(M); 1152 } 1153 1154 return Changed; 1155} 1156 1157inline bool FunctionPassManagerImpl_New::doFinalization(Module &M) { 1158 bool Changed = false; 1159 1160 for (std::vector<Pass *>::iterator itr = passVectorBegin(), 1161 e = passVectorEnd(); itr != e; ++itr) { 1162 Pass *P = *itr; 1163 1164 FunctionPass *FP = dynamic_cast<FunctionPass*>(P); 1165 Changed |= FP->doFinalization(M); 1166 } 1167 1168 return Changed; 1169} 1170 1171// Execute all the passes managed by this top level manager. 1172// Return true if any function is modified by a pass. 1173bool FunctionPassManagerImpl_New::run(Function &F) { 1174 1175 bool Changed = false; 1176 for (std::vector<Pass *>::iterator I = passManagersBegin(), 1177 E = passManagersEnd(); I != E; ++I) { 1178 FunctionPassManagerImpl_New *FP = 1179 dynamic_cast<FunctionPassManagerImpl_New *>(*I); 1180 Changed |= FP->runOnFunction(F); 1181 } 1182 return Changed; 1183} 1184 1185//===----------------------------------------------------------------------===// 1186// ModulePassManager implementation 1187 1188/// Add P into pass vector if it is manageble. If P is a FunctionPass 1189/// then use FunctionPassManagerImpl_New to manage it. Return false if P 1190/// is not manageable by this manager. 1191bool 1192ModulePassManager::addPass(Pass *P) { 1193 1194 // If P is FunctionPass then use function pass maanager. 1195 if (FunctionPass *FP = dynamic_cast<FunctionPass*>(P)) { 1196 1197 if (!activeFunctionPassManager || !activeFunctionPassManager->addPass(P)) { 1198 1199 // If active manager exists then clear its analysis info. 1200 if (activeFunctionPassManager) 1201 activeFunctionPassManager->initializeAnalysisInfo(); 1202 1203 // Create and add new manager 1204 activeFunctionPassManager = 1205 new FunctionPassManagerImpl_New(getDepth() + 1); 1206 1207 // Add new manager into current manager's list 1208 addPassToManager(activeFunctionPassManager, false); 1209 1210 // Inherit top level manager 1211 activeFunctionPassManager->setTopLevelManager(this->getTopLevelManager()); 1212 1213 // Add new manager into top level manager's indirect passes list 1214 PMDataManager *PMD = 1215 dynamic_cast<PMDataManager *>(activeFunctionPassManager); 1216 assert(PMD && "Manager is not Pass Manager"); 1217 TPM->addIndirectPassManager(PMD); 1218 1219 // Add pass into new manager. This time it must succeed. 1220 if (!activeFunctionPassManager->addPass(FP)) 1221 assert(0 && "Unable to add pass"); 1222 } 1223 1224 if (!ForcedLastUses.empty()) 1225 TPM->setLastUser(ForcedLastUses, this); 1226 1227 return true; 1228 } 1229 1230 ModulePass *MP = dynamic_cast<ModulePass *>(P); 1231 if (!MP) 1232 return false; 1233 1234 // If this pass does not preserve anlysis that is used by other passes 1235 // managed by this manager than it is not a suiable pass for this manager. 1236 if (!manageablePass(P)) 1237 return false; 1238 1239 addPassToManager(MP); 1240 // If active manager exists then clear its analysis info. 1241 if (activeFunctionPassManager) { 1242 activeFunctionPassManager->initializeAnalysisInfo(); 1243 activeFunctionPassManager = NULL; 1244 } 1245 1246 return true; 1247} 1248 1249 1250/// Execute all of the passes scheduled for execution by invoking 1251/// runOnModule method. Keep track of whether any of the passes modifies 1252/// the module, and if so, return true. 1253bool 1254ModulePassManager::runOnModule(Module &M) { 1255 bool Changed = false; 1256 initializeAnalysisInfo(); 1257 1258 for (std::vector<Pass *>::iterator itr = passVectorBegin(), 1259 e = passVectorEnd(); itr != e; ++itr) { 1260 Pass *P = *itr; 1261 initializeAnalysisImpl(P); 1262 ModulePass *MP = dynamic_cast<ModulePass*>(P); 1263 Changed |= MP->runOnModule(M); 1264 removeNotPreservedAnalysis(P); 1265 recordAvailableAnalysis(P); 1266 removeDeadPasses(P); 1267 } 1268 return Changed; 1269} 1270 1271//===----------------------------------------------------------------------===// 1272// PassManagerImpl implementation 1273// 1274/// Add P into active pass manager or use new module pass manager to 1275/// manage it. 1276bool PassManagerImpl_New::addPass(Pass *P) { 1277 1278 if (!activeManager || !activeManager->addPass(P)) { 1279 activeManager = new ModulePassManager(getDepth() + 1); 1280 // Inherit top level manager 1281 activeManager->setTopLevelManager(this->getTopLevelManager()); 1282 1283 // This top level manager is going to manage activeManager. 1284 // Set up analysis resolver to connect them. 1285 AnalysisResolver_New *AR = new AnalysisResolver_New(*this); 1286 activeManager->setResolver(AR); 1287 1288 addPassManager(activeManager); 1289 return activeManager->addPass(P); 1290 } 1291 return true; 1292} 1293 1294/// run - Execute all of the passes scheduled for execution. Keep track of 1295/// whether any of the passes modifies the module, and if so, return true. 1296bool PassManagerImpl_New::run(Module &M) { 1297 1298 bool Changed = false; 1299 1300 dumpArguments(); 1301 if (PassDebugging_New >= Structure) 1302 dumpPasses(); 1303 1304 for (std::vector<Pass *>::iterator I = passManagersBegin(), 1305 E = passManagersEnd(); I != E; ++I) { 1306 ModulePassManager *MP = dynamic_cast<ModulePassManager *>(*I); 1307 Changed |= MP->runOnModule(M); 1308 } 1309 return Changed; 1310} 1311 1312//===----------------------------------------------------------------------===// 1313// PassManager implementation 1314 1315/// Create new pass manager 1316PassManager::PassManager() { 1317 PM = new PassManagerImpl_New(0); 1318 // PM is the top level manager 1319 PM->setTopLevelManager(PM); 1320} 1321 1322PassManager::~PassManager() { 1323 delete PM; 1324} 1325 1326/// add - Add a pass to the queue of passes to run. This passes ownership of 1327/// the Pass to the PassManager. When the PassManager is destroyed, the pass 1328/// will be destroyed as well, so there is no need to delete the pass. This 1329/// implies that all passes MUST be allocated with 'new'. 1330void 1331PassManager::add(Pass *P) { 1332 PM->add(P); 1333} 1334 1335/// run - Execute all of the passes scheduled for execution. Keep track of 1336/// whether any of the passes modifies the module, and if so, return true. 1337bool 1338PassManager::run(Module &M) { 1339 return PM->run(M); 1340} 1341 1342#endif 1343