Chris Lattner | 3e58d9b | 2003-10-13 05:33:01 +0000 | [diff] [blame] | 1 | //===- Pass.cpp - LLVM Pass Infrastructure Implementation -----------------===// |
Misha Brukman | fd93908 | 2005-04-21 23:48:37 +0000 | [diff] [blame] | 2 | // |
John Criswell | b576c94 | 2003-10-20 19:43:21 +0000 | [diff] [blame] | 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. |
Misha Brukman | fd93908 | 2005-04-21 23:48:37 +0000 | [diff] [blame] | 7 | // |
John Criswell | b576c94 | 2003-10-20 19:43:21 +0000 | [diff] [blame] | 8 | //===----------------------------------------------------------------------===// |
Chris Lattner | d695328 | 2002-01-21 07:37:31 +0000 | [diff] [blame] | 9 | // |
| 10 | // This file implements the LLVM Pass infrastructure. It is primarily |
| 11 | // responsible with ensuring that passes are executed and batched together |
| 12 | // optimally. |
| 13 | // |
| 14 | //===----------------------------------------------------------------------===// |
| 15 | |
Chris Lattner | 4130086 | 2002-01-31 00:45:31 +0000 | [diff] [blame] | 16 | #include "llvm/PassManager.h" |
| 17 | #include "llvm/Module.h" |
Misha Brukman | 69c856a | 2003-10-14 21:38:42 +0000 | [diff] [blame] | 18 | #include "llvm/ModuleProvider.h" |
Reid Spencer | 551ccae | 2004-09-01 22:55:40 +0000 | [diff] [blame] | 19 | #include "llvm/ADT/STLExtras.h" |
Chris Lattner | baf2ecd | 2006-12-01 23:27:45 +0000 | [diff] [blame] | 20 | #include "llvm/Support/ManagedStatic.h" |
Reid Spencer | 551ccae | 2004-09-01 22:55:40 +0000 | [diff] [blame] | 21 | #include "llvm/Support/TypeInfo.h" |
Jeff Cohen | ca5183d | 2007-03-05 00:00:42 +0000 | [diff] [blame] | 22 | #include <algorithm> |
Chris Lattner | 789bc84 | 2002-08-21 22:17:09 +0000 | [diff] [blame] | 23 | #include <set> |
Chris Lattner | 31f8499 | 2003-11-21 20:23:48 +0000 | [diff] [blame] | 24 | using namespace llvm; |
Brian Gaeke | d0fde30 | 2003-11-11 22:41:34 +0000 | [diff] [blame] | 25 | |
Chris Lattner | 27ad137 | 2002-05-06 19:31:52 +0000 | [diff] [blame] | 26 | //===----------------------------------------------------------------------===// |
Chris Lattner | 4130086 | 2002-01-31 00:45:31 +0000 | [diff] [blame] | 27 | // Pass Implementation |
Chris Lattner | 35f07eb | 2002-01-22 00:17:48 +0000 | [diff] [blame] | 28 | // |
Chris Lattner | 4130086 | 2002-01-31 00:45:31 +0000 | [diff] [blame] | 29 | |
Devang Patel | c7d0f4b | 2006-12-22 22:49:00 +0000 | [diff] [blame] | 30 | // Force out-of-line virtual method. |
Devang Patel | 6e21ff0 | 2007-04-26 21:33:42 +0000 | [diff] [blame] | 31 | Pass::~Pass() { |
| 32 | delete Resolver; |
| 33 | } |
| 34 | |
| 35 | // Force out-of-line virtual method. |
Devang Patel | c7d0f4b | 2006-12-22 22:49:00 +0000 | [diff] [blame] | 36 | ModulePass::~ModulePass() { } |
Chris Lattner | d695328 | 2002-01-21 07:37:31 +0000 | [diff] [blame] | 37 | |
Chris Lattner | f1ab454 | 2003-03-21 21:41:02 +0000 | [diff] [blame] | 38 | bool Pass::mustPreserveAnalysisID(const PassInfo *AnalysisID) const { |
Devang Patel | cde53d3 | 2007-01-05 22:47:07 +0000 | [diff] [blame] | 39 | return Resolver->getAnalysisToUpdate(AnalysisID, true) != 0; |
Chris Lattner | f1ab454 | 2003-03-21 21:41:02 +0000 | [diff] [blame] | 40 | } |
| 41 | |
Chris Lattner | 37d66c4 | 2002-07-30 16:27:02 +0000 | [diff] [blame] | 42 | // dumpPassStructure - Implement the -debug-passes=Structure option |
| 43 | void Pass::dumpPassStructure(unsigned Offset) { |
Bill Wendling | 832171c | 2006-12-07 20:04:42 +0000 | [diff] [blame] | 44 | cerr << std::string(Offset*2, ' ') << getPassName() << "\n"; |
Chris Lattner | 37d66c4 | 2002-07-30 16:27:02 +0000 | [diff] [blame] | 45 | } |
Chris Lattner | 96c466b | 2002-04-29 14:57:45 +0000 | [diff] [blame] | 46 | |
Brian Gaeke | f822ee9 | 2004-02-28 21:55:18 +0000 | [diff] [blame] | 47 | // getPassName - Use C++ RTTI to get a SOMEWHAT intelligible name for the pass. |
Chris Lattner | 96c466b | 2002-04-29 14:57:45 +0000 | [diff] [blame] | 48 | // |
Chris Lattner | 44050fb | 2002-07-29 21:02:31 +0000 | [diff] [blame] | 49 | const char *Pass::getPassName() const { |
| 50 | if (const PassInfo *PI = getPassInfo()) |
| 51 | return PI->getPassName(); |
| 52 | return typeid(*this).name(); |
| 53 | } |
Chris Lattner | 96c466b | 2002-04-29 14:57:45 +0000 | [diff] [blame] | 54 | |
Misha Brukman | 69c856a | 2003-10-14 21:38:42 +0000 | [diff] [blame] | 55 | // print - Print out the internal state of the pass. This is called by Analyze |
Misha Brukman | 5560c9d | 2003-08-18 14:43:39 +0000 | [diff] [blame] | 56 | // to print out the contents of an analysis. Otherwise it is not necessary to |
Chris Lattner | a59cbb2 | 2002-07-27 01:12:17 +0000 | [diff] [blame] | 57 | // implement this method. |
| 58 | // |
Reid Spencer | ce9653c | 2004-12-07 04:03:45 +0000 | [diff] [blame] | 59 | void Pass::print(std::ostream &O,const Module*) const { |
Chris Lattner | a59cbb2 | 2002-07-27 01:12:17 +0000 | [diff] [blame] | 60 | O << "Pass::print not implemented for pass: '" << getPassName() << "'!\n"; |
| 61 | } |
| 62 | |
Bill Wendling | 832171c | 2006-12-07 20:04:42 +0000 | [diff] [blame] | 63 | // dump - call print(cerr); |
Chris Lattner | a59cbb2 | 2002-07-27 01:12:17 +0000 | [diff] [blame] | 64 | void Pass::dump() const { |
Bill Wendling | 832171c | 2006-12-07 20:04:42 +0000 | [diff] [blame] | 65 | print(*cerr.stream(), 0); |
Chris Lattner | a59cbb2 | 2002-07-27 01:12:17 +0000 | [diff] [blame] | 66 | } |
| 67 | |
Chris Lattner | 4130086 | 2002-01-31 00:45:31 +0000 | [diff] [blame] | 68 | //===----------------------------------------------------------------------===// |
Chris Lattner | 70b4f3e | 2002-09-25 21:59:11 +0000 | [diff] [blame] | 69 | // ImmutablePass Implementation |
| 70 | // |
Devang Patel | c7d0f4b | 2006-12-22 22:49:00 +0000 | [diff] [blame] | 71 | // Force out-of-line virtual method. |
| 72 | ImmutablePass::~ImmutablePass() { } |
Chris Lattner | 70b4f3e | 2002-09-25 21:59:11 +0000 | [diff] [blame] | 73 | |
| 74 | //===----------------------------------------------------------------------===// |
Chris Lattner | f57b845 | 2002-04-27 06:56:12 +0000 | [diff] [blame] | 75 | // FunctionPass Implementation |
Chris Lattner | d695328 | 2002-01-21 07:37:31 +0000 | [diff] [blame] | 76 | // |
Chris Lattner | 4130086 | 2002-01-31 00:45:31 +0000 | [diff] [blame] | 77 | |
Chris Lattner | f57b845 | 2002-04-27 06:56:12 +0000 | [diff] [blame] | 78 | // run - On a module, we run this pass by initializing, runOnFunction'ing once |
| 79 | // for every function in the module, then by finalizing. |
Chris Lattner | 4130086 | 2002-01-31 00:45:31 +0000 | [diff] [blame] | 80 | // |
Chris Lattner | bba61c0 | 2004-09-20 04:47:19 +0000 | [diff] [blame] | 81 | bool FunctionPass::runOnModule(Module &M) { |
Chris Lattner | 4130086 | 2002-01-31 00:45:31 +0000 | [diff] [blame] | 82 | bool Changed = doInitialization(M); |
Misha Brukman | fd93908 | 2005-04-21 23:48:37 +0000 | [diff] [blame] | 83 | |
Chris Lattner | 7e70829 | 2002-06-25 16:13:24 +0000 | [diff] [blame] | 84 | for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) |
Reid Spencer | 5cbf985 | 2007-01-30 20:08:39 +0000 | [diff] [blame] | 85 | if (!I->isDeclaration()) // Passes are not run on external functions! |
Chris Lattner | f57b845 | 2002-04-27 06:56:12 +0000 | [diff] [blame] | 86 | Changed |= runOnFunction(*I); |
Misha Brukman | fd93908 | 2005-04-21 23:48:37 +0000 | [diff] [blame] | 87 | |
Chris Lattner | 4130086 | 2002-01-31 00:45:31 +0000 | [diff] [blame] | 88 | return Changed | doFinalization(M); |
Chris Lattner | d695328 | 2002-01-21 07:37:31 +0000 | [diff] [blame] | 89 | } |
| 90 | |
Chris Lattner | f57b845 | 2002-04-27 06:56:12 +0000 | [diff] [blame] | 91 | // run - On a function, we simply initialize, run the function, then finalize. |
Chris Lattner | 4130086 | 2002-01-31 00:45:31 +0000 | [diff] [blame] | 92 | // |
Chris Lattner | 7e70829 | 2002-06-25 16:13:24 +0000 | [diff] [blame] | 93 | bool FunctionPass::run(Function &F) { |
Reid Spencer | 5cbf985 | 2007-01-30 20:08:39 +0000 | [diff] [blame] | 94 | if (F.isDeclaration()) return false;// Passes are not run on external functions! |
Chris Lattner | 4130086 | 2002-01-31 00:45:31 +0000 | [diff] [blame] | 95 | |
Chris Lattner | bba61c0 | 2004-09-20 04:47:19 +0000 | [diff] [blame] | 96 | bool Changed = doInitialization(*F.getParent()); |
| 97 | Changed |= runOnFunction(F); |
| 98 | return Changed | doFinalization(*F.getParent()); |
Chris Lattner | d695328 | 2002-01-21 07:37:31 +0000 | [diff] [blame] | 99 | } |
Chris Lattner | e212062 | 2002-01-23 05:49:41 +0000 | [diff] [blame] | 100 | |
Chris Lattner | 4130086 | 2002-01-31 00:45:31 +0000 | [diff] [blame] | 101 | //===----------------------------------------------------------------------===// |
| 102 | // BasicBlockPass Implementation |
| 103 | // |
| 104 | |
Chris Lattner | f57b845 | 2002-04-27 06:56:12 +0000 | [diff] [blame] | 105 | // To run this pass on a function, we simply call runOnBasicBlock once for each |
| 106 | // function. |
Chris Lattner | 4130086 | 2002-01-31 00:45:31 +0000 | [diff] [blame] | 107 | // |
Chris Lattner | 7e70829 | 2002-06-25 16:13:24 +0000 | [diff] [blame] | 108 | bool BasicBlockPass::runOnFunction(Function &F) { |
Chris Lattner | e0a54f8 | 2002-09-12 17:06:40 +0000 | [diff] [blame] | 109 | bool Changed = doInitialization(F); |
Chris Lattner | 7e70829 | 2002-06-25 16:13:24 +0000 | [diff] [blame] | 110 | for (Function::iterator I = F.begin(), E = F.end(); I != E; ++I) |
Chris Lattner | 4130086 | 2002-01-31 00:45:31 +0000 | [diff] [blame] | 111 | Changed |= runOnBasicBlock(*I); |
Chris Lattner | e0a54f8 | 2002-09-12 17:06:40 +0000 | [diff] [blame] | 112 | return Changed | doFinalization(F); |
Chris Lattner | 4130086 | 2002-01-31 00:45:31 +0000 | [diff] [blame] | 113 | } |
| 114 | |
| 115 | // To run directly on the basic block, we initialize, runOnBasicBlock, then |
| 116 | // finalize. |
| 117 | // |
Chris Lattner | bba61c0 | 2004-09-20 04:47:19 +0000 | [diff] [blame] | 118 | bool BasicBlockPass::runPass(BasicBlock &BB) { |
Chris Lattner | e0a54f8 | 2002-09-12 17:06:40 +0000 | [diff] [blame] | 119 | Function &F = *BB.getParent(); |
| 120 | Module &M = *F.getParent(); |
Chris Lattner | bba61c0 | 2004-09-20 04:47:19 +0000 | [diff] [blame] | 121 | bool Changed = doInitialization(M); |
| 122 | Changed |= doInitialization(F); |
| 123 | Changed |= runOnBasicBlock(BB); |
| 124 | Changed |= doFinalization(F); |
| 125 | Changed |= doFinalization(M); |
| 126 | return Changed; |
Chris Lattner | 4130086 | 2002-01-31 00:45:31 +0000 | [diff] [blame] | 127 | } |
| 128 | |
Chris Lattner | 54bbdb4 | 2002-07-23 18:08:00 +0000 | [diff] [blame] | 129 | //===----------------------------------------------------------------------===// |
| 130 | // Pass Registration mechanism |
| 131 | // |
Chris Lattner | ee74083 | 2006-12-01 23:46:50 +0000 | [diff] [blame] | 132 | namespace { |
Chris Lattner | baf2ecd | 2006-12-01 23:27:45 +0000 | [diff] [blame] | 133 | class PassRegistrar { |
Chris Lattner | ee74083 | 2006-12-01 23:46:50 +0000 | [diff] [blame] | 134 | /// PassInfoMap - Keep track of the passinfo object for each registered llvm |
| 135 | /// pass. |
Devang Patel | eae540a | 2007-05-02 20:38:25 +0000 | [diff] [blame] | 136 | std::map<intptr_t, PassInfo*> PassInfoMap; |
Chris Lattner | ee74083 | 2006-12-01 23:46:50 +0000 | [diff] [blame] | 137 | |
| 138 | /// AnalysisGroupInfo - Keep track of information for each analysis group. |
| 139 | struct AnalysisGroupInfo { |
| 140 | const PassInfo *DefaultImpl; |
| 141 | std::set<const PassInfo *> Implementations; |
| 142 | AnalysisGroupInfo() : DefaultImpl(0) {} |
| 143 | }; |
| 144 | |
| 145 | /// AnalysisGroupInfoMap - Information for each analysis group. |
| 146 | std::map<const PassInfo *, AnalysisGroupInfo> AnalysisGroupInfoMap; |
| 147 | |
Chris Lattner | baf2ecd | 2006-12-01 23:27:45 +0000 | [diff] [blame] | 148 | public: |
| 149 | |
Devang Patel | eae540a | 2007-05-02 20:38:25 +0000 | [diff] [blame] | 150 | const PassInfo *GetPassInfo(intptr_t TI) const { |
| 151 | std::map<intptr_t, PassInfo*>::const_iterator I = PassInfoMap.find(TI); |
Chris Lattner | baf2ecd | 2006-12-01 23:27:45 +0000 | [diff] [blame] | 152 | return I != PassInfoMap.end() ? I->second : 0; |
| 153 | } |
| 154 | |
| 155 | void RegisterPass(PassInfo &PI) { |
| 156 | bool Inserted = |
Devang Patel | eae540a | 2007-05-02 20:38:25 +0000 | [diff] [blame] | 157 | PassInfoMap.insert(std::make_pair(PI.getTypeInfo(),&PI)).second; |
Chris Lattner | 80d692b | 2007-05-02 04:25:31 +0000 | [diff] [blame] | 158 | assert(Inserted && "Pass registered multiple times!"); |
Chris Lattner | baf2ecd | 2006-12-01 23:27:45 +0000 | [diff] [blame] | 159 | } |
| 160 | |
| 161 | void UnregisterPass(PassInfo &PI) { |
Devang Patel | eae540a | 2007-05-02 20:38:25 +0000 | [diff] [blame] | 162 | std::map<intptr_t, PassInfo*>::iterator I = |
Chris Lattner | baf2ecd | 2006-12-01 23:27:45 +0000 | [diff] [blame] | 163 | PassInfoMap.find(PI.getTypeInfo()); |
| 164 | assert(I != PassInfoMap.end() && "Pass registered but not in map!"); |
| 165 | |
| 166 | // Remove pass from the map. |
| 167 | PassInfoMap.erase(I); |
| 168 | } |
| 169 | |
| 170 | void EnumerateWith(PassRegistrationListener *L) { |
Devang Patel | eae540a | 2007-05-02 20:38:25 +0000 | [diff] [blame] | 171 | for (std::map<intptr_t, PassInfo*>::const_iterator I = PassInfoMap.begin(), |
Chris Lattner | baf2ecd | 2006-12-01 23:27:45 +0000 | [diff] [blame] | 172 | E = PassInfoMap.end(); I != E; ++I) |
| 173 | L->passEnumerate(I->second); |
| 174 | } |
Chris Lattner | ee74083 | 2006-12-01 23:46:50 +0000 | [diff] [blame] | 175 | |
| 176 | |
| 177 | /// Analysis Group Mechanisms. |
| 178 | void RegisterAnalysisGroup(PassInfo *InterfaceInfo, |
| 179 | const PassInfo *ImplementationInfo, |
| 180 | bool isDefault) { |
| 181 | AnalysisGroupInfo &AGI = AnalysisGroupInfoMap[InterfaceInfo]; |
| 182 | assert(AGI.Implementations.count(ImplementationInfo) == 0 && |
| 183 | "Cannot add a pass to the same analysis group more than once!"); |
| 184 | AGI.Implementations.insert(ImplementationInfo); |
| 185 | if (isDefault) { |
| 186 | assert(AGI.DefaultImpl == 0 && InterfaceInfo->getNormalCtor() == 0 && |
| 187 | "Default implementation for analysis group already specified!"); |
| 188 | assert(ImplementationInfo->getNormalCtor() && |
| 189 | "Cannot specify pass as default if it does not have a default ctor"); |
| 190 | AGI.DefaultImpl = ImplementationInfo; |
| 191 | InterfaceInfo->setNormalCtor(ImplementationInfo->getNormalCtor()); |
| 192 | } |
| 193 | } |
Chris Lattner | baf2ecd | 2006-12-01 23:27:45 +0000 | [diff] [blame] | 194 | }; |
Chris Lattner | ee74083 | 2006-12-01 23:46:50 +0000 | [diff] [blame] | 195 | } |
Chris Lattner | baf2ecd | 2006-12-01 23:27:45 +0000 | [diff] [blame] | 196 | |
Chris Lattner | 54bbdb4 | 2002-07-23 18:08:00 +0000 | [diff] [blame] | 197 | static std::vector<PassRegistrationListener*> *Listeners = 0; |
| 198 | |
Chris Lattner | d1458f1 | 2007-04-21 00:12:18 +0000 | [diff] [blame] | 199 | // FIXME: This should use ManagedStatic to manage the pass registrar. |
| 200 | // Unfortunately, we can't do this, because passes are registered with static |
| 201 | // ctors, and having llvm_shutdown clear this map prevents successful |
| 202 | // ressurection after llvm_shutdown is run. |
| 203 | static PassRegistrar *getPassRegistrar() { |
| 204 | static PassRegistrar *PassRegistrarObj = 0; |
| 205 | if (!PassRegistrarObj) |
| 206 | PassRegistrarObj = new PassRegistrar(); |
| 207 | return PassRegistrarObj; |
| 208 | } |
| 209 | |
Chris Lattner | 54bbdb4 | 2002-07-23 18:08:00 +0000 | [diff] [blame] | 210 | // getPassInfo - Return the PassInfo data structure that corresponds to this |
| 211 | // pass... |
| 212 | const PassInfo *Pass::getPassInfo() const { |
Devang Patel | eae540a | 2007-05-02 20:38:25 +0000 | [diff] [blame] | 213 | return lookupPassInfo(PassID); |
Chris Lattner | fb30fda | 2002-08-21 17:08:37 +0000 | [diff] [blame] | 214 | } |
| 215 | |
Devang Patel | eae540a | 2007-05-02 20:38:25 +0000 | [diff] [blame] | 216 | const PassInfo *Pass::lookupPassInfo(intptr_t TI) { |
Chris Lattner | d1458f1 | 2007-04-21 00:12:18 +0000 | [diff] [blame] | 217 | return getPassRegistrar()->GetPassInfo(TI); |
Chris Lattner | 54bbdb4 | 2002-07-23 18:08:00 +0000 | [diff] [blame] | 218 | } |
| 219 | |
Chris Lattner | 1ac2d51 | 2006-01-23 01:01:04 +0000 | [diff] [blame] | 220 | void RegisterPassBase::registerPass() { |
Chris Lattner | d1458f1 | 2007-04-21 00:12:18 +0000 | [diff] [blame] | 221 | getPassRegistrar()->RegisterPass(PIObj); |
Chris Lattner | 54bbdb4 | 2002-07-23 18:08:00 +0000 | [diff] [blame] | 222 | |
Chris Lattner | baf2ecd | 2006-12-01 23:27:45 +0000 | [diff] [blame] | 223 | // Notify any listeners. |
Chris Lattner | 54bbdb4 | 2002-07-23 18:08:00 +0000 | [diff] [blame] | 224 | if (Listeners) |
| 225 | for (std::vector<PassRegistrationListener*>::iterator |
| 226 | I = Listeners->begin(), E = Listeners->end(); I != E; ++I) |
Chris Lattner | 1ac2d51 | 2006-01-23 01:01:04 +0000 | [diff] [blame] | 227 | (*I)->passRegistered(&PIObj); |
Chris Lattner | 54bbdb4 | 2002-07-23 18:08:00 +0000 | [diff] [blame] | 228 | } |
| 229 | |
Chris Lattner | 1ac2d51 | 2006-01-23 01:01:04 +0000 | [diff] [blame] | 230 | void RegisterPassBase::unregisterPass() { |
Chris Lattner | d1458f1 | 2007-04-21 00:12:18 +0000 | [diff] [blame] | 231 | getPassRegistrar()->UnregisterPass(PIObj); |
Chris Lattner | 54bbdb4 | 2002-07-23 18:08:00 +0000 | [diff] [blame] | 232 | } |
| 233 | |
Chris Lattner | 789bc84 | 2002-08-21 22:17:09 +0000 | [diff] [blame] | 234 | //===----------------------------------------------------------------------===// |
| 235 | // Analysis Group Implementation Code |
| 236 | //===----------------------------------------------------------------------===// |
| 237 | |
Chris Lattner | 789bc84 | 2002-08-21 22:17:09 +0000 | [diff] [blame] | 238 | // RegisterAGBase implementation |
| 239 | // |
Devang Patel | eae540a | 2007-05-02 20:38:25 +0000 | [diff] [blame] | 240 | RegisterAGBase::RegisterAGBase(intptr_t InterfaceID, |
| 241 | intptr_t PassID, bool isDefault) |
| 242 | : RegisterPassBase(InterfaceID), |
Chris Lattner | 1ac2d51 | 2006-01-23 01:01:04 +0000 | [diff] [blame] | 243 | ImplementationInfo(0), isDefaultImplementation(isDefault) { |
Chris Lattner | 789bc84 | 2002-08-21 22:17:09 +0000 | [diff] [blame] | 244 | |
Devang Patel | eae540a | 2007-05-02 20:38:25 +0000 | [diff] [blame] | 245 | InterfaceInfo = const_cast<PassInfo*>(Pass::lookupPassInfo(InterfaceID)); |
Chris Lattner | 1ac2d51 | 2006-01-23 01:01:04 +0000 | [diff] [blame] | 246 | if (InterfaceInfo == 0) { |
| 247 | // First reference to Interface, register it now. |
| 248 | registerPass(); |
| 249 | InterfaceInfo = &PIObj; |
Chris Lattner | 789bc84 | 2002-08-21 22:17:09 +0000 | [diff] [blame] | 250 | } |
Chris Lattner | 2dd3d42 | 2006-08-27 22:21:55 +0000 | [diff] [blame] | 251 | assert(PIObj.isAnalysisGroup() && |
Chris Lattner | 789bc84 | 2002-08-21 22:17:09 +0000 | [diff] [blame] | 252 | "Trying to join an analysis group that is a normal pass!"); |
| 253 | |
Devang Patel | eae540a | 2007-05-02 20:38:25 +0000 | [diff] [blame] | 254 | if (PassID) { |
| 255 | ImplementationInfo = Pass::lookupPassInfo(PassID); |
Chris Lattner | 789bc84 | 2002-08-21 22:17:09 +0000 | [diff] [blame] | 256 | assert(ImplementationInfo && |
| 257 | "Must register pass before adding to AnalysisGroup!"); |
| 258 | |
Chris Lattner | 1c28b42 | 2002-08-30 20:23:45 +0000 | [diff] [blame] | 259 | // Make sure we keep track of the fact that the implementation implements |
| 260 | // the interface. |
| 261 | PassInfo *IIPI = const_cast<PassInfo*>(ImplementationInfo); |
| 262 | IIPI->addInterfaceImplemented(InterfaceInfo); |
Chris Lattner | ee74083 | 2006-12-01 23:46:50 +0000 | [diff] [blame] | 263 | |
Chris Lattner | d1458f1 | 2007-04-21 00:12:18 +0000 | [diff] [blame] | 264 | getPassRegistrar()->RegisterAnalysisGroup(InterfaceInfo, IIPI, isDefault); |
Chris Lattner | 789bc84 | 2002-08-21 22:17:09 +0000 | [diff] [blame] | 265 | } |
| 266 | } |
| 267 | |
| 268 | void RegisterAGBase::setGroupName(const char *Name) { |
| 269 | assert(InterfaceInfo->getPassName()[0] == 0 && "Interface Name already set!"); |
| 270 | InterfaceInfo->setPassName(Name); |
| 271 | } |
| 272 | |
Chris Lattner | 789bc84 | 2002-08-21 22:17:09 +0000 | [diff] [blame] | 273 | |
Chris Lattner | 54bbdb4 | 2002-07-23 18:08:00 +0000 | [diff] [blame] | 274 | //===----------------------------------------------------------------------===// |
| 275 | // PassRegistrationListener implementation |
| 276 | // |
| 277 | |
| 278 | // PassRegistrationListener ctor - Add the current object to the list of |
| 279 | // PassRegistrationListeners... |
| 280 | PassRegistrationListener::PassRegistrationListener() { |
| 281 | if (!Listeners) Listeners = new std::vector<PassRegistrationListener*>(); |
| 282 | Listeners->push_back(this); |
| 283 | } |
| 284 | |
| 285 | // dtor - Remove object from list of listeners... |
| 286 | PassRegistrationListener::~PassRegistrationListener() { |
| 287 | std::vector<PassRegistrationListener*>::iterator I = |
| 288 | std::find(Listeners->begin(), Listeners->end(), this); |
| 289 | assert(Listeners && I != Listeners->end() && |
| 290 | "PassRegistrationListener not registered!"); |
| 291 | Listeners->erase(I); |
| 292 | |
| 293 | if (Listeners->empty()) { |
| 294 | delete Listeners; |
| 295 | Listeners = 0; |
| 296 | } |
| 297 | } |
| 298 | |
| 299 | // enumeratePasses - Iterate over the registered passes, calling the |
| 300 | // passEnumerate callback on each PassInfo object. |
| 301 | // |
| 302 | void PassRegistrationListener::enumeratePasses() { |
Chris Lattner | d1458f1 | 2007-04-21 00:12:18 +0000 | [diff] [blame] | 303 | getPassRegistrar()->EnumerateWith(this); |
Chris Lattner | 54bbdb4 | 2002-07-23 18:08:00 +0000 | [diff] [blame] | 304 | } |
Reid Spencer | e8f3848 | 2005-04-25 01:01:35 +0000 | [diff] [blame] | 305 | |
Chris Lattner | 947c768 | 2006-12-01 22:21:11 +0000 | [diff] [blame] | 306 | //===----------------------------------------------------------------------===// |
| 307 | // AnalysisUsage Class Implementation |
| 308 | // |
| 309 | |
Chris Lattner | baf2ecd | 2006-12-01 23:27:45 +0000 | [diff] [blame] | 310 | namespace { |
| 311 | struct GetCFGOnlyPasses : public PassRegistrationListener { |
| 312 | std::vector<AnalysisID> &CFGOnlyList; |
| 313 | GetCFGOnlyPasses(std::vector<AnalysisID> &L) : CFGOnlyList(L) {} |
| 314 | |
| 315 | void passEnumerate(const PassInfo *P) { |
| 316 | if (P->isCFGOnlyPass()) |
| 317 | CFGOnlyList.push_back(P); |
| 318 | } |
| 319 | }; |
| 320 | } |
| 321 | |
Chris Lattner | 947c768 | 2006-12-01 22:21:11 +0000 | [diff] [blame] | 322 | // setPreservesCFG - This function should be called to by the pass, iff they do |
| 323 | // not: |
| 324 | // |
| 325 | // 1. Add or remove basic blocks from the function |
| 326 | // 2. Modify terminator instructions in any way. |
| 327 | // |
| 328 | // This function annotates the AnalysisUsage info object to say that analyses |
| 329 | // that only depend on the CFG are preserved by this pass. |
| 330 | // |
| 331 | void AnalysisUsage::setPreservesCFG() { |
| 332 | // Since this transformation doesn't modify the CFG, it preserves all analyses |
| 333 | // that only depend on the CFG (like dominators, loop info, etc...) |
Chris Lattner | baf2ecd | 2006-12-01 23:27:45 +0000 | [diff] [blame] | 334 | GetCFGOnlyPasses(Preserved).enumeratePasses(); |
Chris Lattner | 947c768 | 2006-12-01 22:21:11 +0000 | [diff] [blame] | 335 | } |
| 336 | |
| 337 | |