PassManager.cpp revision 889739c4d188d28c167644bced9df0f3131317d7
1//===- PassManager.cpp - LLVM Pass Infrastructure Implementation ----------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file was developed by the LLVM research group and is distributed under 6// the University of Illinois Open Source License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This file implements the LLVM Pass Manager infrastructure. 11// 12//===----------------------------------------------------------------------===// 13 14 15#include "llvm/PassManager.h" 16#include "llvm/Function.h" 17#include "llvm/Module.h" 18 19using namespace llvm; 20 21// PassManagerAnalysisHelper implementation 22 23/// Return TRUE IFF pass P's required analysis set does not required new 24/// manager. 25bool PassManagerAnalysisHelper::manageablePass(Pass *P) { 26 27 AnalysisUsage AnUsage; 28 P->getAnalysisUsage(AnUsage); 29 30 // If this pass is not preserving information that is required by the other passes 31 // managed by this manager then use new manager 32 // TODO 33 return true; 34} 35 36/// Return TRUE iff AnalysisID AID is currently available. 37bool PassManagerAnalysisHelper::analysisCurrentlyAvailable(AnalysisID AID) { 38 39 // TODO 40 return false; 41} 42 43/// Augment RequiredSet by adding analysis required by pass P. 44void PassManagerAnalysisHelper::noteDownRequiredAnalysis(Pass *P) { 45 46 // TODO 47} 48 49/// Remove AnalysisID from the RequiredSet 50void PassManagerAnalysisHelper::removeAnalysis(AnalysisID AID) { 51 52 // TODO 53} 54 55/// Remove Analyss not preserved by Pass P 56void PassManagerAnalysisHelper::removeNotPreservedAnalysis(Pass *P) { 57 58 // TODO 59} 60 61/// BasicBlockPassManager implementation 62 63/// Add pass P into PassVector and return TRUE. If this pass is not 64/// manageable by this manager then return FALSE. 65bool 66BasicBlockPassManager_New::addPass (Pass *P) { 67 68 BasicBlockPass *BP = dynamic_cast<BasicBlockPass*>(P); 69 if (!BP) 70 return false; 71 72 // TODO: Check if it suitable to manage P using this BasicBlockPassManager 73 // or we need another instance of BasicBlockPassManager 74 75 // Add pass 76 PassVector.push_back(BP); 77 return true; 78} 79 80/// Execute all of the passes scheduled for execution by invoking 81/// runOnBasicBlock method. Keep track of whether any of the passes modifies 82/// the function, and if so, return true. 83bool 84BasicBlockPassManager_New::runOnFunction(Function &F) { 85 86 bool Changed = false; 87 for (Function::iterator I = F.begin(), E = F.end(); I != E; ++I) 88 for (std::vector<Pass *>::iterator itr = PassVector.begin(), 89 e = PassVector.end(); itr != e; ++itr) { 90 Pass *P = *itr; 91 BasicBlockPass *BP = dynamic_cast<BasicBlockPass*>(P); 92 Changed |= BP->runOnBasicBlock(*I); 93 } 94 return Changed; 95} 96 97// FunctionPassManager_New implementation 98 99/////////////////////////////////////////////////////////////////////////////// 100// FunctionPassManager 101 102/// Add pass P into the pass manager queue. If P is a BasicBlockPass then 103/// either use it into active basic block pass manager or create new basic 104/// block pass manager to handle pass P. 105bool 106FunctionPassManager_New::addPass (Pass *P) { 107 108 // If P is a BasicBlockPass then use BasicBlockPassManager_New. 109 if (BasicBlockPass *BP = dynamic_cast<BasicBlockPass*>(P)) { 110 111 if (!activeBBPassManager 112 || !activeBBPassManager->addPass(BP)) { 113 114 activeBBPassManager = new BasicBlockPassManager_New(); 115 116 PassVector.push_back(activeBBPassManager); 117 assert (!activeBBPassManager->addPass(BP) && 118 "Unable to add Pass"); 119 } 120 return true; 121 } 122 123 FunctionPass *FP = dynamic_cast<FunctionPass *>(P); 124 if (!FP) 125 return false; 126 127 // TODO: Check if it suitable to manage P using this FunctionPassManager 128 // or we need another instance of FunctionPassManager 129 130 PassVector.push_back(FP); 131 activeBBPassManager = NULL; 132 return true; 133} 134 135/// Execute all of the passes scheduled for execution by invoking 136/// runOnFunction method. Keep track of whether any of the passes modifies 137/// the function, and if so, return true. 138bool 139FunctionPassManager_New::runOnModule(Module &M) { 140 141 bool Changed = false; 142 for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) 143 for (std::vector<Pass *>::iterator itr = PassVector.begin(), 144 e = PassVector.end(); itr != e; ++itr) { 145 Pass *P = *itr; 146 FunctionPass *FP = dynamic_cast<FunctionPass*>(P); 147 Changed |= FP->runOnFunction(*I); 148 } 149 return Changed; 150} 151 152 153// ModulePassManager implementation 154 155/// Add P into pass vector if it is manageble. If P is a FunctionPass 156/// then use FunctionPassManager_New to manage it. Return FALSE if P 157/// is not manageable by this manager. 158bool 159ModulePassManager_New::addPass (Pass *P) { 160 161 // If P is FunctionPass then use function pass maanager. 162 if (FunctionPass *FP = dynamic_cast<FunctionPass*>(P)) { 163 164 activeFunctionPassManager = NULL; 165 166 if (!activeFunctionPassManager 167 || !activeFunctionPassManager->addPass(P)) { 168 169 activeFunctionPassManager = new FunctionPassManager_New(); 170 171 PassVector.push_back(activeFunctionPassManager); 172 assert (!activeFunctionPassManager->addPass(FP) && 173 "Unable to add Pass"); 174 } 175 return true; 176 } 177 178 ModulePass *MP = dynamic_cast<ModulePass *>(P); 179 if (!MP) 180 return false; 181 182 // TODO: Check if it suitable to manage P using this ModulePassManager 183 // or we need another instance of ModulePassManager 184 185 PassVector.push_back(MP); 186 activeFunctionPassManager = NULL; 187 return true; 188} 189 190 191/// Execute all of the passes scheduled for execution by invoking 192/// runOnModule method. Keep track of whether any of the passes modifies 193/// the module, and if so, return true. 194bool 195ModulePassManager_New::runOnModule(Module &M) { 196 bool Changed = false; 197 for (std::vector<Pass *>::iterator itr = PassVector.begin(), 198 e = PassVector.end(); itr != e; ++itr) { 199 Pass *P = *itr; 200 ModulePass *MP = dynamic_cast<ModulePass*>(P); 201 Changed |= MP->runOnModule(M); 202 } 203 return Changed; 204} 205 206/// Schedule all passes from the queue by adding them in their 207/// respective manager's queue. 208void 209PassManager_New::schedulePasses() { 210 /* TODO */ 211} 212 213/// Add pass P to the queue of passes to run. 214void 215PassManager_New::add(Pass *P) { 216 /* TODO */ 217} 218 219// PassManager_New implementation 220/// Add P into active pass manager or use new module pass manager to 221/// manage it. 222bool 223PassManager_New::addPass (Pass *P) { 224 225 if (!activeManager) { 226 activeManager = new ModulePassManager_New(); 227 PassManagers.push_back(activeManager); 228 } 229 230 return activeManager->addPass(P); 231} 232 233/// run - Execute all of the passes scheduled for execution. Keep track of 234/// whether any of the passes modifies the module, and if so, return true. 235bool 236PassManager_New::run(Module &M) { 237 238 schedulePasses(); 239 bool Changed = false; 240 for (std::vector<ModulePassManager_New *>::iterator itr = PassManagers.begin(), 241 e = PassManagers.end(); itr != e; ++itr) { 242 ModulePassManager_New *pm = *itr; 243 Changed |= pm->runOnModule(M); 244 } 245 return Changed; 246} 247