| File: | src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/IR/LegacyPassManager.cpp |
| Warning: | line 716, column 24 Called C++ object pointer is null |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
| 1 | //===- LegacyPassManager.cpp - LLVM Pass Infrastructure Implementation ----===// | |||
| 2 | // | |||
| 3 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. | |||
| 4 | // See https://llvm.org/LICENSE.txt for license information. | |||
| 5 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception | |||
| 6 | // | |||
| 7 | //===----------------------------------------------------------------------===// | |||
| 8 | // | |||
| 9 | // This file implements the legacy LLVM Pass Manager infrastructure. | |||
| 10 | // | |||
| 11 | //===----------------------------------------------------------------------===// | |||
| 12 | ||||
| 13 | #include "llvm/IR/LegacyPassManager.h" | |||
| 14 | #include "llvm/ADT/MapVector.h" | |||
| 15 | #include "llvm/ADT/Statistic.h" | |||
| 16 | #include "llvm/IR/DiagnosticInfo.h" | |||
| 17 | #include "llvm/IR/IRPrintingPasses.h" | |||
| 18 | #include "llvm/IR/LLVMContext.h" | |||
| 19 | #include "llvm/IR/LegacyPassManagers.h" | |||
| 20 | #include "llvm/IR/LegacyPassNameParser.h" | |||
| 21 | #include "llvm/IR/Module.h" | |||
| 22 | #include "llvm/IR/PassTimingInfo.h" | |||
| 23 | #include "llvm/IR/PrintPasses.h" | |||
| 24 | #include "llvm/IR/StructuralHash.h" | |||
| 25 | #include "llvm/Support/Chrono.h" | |||
| 26 | #include "llvm/Support/CommandLine.h" | |||
| 27 | #include "llvm/Support/Debug.h" | |||
| 28 | #include "llvm/Support/Error.h" | |||
| 29 | #include "llvm/Support/ErrorHandling.h" | |||
| 30 | #include "llvm/Support/ManagedStatic.h" | |||
| 31 | #include "llvm/Support/Mutex.h" | |||
| 32 | #include "llvm/Support/TimeProfiler.h" | |||
| 33 | #include "llvm/Support/Timer.h" | |||
| 34 | #include "llvm/Support/raw_ostream.h" | |||
| 35 | #include <algorithm> | |||
| 36 | #include <unordered_set> | |||
| 37 | using namespace llvm; | |||
| 38 | ||||
| 39 | // See PassManagers.h for Pass Manager infrastructure overview. | |||
| 40 | ||||
| 41 | //===----------------------------------------------------------------------===// | |||
| 42 | // Pass debugging information. Often it is useful to find out what pass is | |||
| 43 | // running when a crash occurs in a utility. When this library is compiled with | |||
| 44 | // debugging on, a command line option (--debug-pass) is enabled that causes the | |||
| 45 | // pass name to be printed before it executes. | |||
| 46 | // | |||
| 47 | ||||
| 48 | namespace { | |||
| 49 | // Different debug levels that can be enabled... | |||
| 50 | enum PassDebugLevel { | |||
| 51 | Disabled, Arguments, Structure, Executions, Details | |||
| 52 | }; | |||
| 53 | } // namespace | |||
| 54 | ||||
| 55 | static cl::opt<enum PassDebugLevel> PassDebugging( | |||
| 56 | "debug-pass", cl::Hidden, | |||
| 57 | cl::desc("Print legacy PassManager debugging information"), | |||
| 58 | cl::values(clEnumVal(Disabled, "disable debug output")llvm::cl::OptionEnumValue { "Disabled", int(Disabled), "disable debug output" }, | |||
| 59 | clEnumVal(Arguments, "print pass arguments to pass to 'opt'")llvm::cl::OptionEnumValue { "Arguments", int(Arguments), "print pass arguments to pass to 'opt'" }, | |||
| 60 | clEnumVal(Structure, "print pass structure before run()")llvm::cl::OptionEnumValue { "Structure", int(Structure), "print pass structure before run()" }, | |||
| 61 | clEnumVal(Executions, "print pass name before it is executed")llvm::cl::OptionEnumValue { "Executions", int(Executions), "print pass name before it is executed" }, | |||
| 62 | clEnumVal(Details, "print pass details when it is executed")llvm::cl::OptionEnumValue { "Details", int(Details), "print pass details when it is executed" })); | |||
| 63 | ||||
| 64 | /// isPassDebuggingExecutionsOrMore - Return true if -debug-pass=Executions | |||
| 65 | /// or higher is specified. | |||
| 66 | bool PMDataManager::isPassDebuggingExecutionsOrMore() const { | |||
| 67 | return PassDebugging >= Executions; | |||
| 68 | } | |||
| 69 | ||||
| 70 | unsigned PMDataManager::initSizeRemarkInfo( | |||
| 71 | Module &M, StringMap<std::pair<unsigned, unsigned>> &FunctionToInstrCount) { | |||
| 72 | // Only calculate getInstructionCount if the size-info remark is requested. | |||
| 73 | unsigned InstrCount = 0; | |||
| 74 | ||||
| 75 | // Collect instruction counts for every function. We'll use this to emit | |||
| 76 | // per-function size remarks later. | |||
| 77 | for (Function &F : M) { | |||
| 78 | unsigned FCount = F.getInstructionCount(); | |||
| 79 | ||||
| 80 | // Insert a record into FunctionToInstrCount keeping track of the current | |||
| 81 | // size of the function as the first member of a pair. Set the second | |||
| 82 | // member to 0; if the function is deleted by the pass, then when we get | |||
| 83 | // here, we'll be able to let the user know that F no longer contributes to | |||
| 84 | // the module. | |||
| 85 | FunctionToInstrCount[F.getName().str()] = | |||
| 86 | std::pair<unsigned, unsigned>(FCount, 0); | |||
| 87 | InstrCount += FCount; | |||
| 88 | } | |||
| 89 | return InstrCount; | |||
| 90 | } | |||
| 91 | ||||
| 92 | void PMDataManager::emitInstrCountChangedRemark( | |||
| 93 | Pass *P, Module &M, int64_t Delta, unsigned CountBefore, | |||
| 94 | StringMap<std::pair<unsigned, unsigned>> &FunctionToInstrCount, | |||
| 95 | Function *F) { | |||
| 96 | // If it's a pass manager, don't emit a remark. (This hinges on the assumption | |||
| 97 | // that the only passes that return non-null with getAsPMDataManager are pass | |||
| 98 | // managers.) The reason we have to do this is to avoid emitting remarks for | |||
| 99 | // CGSCC passes. | |||
| 100 | if (P->getAsPMDataManager()) | |||
| 101 | return; | |||
| 102 | ||||
| 103 | // Set to true if this isn't a module pass or CGSCC pass. | |||
| 104 | bool CouldOnlyImpactOneFunction = (F != nullptr); | |||
| 105 | ||||
| 106 | // Helper lambda that updates the changes to the size of some function. | |||
| 107 | auto UpdateFunctionChanges = | |||
| 108 | [&FunctionToInstrCount](Function &MaybeChangedFn) { | |||
| 109 | // Update the total module count. | |||
| 110 | unsigned FnSize = MaybeChangedFn.getInstructionCount(); | |||
| 111 | auto It = FunctionToInstrCount.find(MaybeChangedFn.getName()); | |||
| 112 | ||||
| 113 | // If we created a new function, then we need to add it to the map and | |||
| 114 | // say that it changed from 0 instructions to FnSize. | |||
| 115 | if (It == FunctionToInstrCount.end()) { | |||
| 116 | FunctionToInstrCount[MaybeChangedFn.getName()] = | |||
| 117 | std::pair<unsigned, unsigned>(0, FnSize); | |||
| 118 | return; | |||
| 119 | } | |||
| 120 | // Insert the new function size into the second member of the pair. This | |||
| 121 | // tells us whether or not this function changed in size. | |||
| 122 | It->second.second = FnSize; | |||
| 123 | }; | |||
| 124 | ||||
| 125 | // We need to initially update all of the function sizes. | |||
| 126 | // If no function was passed in, then we're either a module pass or an | |||
| 127 | // CGSCC pass. | |||
| 128 | if (!CouldOnlyImpactOneFunction) | |||
| 129 | std::for_each(M.begin(), M.end(), UpdateFunctionChanges); | |||
| 130 | else | |||
| 131 | UpdateFunctionChanges(*F); | |||
| 132 | ||||
| 133 | // Do we have a function we can use to emit a remark? | |||
| 134 | if (!CouldOnlyImpactOneFunction) { | |||
| 135 | // We need a function containing at least one basic block in order to output | |||
| 136 | // remarks. Since it's possible that the first function in the module | |||
| 137 | // doesn't actually contain a basic block, we have to go and find one that's | |||
| 138 | // suitable for emitting remarks. | |||
| 139 | auto It = llvm::find_if(M, [](const Function &Fn) { return !Fn.empty(); }); | |||
| 140 | ||||
| 141 | // Didn't find a function. Quit. | |||
| 142 | if (It == M.end()) | |||
| 143 | return; | |||
| 144 | ||||
| 145 | // We found a function containing at least one basic block. | |||
| 146 | F = &*It; | |||
| 147 | } | |||
| 148 | int64_t CountAfter = static_cast<int64_t>(CountBefore) + Delta; | |||
| 149 | BasicBlock &BB = *F->begin(); | |||
| 150 | OptimizationRemarkAnalysis R("size-info", "IRSizeChange", | |||
| 151 | DiagnosticLocation(), &BB); | |||
| 152 | // FIXME: Move ore namespace to DiagnosticInfo so that we can use it. This | |||
| 153 | // would let us use NV instead of DiagnosticInfoOptimizationBase::Argument. | |||
| 154 | R << DiagnosticInfoOptimizationBase::Argument("Pass", P->getPassName()) | |||
| 155 | << ": IR instruction count changed from " | |||
| 156 | << DiagnosticInfoOptimizationBase::Argument("IRInstrsBefore", CountBefore) | |||
| 157 | << " to " | |||
| 158 | << DiagnosticInfoOptimizationBase::Argument("IRInstrsAfter", CountAfter) | |||
| 159 | << "; Delta: " | |||
| 160 | << DiagnosticInfoOptimizationBase::Argument("DeltaInstrCount", Delta); | |||
| 161 | F->getContext().diagnose(R); // Not using ORE for layering reasons. | |||
| 162 | ||||
| 163 | // Emit per-function size change remarks separately. | |||
| 164 | std::string PassName = P->getPassName().str(); | |||
| 165 | ||||
| 166 | // Helper lambda that emits a remark when the size of a function has changed. | |||
| 167 | auto EmitFunctionSizeChangedRemark = [&FunctionToInstrCount, &F, &BB, | |||
| 168 | &PassName](StringRef Fname) { | |||
| 169 | unsigned FnCountBefore, FnCountAfter; | |||
| 170 | std::pair<unsigned, unsigned> &Change = FunctionToInstrCount[Fname]; | |||
| 171 | std::tie(FnCountBefore, FnCountAfter) = Change; | |||
| 172 | int64_t FnDelta = static_cast<int64_t>(FnCountAfter) - | |||
| 173 | static_cast<int64_t>(FnCountBefore); | |||
| 174 | ||||
| 175 | if (FnDelta == 0) | |||
| 176 | return; | |||
| 177 | ||||
| 178 | // FIXME: We shouldn't use BB for the location here. Unfortunately, because | |||
| 179 | // the function that we're looking at could have been deleted, we can't use | |||
| 180 | // it for the source location. We *want* remarks when a function is deleted | |||
| 181 | // though, so we're kind of stuck here as is. (This remark, along with the | |||
| 182 | // whole-module size change remarks really ought not to have source | |||
| 183 | // locations at all.) | |||
| 184 | OptimizationRemarkAnalysis FR("size-info", "FunctionIRSizeChange", | |||
| 185 | DiagnosticLocation(), &BB); | |||
| 186 | FR << DiagnosticInfoOptimizationBase::Argument("Pass", PassName) | |||
| 187 | << ": Function: " | |||
| 188 | << DiagnosticInfoOptimizationBase::Argument("Function", Fname) | |||
| 189 | << ": IR instruction count changed from " | |||
| 190 | << DiagnosticInfoOptimizationBase::Argument("IRInstrsBefore", | |||
| 191 | FnCountBefore) | |||
| 192 | << " to " | |||
| 193 | << DiagnosticInfoOptimizationBase::Argument("IRInstrsAfter", | |||
| 194 | FnCountAfter) | |||
| 195 | << "; Delta: " | |||
| 196 | << DiagnosticInfoOptimizationBase::Argument("DeltaInstrCount", FnDelta); | |||
| 197 | F->getContext().diagnose(FR); | |||
| 198 | ||||
| 199 | // Update the function size. | |||
| 200 | Change.first = FnCountAfter; | |||
| 201 | }; | |||
| 202 | ||||
| 203 | // Are we looking at more than one function? If so, emit remarks for all of | |||
| 204 | // the functions in the module. Otherwise, only emit one remark. | |||
| 205 | if (!CouldOnlyImpactOneFunction) | |||
| 206 | std::for_each(FunctionToInstrCount.keys().begin(), | |||
| 207 | FunctionToInstrCount.keys().end(), | |||
| 208 | EmitFunctionSizeChangedRemark); | |||
| 209 | else | |||
| 210 | EmitFunctionSizeChangedRemark(F->getName().str()); | |||
| 211 | } | |||
| 212 | ||||
| 213 | void PassManagerPrettyStackEntry::print(raw_ostream &OS) const { | |||
| 214 | if (!V && !M) | |||
| 215 | OS << "Releasing pass '"; | |||
| 216 | else | |||
| 217 | OS << "Running pass '"; | |||
| 218 | ||||
| 219 | OS << P->getPassName() << "'"; | |||
| 220 | ||||
| 221 | if (M) { | |||
| 222 | OS << " on module '" << M->getModuleIdentifier() << "'.\n"; | |||
| 223 | return; | |||
| 224 | } | |||
| 225 | if (!V) { | |||
| 226 | OS << '\n'; | |||
| 227 | return; | |||
| 228 | } | |||
| 229 | ||||
| 230 | OS << " on "; | |||
| 231 | if (isa<Function>(V)) | |||
| 232 | OS << "function"; | |||
| 233 | else if (isa<BasicBlock>(V)) | |||
| 234 | OS << "basic block"; | |||
| 235 | else | |||
| 236 | OS << "value"; | |||
| 237 | ||||
| 238 | OS << " '"; | |||
| 239 | V->printAsOperand(OS, /*PrintType=*/false, M); | |||
| 240 | OS << "'\n"; | |||
| 241 | } | |||
| 242 | ||||
| 243 | namespace llvm { | |||
| 244 | namespace legacy { | |||
| 245 | bool debugPassSpecified() { return PassDebugging != Disabled; } | |||
| 246 | ||||
| 247 | //===----------------------------------------------------------------------===// | |||
| 248 | // FunctionPassManagerImpl | |||
| 249 | // | |||
| 250 | /// FunctionPassManagerImpl manages FPPassManagers | |||
| 251 | class FunctionPassManagerImpl : public Pass, | |||
| 252 | public PMDataManager, | |||
| 253 | public PMTopLevelManager { | |||
| 254 | virtual void anchor(); | |||
| 255 | private: | |||
| 256 | bool wasRun; | |||
| 257 | public: | |||
| 258 | static char ID; | |||
| 259 | explicit FunctionPassManagerImpl() : | |||
| 260 | Pass(PT_PassManager, ID), PMDataManager(), | |||
| 261 | PMTopLevelManager(new FPPassManager()), wasRun(false) {} | |||
| 262 | ||||
| 263 | /// \copydoc FunctionPassManager::add() | |||
| 264 | void add(Pass *P) { | |||
| 265 | schedulePass(P); | |||
| 266 | } | |||
| 267 | ||||
| 268 | /// createPrinterPass - Get a function printer pass. | |||
| 269 | Pass *createPrinterPass(raw_ostream &O, | |||
| 270 | const std::string &Banner) const override { | |||
| 271 | return createPrintFunctionPass(O, Banner); | |||
| 272 | } | |||
| 273 | ||||
| 274 | // Prepare for running an on the fly pass, freeing memory if needed | |||
| 275 | // from a previous run. | |||
| 276 | void releaseMemoryOnTheFly(); | |||
| 277 | ||||
| 278 | /// run - Execute all of the passes scheduled for execution. Keep track of | |||
| 279 | /// whether any of the passes modifies the module, and if so, return true. | |||
| 280 | bool run(Function &F); | |||
| 281 | ||||
| 282 | /// doInitialization - Run all of the initializers for the function passes. | |||
| 283 | /// | |||
| 284 | bool doInitialization(Module &M) override; | |||
| 285 | ||||
| 286 | /// doFinalization - Run all of the finalizers for the function passes. | |||
| 287 | /// | |||
| 288 | bool doFinalization(Module &M) override; | |||
| 289 | ||||
| 290 | ||||
| 291 | PMDataManager *getAsPMDataManager() override { return this; } | |||
| 292 | Pass *getAsPass() override { return this; } | |||
| 293 | PassManagerType getTopLevelPassManagerType() override { | |||
| 294 | return PMT_FunctionPassManager; | |||
| 295 | } | |||
| 296 | ||||
| 297 | /// Pass Manager itself does not invalidate any analysis info. | |||
| 298 | void getAnalysisUsage(AnalysisUsage &Info) const override { | |||
| 299 | Info.setPreservesAll(); | |||
| 300 | } | |||
| 301 | ||||
| 302 | FPPassManager *getContainedManager(unsigned N) { | |||
| 303 | assert(N < PassManagers.size() && "Pass number out of range!")((void)0); | |||
| 304 | FPPassManager *FP = static_cast<FPPassManager *>(PassManagers[N]); | |||
| 305 | return FP; | |||
| 306 | } | |||
| 307 | ||||
| 308 | void dumpPassStructure(unsigned Offset) override { | |||
| 309 | for (unsigned I = 0; I < getNumContainedManagers(); ++I) | |||
| 310 | getContainedManager(I)->dumpPassStructure(Offset); | |||
| 311 | } | |||
| 312 | }; | |||
| 313 | ||||
| 314 | void FunctionPassManagerImpl::anchor() {} | |||
| 315 | ||||
| 316 | char FunctionPassManagerImpl::ID = 0; | |||
| 317 | ||||
| 318 | //===----------------------------------------------------------------------===// | |||
| 319 | // FunctionPassManagerImpl implementation | |||
| 320 | // | |||
| 321 | bool FunctionPassManagerImpl::doInitialization(Module &M) { | |||
| 322 | bool Changed = false; | |||
| 323 | ||||
| 324 | dumpArguments(); | |||
| 325 | dumpPasses(); | |||
| 326 | ||||
| 327 | for (ImmutablePass *ImPass : getImmutablePasses()) | |||
| 328 | Changed |= ImPass->doInitialization(M); | |||
| 329 | ||||
| 330 | for (unsigned Index = 0; Index < getNumContainedManagers(); ++Index) | |||
| 331 | Changed |= getContainedManager(Index)->doInitialization(M); | |||
| 332 | ||||
| 333 | return Changed; | |||
| 334 | } | |||
| 335 | ||||
| 336 | bool FunctionPassManagerImpl::doFinalization(Module &M) { | |||
| 337 | bool Changed = false; | |||
| 338 | ||||
| 339 | for (int Index = getNumContainedManagers() - 1; Index >= 0; --Index) | |||
| 340 | Changed |= getContainedManager(Index)->doFinalization(M); | |||
| 341 | ||||
| 342 | for (ImmutablePass *ImPass : getImmutablePasses()) | |||
| 343 | Changed |= ImPass->doFinalization(M); | |||
| 344 | ||||
| 345 | return Changed; | |||
| 346 | } | |||
| 347 | ||||
| 348 | void FunctionPassManagerImpl::releaseMemoryOnTheFly() { | |||
| 349 | if (!wasRun) | |||
| 350 | return; | |||
| 351 | for (unsigned Index = 0; Index < getNumContainedManagers(); ++Index) { | |||
| 352 | FPPassManager *FPPM = getContainedManager(Index); | |||
| 353 | for (unsigned Index = 0; Index < FPPM->getNumContainedPasses(); ++Index) { | |||
| 354 | FPPM->getContainedPass(Index)->releaseMemory(); | |||
| 355 | } | |||
| 356 | } | |||
| 357 | wasRun = false; | |||
| 358 | } | |||
| 359 | ||||
| 360 | // Execute all the passes managed by this top level manager. | |||
| 361 | // Return true if any function is modified by a pass. | |||
| 362 | bool FunctionPassManagerImpl::run(Function &F) { | |||
| 363 | bool Changed = false; | |||
| 364 | ||||
| 365 | initializeAllAnalysisInfo(); | |||
| 366 | for (unsigned Index = 0; Index < getNumContainedManagers(); ++Index) { | |||
| 367 | Changed |= getContainedManager(Index)->runOnFunction(F); | |||
| 368 | F.getContext().yield(); | |||
| 369 | } | |||
| 370 | ||||
| 371 | for (unsigned Index = 0; Index < getNumContainedManagers(); ++Index) | |||
| 372 | getContainedManager(Index)->cleanup(); | |||
| 373 | ||||
| 374 | wasRun = true; | |||
| 375 | return Changed; | |||
| 376 | } | |||
| 377 | } // namespace legacy | |||
| 378 | } // namespace llvm | |||
| 379 | ||||
| 380 | namespace { | |||
| 381 | //===----------------------------------------------------------------------===// | |||
| 382 | // MPPassManager | |||
| 383 | // | |||
| 384 | /// MPPassManager manages ModulePasses and function pass managers. | |||
| 385 | /// It batches all Module passes and function pass managers together and | |||
| 386 | /// sequences them to process one module. | |||
| 387 | class MPPassManager : public Pass, public PMDataManager { | |||
| 388 | public: | |||
| 389 | static char ID; | |||
| 390 | explicit MPPassManager() : | |||
| 391 | Pass(PT_PassManager, ID), PMDataManager() { } | |||
| 392 | ||||
| 393 | // Delete on the fly managers. | |||
| 394 | ~MPPassManager() override { | |||
| 395 | for (auto &OnTheFlyManager : OnTheFlyManagers) { | |||
| 396 | legacy::FunctionPassManagerImpl *FPP = OnTheFlyManager.second; | |||
| 397 | delete FPP; | |||
| 398 | } | |||
| 399 | } | |||
| 400 | ||||
| 401 | /// createPrinterPass - Get a module printer pass. | |||
| 402 | Pass *createPrinterPass(raw_ostream &O, | |||
| 403 | const std::string &Banner) const override { | |||
| 404 | return createPrintModulePass(O, Banner); | |||
| 405 | } | |||
| 406 | ||||
| 407 | /// run - Execute all of the passes scheduled for execution. Keep track of | |||
| 408 | /// whether any of the passes modifies the module, and if so, return true. | |||
| 409 | bool runOnModule(Module &M); | |||
| 410 | ||||
| 411 | using llvm::Pass::doInitialization; | |||
| 412 | using llvm::Pass::doFinalization; | |||
| 413 | ||||
| 414 | /// Pass Manager itself does not invalidate any analysis info. | |||
| 415 | void getAnalysisUsage(AnalysisUsage &Info) const override { | |||
| 416 | Info.setPreservesAll(); | |||
| 417 | } | |||
| 418 | ||||
| 419 | /// Add RequiredPass into list of lower level passes required by pass P. | |||
| 420 | /// RequiredPass is run on the fly by Pass Manager when P requests it | |||
| 421 | /// through getAnalysis interface. | |||
| 422 | void addLowerLevelRequiredPass(Pass *P, Pass *RequiredPass) override; | |||
| 423 | ||||
| 424 | /// Return function pass corresponding to PassInfo PI, that is | |||
| 425 | /// required by module pass MP. Instantiate analysis pass, by using | |||
| 426 | /// its runOnFunction() for function F. | |||
| 427 | std::tuple<Pass *, bool> getOnTheFlyPass(Pass *MP, AnalysisID PI, | |||
| 428 | Function &F) override; | |||
| 429 | ||||
| 430 | StringRef getPassName() const override { return "Module Pass Manager"; } | |||
| 431 | ||||
| 432 | PMDataManager *getAsPMDataManager() override { return this; } | |||
| 433 | Pass *getAsPass() override { return this; } | |||
| 434 | ||||
| 435 | // Print passes managed by this manager | |||
| 436 | void dumpPassStructure(unsigned Offset) override { | |||
| 437 | dbgs().indent(Offset*2) << "ModulePass Manager\n"; | |||
| 438 | for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) { | |||
| 439 | ModulePass *MP = getContainedPass(Index); | |||
| 440 | MP->dumpPassStructure(Offset + 1); | |||
| 441 | MapVector<Pass *, legacy::FunctionPassManagerImpl *>::const_iterator I = | |||
| 442 | OnTheFlyManagers.find(MP); | |||
| 443 | if (I != OnTheFlyManagers.end()) | |||
| 444 | I->second->dumpPassStructure(Offset + 2); | |||
| 445 | dumpLastUses(MP, Offset+1); | |||
| 446 | } | |||
| 447 | } | |||
| 448 | ||||
| 449 | ModulePass *getContainedPass(unsigned N) { | |||
| 450 | assert(N < PassVector.size() && "Pass number out of range!")((void)0); | |||
| 451 | return static_cast<ModulePass *>(PassVector[N]); | |||
| 452 | } | |||
| 453 | ||||
| 454 | PassManagerType getPassManagerType() const override { | |||
| 455 | return PMT_ModulePassManager; | |||
| 456 | } | |||
| 457 | ||||
| 458 | private: | |||
| 459 | /// Collection of on the fly FPPassManagers. These managers manage | |||
| 460 | /// function passes that are required by module passes. | |||
| 461 | MapVector<Pass *, legacy::FunctionPassManagerImpl *> OnTheFlyManagers; | |||
| 462 | }; | |||
| 463 | ||||
| 464 | char MPPassManager::ID = 0; | |||
| 465 | } // End anonymous namespace | |||
| 466 | ||||
| 467 | namespace llvm { | |||
| 468 | namespace legacy { | |||
| 469 | //===----------------------------------------------------------------------===// | |||
| 470 | // PassManagerImpl | |||
| 471 | // | |||
| 472 | ||||
| 473 | /// PassManagerImpl manages MPPassManagers | |||
| 474 | class PassManagerImpl : public Pass, | |||
| 475 | public PMDataManager, | |||
| 476 | public PMTopLevelManager { | |||
| 477 | virtual void anchor(); | |||
| 478 | ||||
| 479 | public: | |||
| 480 | static char ID; | |||
| 481 | explicit PassManagerImpl() : | |||
| 482 | Pass(PT_PassManager, ID), PMDataManager(), | |||
| 483 | PMTopLevelManager(new MPPassManager()) {} | |||
| 484 | ||||
| 485 | /// \copydoc PassManager::add() | |||
| 486 | void add(Pass *P) { | |||
| 487 | schedulePass(P); | |||
| 488 | } | |||
| 489 | ||||
| 490 | /// createPrinterPass - Get a module printer pass. | |||
| 491 | Pass *createPrinterPass(raw_ostream &O, | |||
| 492 | const std::string &Banner) const override { | |||
| 493 | return createPrintModulePass(O, Banner); | |||
| 494 | } | |||
| 495 | ||||
| 496 | /// run - Execute all of the passes scheduled for execution. Keep track of | |||
| 497 | /// whether any of the passes modifies the module, and if so, return true. | |||
| 498 | bool run(Module &M); | |||
| 499 | ||||
| 500 | using llvm::Pass::doInitialization; | |||
| 501 | using llvm::Pass::doFinalization; | |||
| 502 | ||||
| 503 | /// Pass Manager itself does not invalidate any analysis info. | |||
| 504 | void getAnalysisUsage(AnalysisUsage &Info) const override { | |||
| 505 | Info.setPreservesAll(); | |||
| 506 | } | |||
| 507 | ||||
| 508 | PMDataManager *getAsPMDataManager() override { return this; } | |||
| 509 | Pass *getAsPass() override { return this; } | |||
| 510 | PassManagerType getTopLevelPassManagerType() override { | |||
| 511 | return PMT_ModulePassManager; | |||
| 512 | } | |||
| 513 | ||||
| 514 | MPPassManager *getContainedManager(unsigned N) { | |||
| 515 | assert(N < PassManagers.size() && "Pass number out of range!")((void)0); | |||
| 516 | MPPassManager *MP = static_cast<MPPassManager *>(PassManagers[N]); | |||
| 517 | return MP; | |||
| 518 | } | |||
| 519 | }; | |||
| 520 | ||||
| 521 | void PassManagerImpl::anchor() {} | |||
| 522 | ||||
| 523 | char PassManagerImpl::ID = 0; | |||
| 524 | ||||
| 525 | //===----------------------------------------------------------------------===// | |||
| 526 | // PassManagerImpl implementation | |||
| 527 | ||||
| 528 | // | |||
| 529 | /// run - Execute all of the passes scheduled for execution. Keep track of | |||
| 530 | /// whether any of the passes modifies the module, and if so, return true. | |||
| 531 | bool PassManagerImpl::run(Module &M) { | |||
| 532 | bool Changed = false; | |||
| 533 | ||||
| 534 | dumpArguments(); | |||
| 535 | dumpPasses(); | |||
| 536 | ||||
| 537 | for (ImmutablePass *ImPass : getImmutablePasses()) | |||
| 538 | Changed |= ImPass->doInitialization(M); | |||
| 539 | ||||
| 540 | initializeAllAnalysisInfo(); | |||
| 541 | for (unsigned Index = 0; Index < getNumContainedManagers(); ++Index) { | |||
| 542 | Changed |= getContainedManager(Index)->runOnModule(M); | |||
| 543 | M.getContext().yield(); | |||
| 544 | } | |||
| 545 | ||||
| 546 | for (ImmutablePass *ImPass : getImmutablePasses()) | |||
| 547 | Changed |= ImPass->doFinalization(M); | |||
| 548 | ||||
| 549 | return Changed; | |||
| 550 | } | |||
| 551 | } // namespace legacy | |||
| 552 | } // namespace llvm | |||
| 553 | ||||
| 554 | //===----------------------------------------------------------------------===// | |||
| 555 | // PMTopLevelManager implementation | |||
| 556 | ||||
| 557 | /// Initialize top level manager. Create first pass manager. | |||
| 558 | PMTopLevelManager::PMTopLevelManager(PMDataManager *PMDM) { | |||
| 559 | PMDM->setTopLevelManager(this); | |||
| 560 | addPassManager(PMDM); | |||
| 561 | activeStack.push(PMDM); | |||
| 562 | } | |||
| 563 | ||||
| 564 | /// Set pass P as the last user of the given analysis passes. | |||
| 565 | void | |||
| 566 | PMTopLevelManager::setLastUser(ArrayRef<Pass*> AnalysisPasses, Pass *P) { | |||
| 567 | unsigned PDepth = 0; | |||
| 568 | if (P->getResolver()) | |||
| 569 | PDepth = P->getResolver()->getPMDataManager().getDepth(); | |||
| 570 | ||||
| 571 | for (Pass *AP : AnalysisPasses) { | |||
| 572 | // Record P as the new last user of AP. | |||
| 573 | auto &LastUserOfAP = LastUser[AP]; | |||
| 574 | if (LastUserOfAP) | |||
| 575 | InversedLastUser[LastUserOfAP].erase(AP); | |||
| 576 | LastUserOfAP = P; | |||
| 577 | InversedLastUser[P].insert(AP); | |||
| 578 | ||||
| 579 | if (P == AP) | |||
| 580 | continue; | |||
| 581 | ||||
| 582 | // Update the last users of passes that are required transitive by AP. | |||
| 583 | AnalysisUsage *AnUsage = findAnalysisUsage(AP); | |||
| 584 | const AnalysisUsage::VectorType &IDs = AnUsage->getRequiredTransitiveSet(); | |||
| 585 | SmallVector<Pass *, 12> LastUses; | |||
| 586 | SmallVector<Pass *, 12> LastPMUses; | |||
| 587 | for (AnalysisID ID : IDs) { | |||
| 588 | Pass *AnalysisPass = findAnalysisPass(ID); | |||
| 589 | assert(AnalysisPass && "Expected analysis pass to exist.")((void)0); | |||
| 590 | AnalysisResolver *AR = AnalysisPass->getResolver(); | |||
| 591 | assert(AR && "Expected analysis resolver to exist.")((void)0); | |||
| 592 | unsigned APDepth = AR->getPMDataManager().getDepth(); | |||
| 593 | ||||
| 594 | if (PDepth == APDepth) | |||
| 595 | LastUses.push_back(AnalysisPass); | |||
| 596 | else if (PDepth > APDepth) | |||
| 597 | LastPMUses.push_back(AnalysisPass); | |||
| 598 | } | |||
| 599 | ||||
| 600 | setLastUser(LastUses, P); | |||
| 601 | ||||
| 602 | // If this pass has a corresponding pass manager, push higher level | |||
| 603 | // analysis to this pass manager. | |||
| 604 | if (P->getResolver()) | |||
| 605 | setLastUser(LastPMUses, P->getResolver()->getPMDataManager().getAsPass()); | |||
| 606 | ||||
| 607 | // If AP is the last user of other passes then make P last user of | |||
| 608 | // such passes. | |||
| 609 | auto &LastUsedByAP = InversedLastUser[AP]; | |||
| 610 | for (Pass *L : LastUsedByAP) | |||
| 611 | LastUser[L] = P; | |||
| 612 | InversedLastUser[P].insert(LastUsedByAP.begin(), LastUsedByAP.end()); | |||
| 613 | LastUsedByAP.clear(); | |||
| 614 | } | |||
| 615 | } | |||
| 616 | ||||
| 617 | /// Collect passes whose last user is P | |||
| 618 | void PMTopLevelManager::collectLastUses(SmallVectorImpl<Pass *> &LastUses, | |||
| 619 | Pass *P) { | |||
| 620 | auto DMI = InversedLastUser.find(P); | |||
| 621 | if (DMI == InversedLastUser.end()) | |||
| 622 | return; | |||
| 623 | ||||
| 624 | auto &LU = DMI->second; | |||
| 625 | LastUses.append(LU.begin(), LU.end()); | |||
| 626 | } | |||
| 627 | ||||
| 628 | AnalysisUsage *PMTopLevelManager::findAnalysisUsage(Pass *P) { | |||
| 629 | AnalysisUsage *AnUsage = nullptr; | |||
| 630 | auto DMI = AnUsageMap.find(P); | |||
| 631 | if (DMI != AnUsageMap.end()) | |||
| 632 | AnUsage = DMI->second; | |||
| 633 | else { | |||
| 634 | // Look up the analysis usage from the pass instance (different instances | |||
| 635 | // of the same pass can produce different results), but unique the | |||
| 636 | // resulting object to reduce memory usage. This helps to greatly reduce | |||
| 637 | // memory usage when we have many instances of only a few pass types | |||
| 638 | // (e.g. instcombine, simplifycfg, etc...) which tend to share a fixed set | |||
| 639 | // of dependencies. | |||
| 640 | AnalysisUsage AU; | |||
| 641 | P->getAnalysisUsage(AU); | |||
| 642 | ||||
| 643 | AUFoldingSetNode* Node = nullptr; | |||
| 644 | FoldingSetNodeID ID; | |||
| 645 | AUFoldingSetNode::Profile(ID, AU); | |||
| 646 | void *IP = nullptr; | |||
| 647 | if (auto *N = UniqueAnalysisUsages.FindNodeOrInsertPos(ID, IP)) | |||
| 648 | Node = N; | |||
| 649 | else { | |||
| 650 | Node = new (AUFoldingSetNodeAllocator.Allocate()) AUFoldingSetNode(AU); | |||
| 651 | UniqueAnalysisUsages.InsertNode(Node, IP); | |||
| 652 | } | |||
| 653 | assert(Node && "cached analysis usage must be non null")((void)0); | |||
| 654 | ||||
| 655 | AnUsageMap[P] = &Node->AU; | |||
| 656 | AnUsage = &Node->AU; | |||
| 657 | } | |||
| 658 | return AnUsage; | |||
| 659 | } | |||
| 660 | ||||
| 661 | /// Schedule pass P for execution. Make sure that passes required by | |||
| 662 | /// P are run before P is run. Update analysis info maintained by | |||
| 663 | /// the manager. Remove dead passes. This is a recursive function. | |||
| 664 | void PMTopLevelManager::schedulePass(Pass *P) { | |||
| 665 | ||||
| 666 | // TODO : Allocate function manager for this pass, other wise required set | |||
| 667 | // may be inserted into previous function manager | |||
| 668 | ||||
| 669 | // Give pass a chance to prepare the stage. | |||
| 670 | P->preparePassManager(activeStack); | |||
| 671 | ||||
| 672 | // If P is an analysis pass and it is available then do not | |||
| 673 | // generate the analysis again. Stale analysis info should not be | |||
| 674 | // available at this point. | |||
| 675 | const PassInfo *PI = findAnalysisPassInfo(P->getPassID()); | |||
| 676 | if (PI
| |||
| 677 | // Remove any cached AnalysisUsage information. | |||
| 678 | AnUsageMap.erase(P); | |||
| 679 | delete P; | |||
| 680 | return; | |||
| 681 | } | |||
| 682 | ||||
| 683 | AnalysisUsage *AnUsage = findAnalysisUsage(P); | |||
| 684 | ||||
| 685 | bool checkAnalysis = true; | |||
| 686 | while (checkAnalysis) { | |||
| 687 | checkAnalysis = false; | |||
| 688 | ||||
| 689 | const AnalysisUsage::VectorType &RequiredSet = AnUsage->getRequiredSet(); | |||
| 690 | for (const AnalysisID ID : RequiredSet) { | |||
| 691 | ||||
| 692 | Pass *AnalysisPass = findAnalysisPass(ID); | |||
| 693 | if (!AnalysisPass) { | |||
| 694 | const PassInfo *PI = findAnalysisPassInfo(ID); | |||
| 695 | ||||
| 696 | if (!PI) { | |||
| 697 | // Pass P is not in the global PassRegistry | |||
| 698 | dbgs() << "Pass '" << P->getPassName() << "' is not initialized." << "\n"; | |||
| 699 | dbgs() << "Verify if there is a pass dependency cycle." << "\n"; | |||
| 700 | dbgs() << "Required Passes:" << "\n"; | |||
| 701 | for (const AnalysisID ID2 : RequiredSet) { | |||
| 702 | if (ID == ID2) | |||
| 703 | break; | |||
| 704 | Pass *AnalysisPass2 = findAnalysisPass(ID2); | |||
| 705 | if (AnalysisPass2) { | |||
| 706 | dbgs() << "\t" << AnalysisPass2->getPassName() << "\n"; | |||
| 707 | } else { | |||
| 708 | dbgs() << "\t" << "Error: Required pass not found! Possible causes:" << "\n"; | |||
| 709 | dbgs() << "\t\t" << "- Pass misconfiguration (e.g.: missing macros)" << "\n"; | |||
| 710 | dbgs() << "\t\t" << "- Corruption of the global PassRegistry" << "\n"; | |||
| 711 | } | |||
| 712 | } | |||
| 713 | } | |||
| 714 | ||||
| 715 | assert(PI && "Expected required passes to be initialized")((void)0); | |||
| 716 | AnalysisPass = PI->createPass(); | |||
| ||||
| 717 | if (P->getPotentialPassManagerType () == | |||
| 718 | AnalysisPass->getPotentialPassManagerType()) | |||
| 719 | // Schedule analysis pass that is managed by the same pass manager. | |||
| 720 | schedulePass(AnalysisPass); | |||
| 721 | else if (P->getPotentialPassManagerType () > | |||
| 722 | AnalysisPass->getPotentialPassManagerType()) { | |||
| 723 | // Schedule analysis pass that is managed by a new manager. | |||
| 724 | schedulePass(AnalysisPass); | |||
| 725 | // Recheck analysis passes to ensure that required analyses that | |||
| 726 | // are already checked are still available. | |||
| 727 | checkAnalysis = true; | |||
| 728 | } else | |||
| 729 | // Do not schedule this analysis. Lower level analysis | |||
| 730 | // passes are run on the fly. | |||
| 731 | delete AnalysisPass; | |||
| 732 | } | |||
| 733 | } | |||
| 734 | } | |||
| 735 | ||||
| 736 | // Now all required passes are available. | |||
| 737 | if (ImmutablePass *IP = P->getAsImmutablePass()) { | |||
| 738 | // P is a immutable pass and it will be managed by this | |||
| 739 | // top level manager. Set up analysis resolver to connect them. | |||
| 740 | PMDataManager *DM = getAsPMDataManager(); | |||
| 741 | AnalysisResolver *AR = new AnalysisResolver(*DM); | |||
| 742 | P->setResolver(AR); | |||
| 743 | DM->initializeAnalysisImpl(P); | |||
| 744 | addImmutablePass(IP); | |||
| 745 | DM->recordAvailableAnalysis(IP); | |||
| 746 | return; | |||
| 747 | } | |||
| 748 | ||||
| 749 | if (PI && !PI->isAnalysis() && shouldPrintBeforePass(PI->getPassArgument())) { | |||
| 750 | Pass *PP = | |||
| 751 | P->createPrinterPass(dbgs(), ("*** IR Dump Before " + P->getPassName() + | |||
| 752 | " (" + PI->getPassArgument() + ") ***") | |||
| 753 | .str()); | |||
| 754 | PP->assignPassManager(activeStack, getTopLevelPassManagerType()); | |||
| 755 | } | |||
| 756 | ||||
| 757 | // Add the requested pass to the best available pass manager. | |||
| 758 | P->assignPassManager(activeStack, getTopLevelPassManagerType()); | |||
| 759 | ||||
| 760 | if (PI && !PI->isAnalysis() && shouldPrintAfterPass(PI->getPassArgument())) { | |||
| 761 | Pass *PP = | |||
| 762 | P->createPrinterPass(dbgs(), ("*** IR Dump After " + P->getPassName() + | |||
| 763 | " (" + PI->getPassArgument() + ") ***") | |||
| 764 | .str()); | |||
| 765 | PP->assignPassManager(activeStack, getTopLevelPassManagerType()); | |||
| 766 | } | |||
| 767 | } | |||
| 768 | ||||
| 769 | /// Find the pass that implements Analysis AID. Search immutable | |||
| 770 | /// passes and all pass managers. If desired pass is not found | |||
| 771 | /// then return NULL. | |||
| 772 | Pass *PMTopLevelManager::findAnalysisPass(AnalysisID AID) { | |||
| 773 | // For immutable passes we have a direct mapping from ID to pass, so check | |||
| 774 | // that first. | |||
| 775 | if (Pass *P = ImmutablePassMap.lookup(AID)) | |||
| 776 | return P; | |||
| 777 | ||||
| 778 | // Check pass managers | |||
| 779 | for (PMDataManager *PassManager : PassManagers) | |||
| 780 | if (Pass *P = PassManager->findAnalysisPass(AID, false)) | |||
| 781 | return P; | |||
| 782 | ||||
| 783 | // Check other pass managers | |||
| 784 | for (PMDataManager *IndirectPassManager : IndirectPassManagers) | |||
| 785 | if (Pass *P = IndirectPassManager->findAnalysisPass(AID, false)) | |||
| 786 | return P; | |||
| 787 | ||||
| 788 | return nullptr; | |||
| 789 | } | |||
| 790 | ||||
| 791 | const PassInfo *PMTopLevelManager::findAnalysisPassInfo(AnalysisID AID) const { | |||
| 792 | const PassInfo *&PI = AnalysisPassInfos[AID]; | |||
| 793 | if (!PI) | |||
| 794 | PI = PassRegistry::getPassRegistry()->getPassInfo(AID); | |||
| 795 | else | |||
| 796 | assert(PI == PassRegistry::getPassRegistry()->getPassInfo(AID) &&((void)0) | |||
| 797 | "The pass info pointer changed for an analysis ID!")((void)0); | |||
| 798 | ||||
| 799 | return PI; | |||
| 800 | } | |||
| 801 | ||||
| 802 | void PMTopLevelManager::addImmutablePass(ImmutablePass *P) { | |||
| 803 | P->initializePass(); | |||
| 804 | ImmutablePasses.push_back(P); | |||
| 805 | ||||
| 806 | // Add this pass to the map from its analysis ID. We clobber any prior runs | |||
| 807 | // of the pass in the map so that the last one added is the one found when | |||
| 808 | // doing lookups. | |||
| 809 | AnalysisID AID = P->getPassID(); | |||
| 810 | ImmutablePassMap[AID] = P; | |||
| 811 | ||||
| 812 | // Also add any interfaces implemented by the immutable pass to the map for | |||
| 813 | // fast lookup. | |||
| 814 | const PassInfo *PassInf = findAnalysisPassInfo(AID); | |||
| 815 | assert(PassInf && "Expected all immutable passes to be initialized")((void)0); | |||
| 816 | for (const PassInfo *ImmPI : PassInf->getInterfacesImplemented()) | |||
| 817 | ImmutablePassMap[ImmPI->getTypeInfo()] = P; | |||
| 818 | } | |||
| 819 | ||||
| 820 | // Print passes managed by this top level manager. | |||
| 821 | void PMTopLevelManager::dumpPasses() const { | |||
| 822 | ||||
| 823 | if (PassDebugging < Structure) | |||
| 824 | return; | |||
| 825 | ||||
| 826 | // Print out the immutable passes | |||
| 827 | for (unsigned i = 0, e = ImmutablePasses.size(); i != e; ++i) { | |||
| 828 | ImmutablePasses[i]->dumpPassStructure(0); | |||
| 829 | } | |||
| 830 | ||||
| 831 | // Every class that derives from PMDataManager also derives from Pass | |||
| 832 | // (sometimes indirectly), but there's no inheritance relationship | |||
| 833 | // between PMDataManager and Pass, so we have to getAsPass to get | |||
| 834 | // from a PMDataManager* to a Pass*. | |||
| 835 | for (PMDataManager *Manager : PassManagers) | |||
| 836 | Manager->getAsPass()->dumpPassStructure(1); | |||
| 837 | } | |||
| 838 | ||||
| 839 | void PMTopLevelManager::dumpArguments() const { | |||
| 840 | ||||
| 841 | if (PassDebugging < Arguments) | |||
| 842 | return; | |||
| 843 | ||||
| 844 | dbgs() << "Pass Arguments: "; | |||
| 845 | for (ImmutablePass *P : ImmutablePasses) | |||
| 846 | if (const PassInfo *PI = findAnalysisPassInfo(P->getPassID())) { | |||
| 847 | assert(PI && "Expected all immutable passes to be initialized")((void)0); | |||
| 848 | if (!PI->isAnalysisGroup()) | |||
| 849 | dbgs() << " -" << PI->getPassArgument(); | |||
| 850 | } | |||
| 851 | for (PMDataManager *PM : PassManagers) | |||
| 852 | PM->dumpPassArguments(); | |||
| 853 | dbgs() << "\n"; | |||
| 854 | } | |||
| 855 | ||||
| 856 | void PMTopLevelManager::initializeAllAnalysisInfo() { | |||
| 857 | for (PMDataManager *PM : PassManagers) | |||
| 858 | PM->initializeAnalysisInfo(); | |||
| 859 | ||||
| 860 | // Initailize other pass managers | |||
| 861 | for (PMDataManager *IPM : IndirectPassManagers) | |||
| 862 | IPM->initializeAnalysisInfo(); | |||
| 863 | } | |||
| 864 | ||||
| 865 | /// Destructor | |||
| 866 | PMTopLevelManager::~PMTopLevelManager() { | |||
| 867 | for (PMDataManager *PM : PassManagers) | |||
| 868 | delete PM; | |||
| 869 | ||||
| 870 | for (ImmutablePass *P : ImmutablePasses) | |||
| 871 | delete P; | |||
| 872 | } | |||
| 873 | ||||
| 874 | //===----------------------------------------------------------------------===// | |||
| 875 | // PMDataManager implementation | |||
| 876 | ||||
| 877 | /// Augement AvailableAnalysis by adding analysis made available by pass P. | |||
| 878 | void PMDataManager::recordAvailableAnalysis(Pass *P) { | |||
| 879 | AnalysisID PI = P->getPassID(); | |||
| 880 | ||||
| 881 | AvailableAnalysis[PI] = P; | |||
| 882 | ||||
| 883 | assert(!AvailableAnalysis.empty())((void)0); | |||
| 884 | ||||
| 885 | // This pass is the current implementation of all of the interfaces it | |||
| 886 | // implements as well. | |||
| 887 | const PassInfo *PInf = TPM->findAnalysisPassInfo(PI); | |||
| 888 | if (!PInf) return; | |||
| 889 | const std::vector<const PassInfo*> &II = PInf->getInterfacesImplemented(); | |||
| 890 | for (unsigned i = 0, e = II.size(); i != e; ++i) | |||
| 891 | AvailableAnalysis[II[i]->getTypeInfo()] = P; | |||
| 892 | } | |||
| 893 | ||||
| 894 | // Return true if P preserves high level analysis used by other | |||
| 895 | // passes managed by this manager | |||
| 896 | bool PMDataManager::preserveHigherLevelAnalysis(Pass *P) { | |||
| 897 | AnalysisUsage *AnUsage = TPM->findAnalysisUsage(P); | |||
| 898 | if (AnUsage->getPreservesAll()) | |||
| 899 | return true; | |||
| 900 | ||||
| 901 | const AnalysisUsage::VectorType &PreservedSet = AnUsage->getPreservedSet(); | |||
| 902 | for (Pass *P1 : HigherLevelAnalysis) { | |||
| 903 | if (P1->getAsImmutablePass() == nullptr && | |||
| 904 | !is_contained(PreservedSet, P1->getPassID())) | |||
| 905 | return false; | |||
| 906 | } | |||
| 907 | ||||
| 908 | return true; | |||
| 909 | } | |||
| 910 | ||||
| 911 | /// verifyPreservedAnalysis -- Verify analysis preserved by pass P. | |||
| 912 | void PMDataManager::verifyPreservedAnalysis(Pass *P) { | |||
| 913 | // Don't do this unless assertions are enabled. | |||
| 914 | #ifdef NDEBUG1 | |||
| 915 | return; | |||
| 916 | #endif | |||
| 917 | AnalysisUsage *AnUsage = TPM->findAnalysisUsage(P); | |||
| 918 | const AnalysisUsage::VectorType &PreservedSet = AnUsage->getPreservedSet(); | |||
| 919 | ||||
| 920 | // Verify preserved analysis | |||
| 921 | for (AnalysisID AID : PreservedSet) { | |||
| 922 | if (Pass *AP = findAnalysisPass(AID, true)) { | |||
| 923 | TimeRegion PassTimer(getPassTimer(AP)); | |||
| 924 | AP->verifyAnalysis(); | |||
| 925 | } | |||
| 926 | } | |||
| 927 | } | |||
| 928 | ||||
| 929 | /// Remove Analysis not preserved by Pass P | |||
| 930 | void PMDataManager::removeNotPreservedAnalysis(Pass *P) { | |||
| 931 | AnalysisUsage *AnUsage = TPM->findAnalysisUsage(P); | |||
| 932 | if (AnUsage->getPreservesAll()) | |||
| 933 | return; | |||
| 934 | ||||
| 935 | const AnalysisUsage::VectorType &PreservedSet = AnUsage->getPreservedSet(); | |||
| 936 | for (DenseMap<AnalysisID, Pass*>::iterator I = AvailableAnalysis.begin(), | |||
| 937 | E = AvailableAnalysis.end(); I != E; ) { | |||
| 938 | DenseMap<AnalysisID, Pass*>::iterator Info = I++; | |||
| 939 | if (Info->second->getAsImmutablePass() == nullptr && | |||
| 940 | !is_contained(PreservedSet, Info->first)) { | |||
| 941 | // Remove this analysis | |||
| 942 | if (PassDebugging >= Details) { | |||
| 943 | Pass *S = Info->second; | |||
| 944 | dbgs() << " -- '" << P->getPassName() << "' is not preserving '"; | |||
| 945 | dbgs() << S->getPassName() << "'\n"; | |||
| 946 | } | |||
| 947 | AvailableAnalysis.erase(Info); | |||
| 948 | } | |||
| 949 | } | |||
| 950 | ||||
| 951 | // Check inherited analysis also. If P is not preserving analysis | |||
| 952 | // provided by parent manager then remove it here. | |||
| 953 | for (DenseMap<AnalysisID, Pass *> *IA : InheritedAnalysis) { | |||
| 954 | if (!IA) | |||
| 955 | continue; | |||
| 956 | ||||
| 957 | for (DenseMap<AnalysisID, Pass *>::iterator I = IA->begin(), | |||
| 958 | E = IA->end(); | |||
| 959 | I != E;) { | |||
| 960 | DenseMap<AnalysisID, Pass *>::iterator Info = I++; | |||
| 961 | if (Info->second->getAsImmutablePass() == nullptr && | |||
| 962 | !is_contained(PreservedSet, Info->first)) { | |||
| 963 | // Remove this analysis | |||
| 964 | if (PassDebugging >= Details) { | |||
| 965 | Pass *S = Info->second; | |||
| 966 | dbgs() << " -- '" << P->getPassName() << "' is not preserving '"; | |||
| 967 | dbgs() << S->getPassName() << "'\n"; | |||
| 968 | } | |||
| 969 | IA->erase(Info); | |||
| 970 | } | |||
| 971 | } | |||
| 972 | } | |||
| 973 | } | |||
| 974 | ||||
| 975 | /// Remove analysis passes that are not used any longer | |||
| 976 | void PMDataManager::removeDeadPasses(Pass *P, StringRef Msg, | |||
| 977 | enum PassDebuggingString DBG_STR) { | |||
| 978 | ||||
| 979 | SmallVector<Pass *, 12> DeadPasses; | |||
| 980 | ||||
| 981 | // If this is a on the fly manager then it does not have TPM. | |||
| 982 | if (!TPM) | |||
| 983 | return; | |||
| 984 | ||||
| 985 | TPM->collectLastUses(DeadPasses, P); | |||
| 986 | ||||
| 987 | if (PassDebugging >= Details && !DeadPasses.empty()) { | |||
| 988 | dbgs() << " -*- '" << P->getPassName(); | |||
| 989 | dbgs() << "' is the last user of following pass instances."; | |||
| 990 | dbgs() << " Free these instances\n"; | |||
| 991 | } | |||
| 992 | ||||
| 993 | for (Pass *P : DeadPasses) | |||
| 994 | freePass(P, Msg, DBG_STR); | |||
| 995 | } | |||
| 996 | ||||
| 997 | void PMDataManager::freePass(Pass *P, StringRef Msg, | |||
| 998 | enum PassDebuggingString DBG_STR) { | |||
| 999 | dumpPassInfo(P, FREEING_MSG, DBG_STR, Msg); | |||
| 1000 | ||||
| 1001 | { | |||
| 1002 | // If the pass crashes releasing memory, remember this. | |||
| 1003 | PassManagerPrettyStackEntry X(P); | |||
| 1004 | TimeRegion PassTimer(getPassTimer(P)); | |||
| 1005 | ||||
| 1006 | P->releaseMemory(); | |||
| 1007 | } | |||
| 1008 | ||||
| 1009 | AnalysisID PI = P->getPassID(); | |||
| 1010 | if (const PassInfo *PInf = TPM->findAnalysisPassInfo(PI)) { | |||
| 1011 | // Remove the pass itself (if it is not already removed). | |||
| 1012 | AvailableAnalysis.erase(PI); | |||
| 1013 | ||||
| 1014 | // Remove all interfaces this pass implements, for which it is also | |||
| 1015 | // listed as the available implementation. | |||
| 1016 | const std::vector<const PassInfo*> &II = PInf->getInterfacesImplemented(); | |||
| 1017 | for (unsigned i = 0, e = II.size(); i != e; ++i) { | |||
| 1018 | DenseMap<AnalysisID, Pass*>::iterator Pos = | |||
| 1019 | AvailableAnalysis.find(II[i]->getTypeInfo()); | |||
| 1020 | if (Pos != AvailableAnalysis.end() && Pos->second == P) | |||
| 1021 | AvailableAnalysis.erase(Pos); | |||
| 1022 | } | |||
| 1023 | } | |||
| 1024 | } | |||
| 1025 | ||||
| 1026 | /// Add pass P into the PassVector. Update | |||
| 1027 | /// AvailableAnalysis appropriately if ProcessAnalysis is true. | |||
| 1028 | void PMDataManager::add(Pass *P, bool ProcessAnalysis) { | |||
| 1029 | // This manager is going to manage pass P. Set up analysis resolver | |||
| 1030 | // to connect them. | |||
| 1031 | AnalysisResolver *AR = new AnalysisResolver(*this); | |||
| 1032 | P->setResolver(AR); | |||
| 1033 | ||||
| 1034 | // If a FunctionPass F is the last user of ModulePass info M | |||
| 1035 | // then the F's manager, not F, records itself as a last user of M. | |||
| 1036 | SmallVector<Pass *, 12> TransferLastUses; | |||
| 1037 | ||||
| 1038 | if (!ProcessAnalysis) { | |||
| 1039 | // Add pass | |||
| 1040 | PassVector.push_back(P); | |||
| 1041 | return; | |||
| 1042 | } | |||
| 1043 | ||||
| 1044 | // At the moment, this pass is the last user of all required passes. | |||
| 1045 | SmallVector<Pass *, 12> LastUses; | |||
| 1046 | SmallVector<Pass *, 8> UsedPasses; | |||
| 1047 | SmallVector<AnalysisID, 8> ReqAnalysisNotAvailable; | |||
| 1048 | ||||
| 1049 | unsigned PDepth = this->getDepth(); | |||
| 1050 | ||||
| 1051 | collectRequiredAndUsedAnalyses(UsedPasses, ReqAnalysisNotAvailable, P); | |||
| 1052 | for (Pass *PUsed : UsedPasses) { | |||
| 1053 | unsigned RDepth = 0; | |||
| 1054 | ||||
| 1055 | assert(PUsed->getResolver() && "Analysis Resolver is not set")((void)0); | |||
| 1056 | PMDataManager &DM = PUsed->getResolver()->getPMDataManager(); | |||
| 1057 | RDepth = DM.getDepth(); | |||
| 1058 | ||||
| 1059 | if (PDepth == RDepth) | |||
| 1060 | LastUses.push_back(PUsed); | |||
| 1061 | else if (PDepth > RDepth) { | |||
| 1062 | // Let the parent claim responsibility of last use | |||
| 1063 | TransferLastUses.push_back(PUsed); | |||
| 1064 | // Keep track of higher level analysis used by this manager. | |||
| 1065 | HigherLevelAnalysis.push_back(PUsed); | |||
| 1066 | } else | |||
| 1067 | llvm_unreachable("Unable to accommodate Used Pass")__builtin_unreachable(); | |||
| 1068 | } | |||
| 1069 | ||||
| 1070 | // Set P as P's last user until someone starts using P. | |||
| 1071 | // However, if P is a Pass Manager then it does not need | |||
| 1072 | // to record its last user. | |||
| 1073 | if (!P->getAsPMDataManager()) | |||
| 1074 | LastUses.push_back(P); | |||
| 1075 | TPM->setLastUser(LastUses, P); | |||
| 1076 | ||||
| 1077 | if (!TransferLastUses.empty()) { | |||
| 1078 | Pass *My_PM = getAsPass(); | |||
| 1079 | TPM->setLastUser(TransferLastUses, My_PM); | |||
| 1080 | TransferLastUses.clear(); | |||
| 1081 | } | |||
| 1082 | ||||
| 1083 | // Now, take care of required analyses that are not available. | |||
| 1084 | for (AnalysisID ID : ReqAnalysisNotAvailable) { | |||
| 1085 | const PassInfo *PI = TPM->findAnalysisPassInfo(ID); | |||
| 1086 | Pass *AnalysisPass = PI->createPass(); | |||
| 1087 | this->addLowerLevelRequiredPass(P, AnalysisPass); | |||
| 1088 | } | |||
| 1089 | ||||
| 1090 | // Take a note of analysis required and made available by this pass. | |||
| 1091 | // Remove the analysis not preserved by this pass | |||
| 1092 | removeNotPreservedAnalysis(P); | |||
| 1093 | recordAvailableAnalysis(P); | |||
| 1094 | ||||
| 1095 | // Add pass | |||
| 1096 | PassVector.push_back(P); | |||
| 1097 | } | |||
| 1098 | ||||
| 1099 | ||||
| 1100 | /// Populate UP with analysis pass that are used or required by | |||
| 1101 | /// pass P and are available. Populate RP_NotAvail with analysis | |||
| 1102 | /// pass that are required by pass P but are not available. | |||
| 1103 | void PMDataManager::collectRequiredAndUsedAnalyses( | |||
| 1104 | SmallVectorImpl<Pass *> &UP, SmallVectorImpl<AnalysisID> &RP_NotAvail, | |||
| 1105 | Pass *P) { | |||
| 1106 | AnalysisUsage *AnUsage = TPM->findAnalysisUsage(P); | |||
| 1107 | ||||
| 1108 | for (const auto &UsedID : AnUsage->getUsedSet()) | |||
| 1109 | if (Pass *AnalysisPass = findAnalysisPass(UsedID, true)) | |||
| 1110 | UP.push_back(AnalysisPass); | |||
| 1111 | ||||
| 1112 | for (const auto &RequiredID : AnUsage->getRequiredSet()) | |||
| 1113 | if (Pass *AnalysisPass = findAnalysisPass(RequiredID, true)) | |||
| 1114 | UP.push_back(AnalysisPass); | |||
| 1115 | else | |||
| 1116 | RP_NotAvail.push_back(RequiredID); | |||
| 1117 | } | |||
| 1118 | ||||
| 1119 | // All Required analyses should be available to the pass as it runs! Here | |||
| 1120 | // we fill in the AnalysisImpls member of the pass so that it can | |||
| 1121 | // successfully use the getAnalysis() method to retrieve the | |||
| 1122 | // implementations it needs. | |||
| 1123 | // | |||
| 1124 | void PMDataManager::initializeAnalysisImpl(Pass *P) { | |||
| 1125 | AnalysisUsage *AnUsage = TPM->findAnalysisUsage(P); | |||
| 1126 | ||||
| 1127 | for (const AnalysisID ID : AnUsage->getRequiredSet()) { | |||
| 1128 | Pass *Impl = findAnalysisPass(ID, true); | |||
| 1129 | if (!Impl) | |||
| 1130 | // This may be analysis pass that is initialized on the fly. | |||
| 1131 | // If that is not the case then it will raise an assert when it is used. | |||
| 1132 | continue; | |||
| 1133 | AnalysisResolver *AR = P->getResolver(); | |||
| 1134 | assert(AR && "Analysis Resolver is not set")((void)0); | |||
| 1135 | AR->addAnalysisImplsPair(ID, Impl); | |||
| 1136 | } | |||
| 1137 | } | |||
| 1138 | ||||
| 1139 | /// Find the pass that implements Analysis AID. If desired pass is not found | |||
| 1140 | /// then return NULL. | |||
| 1141 | Pass *PMDataManager::findAnalysisPass(AnalysisID AID, bool SearchParent) { | |||
| 1142 | ||||
| 1143 | // Check if AvailableAnalysis map has one entry. | |||
| 1144 | DenseMap<AnalysisID, Pass*>::const_iterator I = AvailableAnalysis.find(AID); | |||
| 1145 | ||||
| 1146 | if (I != AvailableAnalysis.end()) | |||
| 1147 | return I->second; | |||
| 1148 | ||||
| 1149 | // Search Parents through TopLevelManager | |||
| 1150 | if (SearchParent) | |||
| 1151 | return TPM->findAnalysisPass(AID); | |||
| 1152 | ||||
| 1153 | return nullptr; | |||
| 1154 | } | |||
| 1155 | ||||
| 1156 | // Print list of passes that are last used by P. | |||
| 1157 | void PMDataManager::dumpLastUses(Pass *P, unsigned Offset) const{ | |||
| 1158 | if (PassDebugging < Details) | |||
| 1159 | return; | |||
| 1160 | ||||
| 1161 | SmallVector<Pass *, 12> LUses; | |||
| 1162 | ||||
| 1163 | // If this is a on the fly manager then it does not have TPM. | |||
| 1164 | if (!TPM) | |||
| 1165 | return; | |||
| 1166 | ||||
| 1167 | TPM->collectLastUses(LUses, P); | |||
| 1168 | ||||
| 1169 | for (Pass *P : LUses) { | |||
| 1170 | dbgs() << "--" << std::string(Offset*2, ' '); | |||
| 1171 | P->dumpPassStructure(0); | |||
| 1172 | } | |||
| 1173 | } | |||
| 1174 | ||||
| 1175 | void PMDataManager::dumpPassArguments() const { | |||
| 1176 | for (Pass *P : PassVector) { | |||
| 1177 | if (PMDataManager *PMD = P->getAsPMDataManager()) | |||
| 1178 | PMD->dumpPassArguments(); | |||
| 1179 | else | |||
| 1180 | if (const PassInfo *PI = | |||
| 1181 | TPM->findAnalysisPassInfo(P->getPassID())) | |||
| 1182 | if (!PI->isAnalysisGroup()) | |||
| 1183 | dbgs() << " -" << PI->getPassArgument(); | |||
| 1184 | } | |||
| 1185 | } | |||
| 1186 | ||||
| 1187 | void PMDataManager::dumpPassInfo(Pass *P, enum PassDebuggingString S1, | |||
| 1188 | enum PassDebuggingString S2, | |||
| 1189 | StringRef Msg) { | |||
| 1190 | if (PassDebugging < Executions) | |||
| 1191 | return; | |||
| 1192 | dbgs() << "[" << std::chrono::system_clock::now() << "] " << (void *)this | |||
| 1193 | << std::string(getDepth() * 2 + 1, ' '); | |||
| 1194 | switch (S1) { | |||
| 1195 | case EXECUTION_MSG: | |||
| 1196 | dbgs() << "Executing Pass '" << P->getPassName(); | |||
| 1197 | break; | |||
| 1198 | case MODIFICATION_MSG: | |||
| 1199 | dbgs() << "Made Modification '" << P->getPassName(); | |||
| 1200 | break; | |||
| 1201 | case FREEING_MSG: | |||
| 1202 | dbgs() << " Freeing Pass '" << P->getPassName(); | |||
| 1203 | break; | |||
| 1204 | default: | |||
| 1205 | break; | |||
| 1206 | } | |||
| 1207 | switch (S2) { | |||
| 1208 | case ON_FUNCTION_MSG: | |||
| 1209 | dbgs() << "' on Function '" << Msg << "'...\n"; | |||
| 1210 | break; | |||
| 1211 | case ON_MODULE_MSG: | |||
| 1212 | dbgs() << "' on Module '" << Msg << "'...\n"; | |||
| 1213 | break; | |||
| 1214 | case ON_REGION_MSG: | |||
| 1215 | dbgs() << "' on Region '" << Msg << "'...\n"; | |||
| 1216 | break; | |||
| 1217 | case ON_LOOP_MSG: | |||
| 1218 | dbgs() << "' on Loop '" << Msg << "'...\n"; | |||
| 1219 | break; | |||
| 1220 | case ON_CG_MSG: | |||
| 1221 | dbgs() << "' on Call Graph Nodes '" << Msg << "'...\n"; | |||
| 1222 | break; | |||
| 1223 | default: | |||
| 1224 | break; | |||
| 1225 | } | |||
| 1226 | } | |||
| 1227 | ||||
| 1228 | void PMDataManager::dumpRequiredSet(const Pass *P) const { | |||
| 1229 | if (PassDebugging < Details) | |||
| 1230 | return; | |||
| 1231 | ||||
| 1232 | AnalysisUsage analysisUsage; | |||
| 1233 | P->getAnalysisUsage(analysisUsage); | |||
| 1234 | dumpAnalysisUsage("Required", P, analysisUsage.getRequiredSet()); | |||
| 1235 | } | |||
| 1236 | ||||
| 1237 | void PMDataManager::dumpPreservedSet(const Pass *P) const { | |||
| 1238 | if (PassDebugging < Details) | |||
| 1239 | return; | |||
| 1240 | ||||
| 1241 | AnalysisUsage analysisUsage; | |||
| 1242 | P->getAnalysisUsage(analysisUsage); | |||
| 1243 | dumpAnalysisUsage("Preserved", P, analysisUsage.getPreservedSet()); | |||
| 1244 | } | |||
| 1245 | ||||
| 1246 | void PMDataManager::dumpUsedSet(const Pass *P) const { | |||
| 1247 | if (PassDebugging < Details) | |||
| 1248 | return; | |||
| 1249 | ||||
| 1250 | AnalysisUsage analysisUsage; | |||
| 1251 | P->getAnalysisUsage(analysisUsage); | |||
| 1252 | dumpAnalysisUsage("Used", P, analysisUsage.getUsedSet()); | |||
| 1253 | } | |||
| 1254 | ||||
| 1255 | void PMDataManager::dumpAnalysisUsage(StringRef Msg, const Pass *P, | |||
| 1256 | const AnalysisUsage::VectorType &Set) const { | |||
| 1257 | assert(PassDebugging >= Details)((void)0); | |||
| 1258 | if (Set.empty()) | |||
| 1259 | return; | |||
| 1260 | dbgs() << (const void*)P << std::string(getDepth()*2+3, ' ') << Msg << " Analyses:"; | |||
| 1261 | for (unsigned i = 0; i != Set.size(); ++i) { | |||
| 1262 | if (i) dbgs() << ','; | |||
| 1263 | const PassInfo *PInf = TPM->findAnalysisPassInfo(Set[i]); | |||
| 1264 | if (!PInf) { | |||
| 1265 | // Some preserved passes, such as AliasAnalysis, may not be initialized by | |||
| 1266 | // all drivers. | |||
| 1267 | dbgs() << " Uninitialized Pass"; | |||
| 1268 | continue; | |||
| 1269 | } | |||
| 1270 | dbgs() << ' ' << PInf->getPassName(); | |||
| 1271 | } | |||
| 1272 | dbgs() << '\n'; | |||
| 1273 | } | |||
| 1274 | ||||
| 1275 | /// Add RequiredPass into list of lower level passes required by pass P. | |||
| 1276 | /// RequiredPass is run on the fly by Pass Manager when P requests it | |||
| 1277 | /// through getAnalysis interface. | |||
| 1278 | /// This should be handled by specific pass manager. | |||
| 1279 | void PMDataManager::addLowerLevelRequiredPass(Pass *P, Pass *RequiredPass) { | |||
| 1280 | if (TPM) { | |||
| 1281 | TPM->dumpArguments(); | |||
| 1282 | TPM->dumpPasses(); | |||
| 1283 | } | |||
| 1284 | ||||
| 1285 | // Module Level pass may required Function Level analysis info | |||
| 1286 | // (e.g. dominator info). Pass manager uses on the fly function pass manager | |||
| 1287 | // to provide this on demand. In that case, in Pass manager terminology, | |||
| 1288 | // module level pass is requiring lower level analysis info managed by | |||
| 1289 | // lower level pass manager. | |||
| 1290 | ||||
| 1291 | // When Pass manager is not able to order required analysis info, Pass manager | |||
| 1292 | // checks whether any lower level manager will be able to provide this | |||
| 1293 | // analysis info on demand or not. | |||
| 1294 | #ifndef NDEBUG1 | |||
| 1295 | dbgs() << "Unable to schedule '" << RequiredPass->getPassName(); | |||
| 1296 | dbgs() << "' required by '" << P->getPassName() << "'\n"; | |||
| 1297 | #endif | |||
| 1298 | llvm_unreachable("Unable to schedule pass")__builtin_unreachable(); | |||
| 1299 | } | |||
| 1300 | ||||
| 1301 | std::tuple<Pass *, bool> PMDataManager::getOnTheFlyPass(Pass *P, AnalysisID PI, | |||
| 1302 | Function &F) { | |||
| 1303 | llvm_unreachable("Unable to find on the fly pass")__builtin_unreachable(); | |||
| 1304 | } | |||
| 1305 | ||||
| 1306 | // Destructor | |||
| 1307 | PMDataManager::~PMDataManager() { | |||
| 1308 | for (Pass *P : PassVector) | |||
| 1309 | delete P; | |||
| 1310 | } | |||
| 1311 | ||||
| 1312 | //===----------------------------------------------------------------------===// | |||
| 1313 | // NOTE: Is this the right place to define this method ? | |||
| 1314 | // getAnalysisIfAvailable - Return analysis result or null if it doesn't exist. | |||
| 1315 | Pass *AnalysisResolver::getAnalysisIfAvailable(AnalysisID ID) const { | |||
| 1316 | return PM.findAnalysisPass(ID, true); | |||
| 1317 | } | |||
| 1318 | ||||
| 1319 | std::tuple<Pass *, bool> | |||
| 1320 | AnalysisResolver::findImplPass(Pass *P, AnalysisID AnalysisPI, Function &F) { | |||
| 1321 | return PM.getOnTheFlyPass(P, AnalysisPI, F); | |||
| 1322 | } | |||
| 1323 | ||||
| 1324 | namespace llvm { | |||
| 1325 | namespace legacy { | |||
| 1326 | ||||
| 1327 | //===----------------------------------------------------------------------===// | |||
| 1328 | // FunctionPassManager implementation | |||
| 1329 | ||||
| 1330 | /// Create new Function pass manager | |||
| 1331 | FunctionPassManager::FunctionPassManager(Module *m) : M(m) { | |||
| 1332 | FPM = new legacy::FunctionPassManagerImpl(); | |||
| 1333 | // FPM is the top level manager. | |||
| 1334 | FPM->setTopLevelManager(FPM); | |||
| 1335 | ||||
| 1336 | AnalysisResolver *AR = new AnalysisResolver(*FPM); | |||
| 1337 | FPM->setResolver(AR); | |||
| 1338 | } | |||
| 1339 | ||||
| 1340 | FunctionPassManager::~FunctionPassManager() { | |||
| 1341 | delete FPM; | |||
| 1342 | } | |||
| 1343 | ||||
| 1344 | void FunctionPassManager::add(Pass *P) { | |||
| 1345 | FPM->add(P); | |||
| 1346 | } | |||
| 1347 | ||||
| 1348 | /// run - Execute all of the passes scheduled for execution. Keep | |||
| 1349 | /// track of whether any of the passes modifies the function, and if | |||
| 1350 | /// so, return true. | |||
| 1351 | /// | |||
| 1352 | bool FunctionPassManager::run(Function &F) { | |||
| 1353 | handleAllErrors(F.materialize(), [&](ErrorInfoBase &EIB) { | |||
| 1354 | report_fatal_error("Error reading bitcode file: " + EIB.message()); | |||
| 1355 | }); | |||
| 1356 | return FPM->run(F); | |||
| 1357 | } | |||
| 1358 | ||||
| 1359 | ||||
| 1360 | /// doInitialization - Run all of the initializers for the function passes. | |||
| 1361 | /// | |||
| 1362 | bool FunctionPassManager::doInitialization() { | |||
| 1363 | return FPM->doInitialization(*M); | |||
| 1364 | } | |||
| 1365 | ||||
| 1366 | /// doFinalization - Run all of the finalizers for the function passes. | |||
| 1367 | /// | |||
| 1368 | bool FunctionPassManager::doFinalization() { | |||
| 1369 | return FPM->doFinalization(*M); | |||
| 1370 | } | |||
| 1371 | } // namespace legacy | |||
| 1372 | } // namespace llvm | |||
| 1373 | ||||
| 1374 | /// cleanup - After running all passes, clean up pass manager cache. | |||
| 1375 | void FPPassManager::cleanup() { | |||
| 1376 | for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) { | |||
| 1377 | FunctionPass *FP = getContainedPass(Index); | |||
| 1378 | AnalysisResolver *AR = FP->getResolver(); | |||
| 1379 | assert(AR && "Analysis Resolver is not set")((void)0); | |||
| 1380 | AR->clearAnalysisImpls(); | |||
| 1381 | } | |||
| 1382 | } | |||
| 1383 | ||||
| 1384 | ||||
| 1385 | //===----------------------------------------------------------------------===// | |||
| 1386 | // FPPassManager implementation | |||
| 1387 | ||||
| 1388 | char FPPassManager::ID = 0; | |||
| 1389 | /// Print passes managed by this manager | |||
| 1390 | void FPPassManager::dumpPassStructure(unsigned Offset) { | |||
| 1391 | dbgs().indent(Offset*2) << "FunctionPass Manager\n"; | |||
| 1392 | for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) { | |||
| 1393 | FunctionPass *FP = getContainedPass(Index); | |||
| 1394 | FP->dumpPassStructure(Offset + 1); | |||
| 1395 | dumpLastUses(FP, Offset+1); | |||
| 1396 | } | |||
| 1397 | } | |||
| 1398 | ||||
| 1399 | /// Execute all of the passes scheduled for execution by invoking | |||
| 1400 | /// runOnFunction method. Keep track of whether any of the passes modifies | |||
| 1401 | /// the function, and if so, return true. | |||
| 1402 | bool FPPassManager::runOnFunction(Function &F) { | |||
| 1403 | if (F.isDeclaration()) | |||
| 1404 | return false; | |||
| 1405 | ||||
| 1406 | bool Changed = false; | |||
| 1407 | Module &M = *F.getParent(); | |||
| 1408 | // Collect inherited analysis from Module level pass manager. | |||
| 1409 | populateInheritedAnalysis(TPM->activeStack); | |||
| 1410 | ||||
| 1411 | unsigned InstrCount, FunctionSize = 0; | |||
| 1412 | StringMap<std::pair<unsigned, unsigned>> FunctionToInstrCount; | |||
| 1413 | bool EmitICRemark = M.shouldEmitInstrCountChangedRemark(); | |||
| 1414 | // Collect the initial size of the module. | |||
| 1415 | if (EmitICRemark) { | |||
| 1416 | InstrCount = initSizeRemarkInfo(M, FunctionToInstrCount); | |||
| 1417 | FunctionSize = F.getInstructionCount(); | |||
| 1418 | } | |||
| 1419 | ||||
| 1420 | llvm::TimeTraceScope FunctionScope("OptFunction", F.getName()); | |||
| 1421 | ||||
| 1422 | for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) { | |||
| 1423 | FunctionPass *FP = getContainedPass(Index); | |||
| 1424 | bool LocalChanged = false; | |||
| 1425 | ||||
| 1426 | llvm::TimeTraceScope PassScope("RunPass", FP->getPassName()); | |||
| 1427 | ||||
| 1428 | dumpPassInfo(FP, EXECUTION_MSG, ON_FUNCTION_MSG, F.getName()); | |||
| 1429 | dumpRequiredSet(FP); | |||
| 1430 | ||||
| 1431 | initializeAnalysisImpl(FP); | |||
| 1432 | ||||
| 1433 | { | |||
| 1434 | PassManagerPrettyStackEntry X(FP, F); | |||
| 1435 | TimeRegion PassTimer(getPassTimer(FP)); | |||
| 1436 | #ifdef EXPENSIVE_CHECKS | |||
| 1437 | uint64_t RefHash = StructuralHash(F); | |||
| 1438 | #endif | |||
| 1439 | LocalChanged |= FP->runOnFunction(F); | |||
| 1440 | ||||
| 1441 | #if defined(EXPENSIVE_CHECKS) && !defined(NDEBUG1) | |||
| 1442 | if (!LocalChanged && (RefHash != StructuralHash(F))) { | |||
| 1443 | llvm::errs() << "Pass modifies its input and doesn't report it: " | |||
| 1444 | << FP->getPassName() << "\n"; | |||
| 1445 | llvm_unreachable("Pass modifies its input and doesn't report it")__builtin_unreachable(); | |||
| 1446 | } | |||
| 1447 | #endif | |||
| 1448 | ||||
| 1449 | if (EmitICRemark) { | |||
| 1450 | unsigned NewSize = F.getInstructionCount(); | |||
| 1451 | ||||
| 1452 | // Update the size of the function, emit a remark, and update the size | |||
| 1453 | // of the module. | |||
| 1454 | if (NewSize != FunctionSize) { | |||
| 1455 | int64_t Delta = static_cast<int64_t>(NewSize) - | |||
| 1456 | static_cast<int64_t>(FunctionSize); | |||
| 1457 | emitInstrCountChangedRemark(FP, M, Delta, InstrCount, | |||
| 1458 | FunctionToInstrCount, &F); | |||
| 1459 | InstrCount = static_cast<int64_t>(InstrCount) + Delta; | |||
| 1460 | FunctionSize = NewSize; | |||
| 1461 | } | |||
| 1462 | } | |||
| 1463 | } | |||
| 1464 | ||||
| 1465 | Changed |= LocalChanged; | |||
| 1466 | if (LocalChanged) | |||
| 1467 | dumpPassInfo(FP, MODIFICATION_MSG, ON_FUNCTION_MSG, F.getName()); | |||
| 1468 | dumpPreservedSet(FP); | |||
| 1469 | dumpUsedSet(FP); | |||
| 1470 | ||||
| 1471 | verifyPreservedAnalysis(FP); | |||
| 1472 | if (LocalChanged) | |||
| 1473 | removeNotPreservedAnalysis(FP); | |||
| 1474 | recordAvailableAnalysis(FP); | |||
| 1475 | removeDeadPasses(FP, F.getName(), ON_FUNCTION_MSG); | |||
| 1476 | } | |||
| 1477 | ||||
| 1478 | return Changed; | |||
| 1479 | } | |||
| 1480 | ||||
| 1481 | bool FPPassManager::runOnModule(Module &M) { | |||
| 1482 | bool Changed = false; | |||
| 1483 | ||||
| 1484 | for (Function &F : M) | |||
| 1485 | Changed |= runOnFunction(F); | |||
| 1486 | ||||
| 1487 | return Changed; | |||
| 1488 | } | |||
| 1489 | ||||
| 1490 | bool FPPassManager::doInitialization(Module &M) { | |||
| 1491 | bool Changed = false; | |||
| 1492 | ||||
| 1493 | for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) | |||
| 1494 | Changed |= getContainedPass(Index)->doInitialization(M); | |||
| 1495 | ||||
| 1496 | return Changed; | |||
| 1497 | } | |||
| 1498 | ||||
| 1499 | bool FPPassManager::doFinalization(Module &M) { | |||
| 1500 | bool Changed = false; | |||
| 1501 | ||||
| 1502 | for (int Index = getNumContainedPasses() - 1; Index >= 0; --Index) | |||
| 1503 | Changed |= getContainedPass(Index)->doFinalization(M); | |||
| 1504 | ||||
| 1505 | return Changed; | |||
| 1506 | } | |||
| 1507 | ||||
| 1508 | //===----------------------------------------------------------------------===// | |||
| 1509 | // MPPassManager implementation | |||
| 1510 | ||||
| 1511 | /// Execute all of the passes scheduled for execution by invoking | |||
| 1512 | /// runOnModule method. Keep track of whether any of the passes modifies | |||
| 1513 | /// the module, and if so, return true. | |||
| 1514 | bool | |||
| 1515 | MPPassManager::runOnModule(Module &M) { | |||
| 1516 | llvm::TimeTraceScope TimeScope("OptModule", M.getName()); | |||
| 1517 | ||||
| 1518 | bool Changed = false; | |||
| 1519 | ||||
| 1520 | // Initialize on-the-fly passes | |||
| 1521 | for (auto &OnTheFlyManager : OnTheFlyManagers) { | |||
| 1522 | legacy::FunctionPassManagerImpl *FPP = OnTheFlyManager.second; | |||
| 1523 | Changed |= FPP->doInitialization(M); | |||
| 1524 | } | |||
| 1525 | ||||
| 1526 | // Initialize module passes | |||
| 1527 | for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) | |||
| 1528 | Changed |= getContainedPass(Index)->doInitialization(M); | |||
| 1529 | ||||
| 1530 | unsigned InstrCount; | |||
| 1531 | StringMap<std::pair<unsigned, unsigned>> FunctionToInstrCount; | |||
| 1532 | bool EmitICRemark = M.shouldEmitInstrCountChangedRemark(); | |||
| 1533 | // Collect the initial size of the module. | |||
| 1534 | if (EmitICRemark) | |||
| 1535 | InstrCount = initSizeRemarkInfo(M, FunctionToInstrCount); | |||
| 1536 | ||||
| 1537 | for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) { | |||
| 1538 | ModulePass *MP = getContainedPass(Index); | |||
| 1539 | bool LocalChanged = false; | |||
| 1540 | ||||
| 1541 | dumpPassInfo(MP, EXECUTION_MSG, ON_MODULE_MSG, M.getModuleIdentifier()); | |||
| 1542 | dumpRequiredSet(MP); | |||
| 1543 | ||||
| 1544 | initializeAnalysisImpl(MP); | |||
| 1545 | ||||
| 1546 | { | |||
| 1547 | PassManagerPrettyStackEntry X(MP, M); | |||
| 1548 | TimeRegion PassTimer(getPassTimer(MP)); | |||
| 1549 | ||||
| 1550 | #ifdef EXPENSIVE_CHECKS | |||
| 1551 | uint64_t RefHash = StructuralHash(M); | |||
| 1552 | #endif | |||
| 1553 | ||||
| 1554 | LocalChanged |= MP->runOnModule(M); | |||
| 1555 | ||||
| 1556 | #ifdef EXPENSIVE_CHECKS | |||
| 1557 | assert((LocalChanged || (RefHash == StructuralHash(M))) &&((void)0) | |||
| 1558 | "Pass modifies its input and doesn't report it.")((void)0); | |||
| 1559 | #endif | |||
| 1560 | ||||
| 1561 | if (EmitICRemark) { | |||
| 1562 | // Update the size of the module. | |||
| 1563 | unsigned ModuleCount = M.getInstructionCount(); | |||
| 1564 | if (ModuleCount != InstrCount) { | |||
| 1565 | int64_t Delta = static_cast<int64_t>(ModuleCount) - | |||
| 1566 | static_cast<int64_t>(InstrCount); | |||
| 1567 | emitInstrCountChangedRemark(MP, M, Delta, InstrCount, | |||
| 1568 | FunctionToInstrCount); | |||
| 1569 | InstrCount = ModuleCount; | |||
| 1570 | } | |||
| 1571 | } | |||
| 1572 | } | |||
| 1573 | ||||
| 1574 | Changed |= LocalChanged; | |||
| 1575 | if (LocalChanged) | |||
| 1576 | dumpPassInfo(MP, MODIFICATION_MSG, ON_MODULE_MSG, | |||
| 1577 | M.getModuleIdentifier()); | |||
| 1578 | dumpPreservedSet(MP); | |||
| 1579 | dumpUsedSet(MP); | |||
| 1580 | ||||
| 1581 | verifyPreservedAnalysis(MP); | |||
| 1582 | if (LocalChanged) | |||
| 1583 | removeNotPreservedAnalysis(MP); | |||
| 1584 | recordAvailableAnalysis(MP); | |||
| 1585 | removeDeadPasses(MP, M.getModuleIdentifier(), ON_MODULE_MSG); | |||
| 1586 | } | |||
| 1587 | ||||
| 1588 | // Finalize module passes | |||
| 1589 | for (int Index = getNumContainedPasses() - 1; Index >= 0; --Index) | |||
| 1590 | Changed |= getContainedPass(Index)->doFinalization(M); | |||
| 1591 | ||||
| 1592 | // Finalize on-the-fly passes | |||
| 1593 | for (auto &OnTheFlyManager : OnTheFlyManagers) { | |||
| 1594 | legacy::FunctionPassManagerImpl *FPP = OnTheFlyManager.second; | |||
| 1595 | // We don't know when is the last time an on-the-fly pass is run, | |||
| 1596 | // so we need to releaseMemory / finalize here | |||
| 1597 | FPP->releaseMemoryOnTheFly(); | |||
| 1598 | Changed |= FPP->doFinalization(M); | |||
| 1599 | } | |||
| 1600 | ||||
| 1601 | return Changed; | |||
| 1602 | } | |||
| 1603 | ||||
| 1604 | /// Add RequiredPass into list of lower level passes required by pass P. | |||
| 1605 | /// RequiredPass is run on the fly by Pass Manager when P requests it | |||
| 1606 | /// through getAnalysis interface. | |||
| 1607 | void MPPassManager::addLowerLevelRequiredPass(Pass *P, Pass *RequiredPass) { | |||
| 1608 | assert(RequiredPass && "No required pass?")((void)0); | |||
| 1609 | assert(P->getPotentialPassManagerType() == PMT_ModulePassManager &&((void)0) | |||
| 1610 | "Unable to handle Pass that requires lower level Analysis pass")((void)0); | |||
| 1611 | assert((P->getPotentialPassManagerType() <((void)0) | |||
| 1612 | RequiredPass->getPotentialPassManagerType()) &&((void)0) | |||
| 1613 | "Unable to handle Pass that requires lower level Analysis pass")((void)0); | |||
| 1614 | ||||
| 1615 | legacy::FunctionPassManagerImpl *FPP = OnTheFlyManagers[P]; | |||
| 1616 | if (!FPP) { | |||
| ||||
| 1617 | FPP = new legacy::FunctionPassManagerImpl(); | |||
| 1618 | // FPP is the top level manager. | |||
| 1619 | FPP->setTopLevelManager(FPP); | |||
| 1620 | ||||
| 1621 | OnTheFlyManagers[P] = FPP; | |||
| 1622 | } | |||
| 1623 | const PassInfo *RequiredPassPI = | |||
| 1624 | TPM->findAnalysisPassInfo(RequiredPass->getPassID()); | |||
| 1625 | ||||
| 1626 | Pass *FoundPass = nullptr; | |||
| 1627 | if (RequiredPassPI
| |||
| 1628 | FoundPass = | |||
| 1629 | ((PMTopLevelManager*)FPP)->findAnalysisPass(RequiredPass->getPassID()); | |||
| 1630 | } | |||
| 1631 | if (!FoundPass
| |||
| 1632 | FoundPass = RequiredPass; | |||
| 1633 | // This should be guaranteed to add RequiredPass to the passmanager given | |||
| 1634 | // that we checked for an available analysis above. | |||
| 1635 | FPP->add(RequiredPass); | |||
| 1636 | } | |||
| 1637 | // Register P as the last user of FoundPass or RequiredPass. | |||
| 1638 | SmallVector<Pass *, 1> LU; | |||
| 1639 | LU.push_back(FoundPass); | |||
| 1640 | FPP->setLastUser(LU, P); | |||
| 1641 | } | |||
| 1642 | ||||
| 1643 | /// Return function pass corresponding to PassInfo PI, that is | |||
| 1644 | /// required by module pass MP. Instantiate analysis pass, by using | |||
| 1645 | /// its runOnFunction() for function F. | |||
| 1646 | std::tuple<Pass *, bool> MPPassManager::getOnTheFlyPass(Pass *MP, AnalysisID PI, | |||
| 1647 | Function &F) { | |||
| 1648 | legacy::FunctionPassManagerImpl *FPP = OnTheFlyManagers[MP]; | |||
| 1649 | assert(FPP && "Unable to find on the fly pass")((void)0); | |||
| 1650 | ||||
| 1651 | FPP->releaseMemoryOnTheFly(); | |||
| 1652 | bool Changed = FPP->run(F); | |||
| 1653 | return std::make_tuple(((PMTopLevelManager *)FPP)->findAnalysisPass(PI), | |||
| 1654 | Changed); | |||
| 1655 | } | |||
| 1656 | ||||
| 1657 | namespace llvm { | |||
| 1658 | namespace legacy { | |||
| 1659 | ||||
| 1660 | //===----------------------------------------------------------------------===// | |||
| 1661 | // PassManager implementation | |||
| 1662 | ||||
| 1663 | /// Create new pass manager | |||
| 1664 | PassManager::PassManager() { | |||
| 1665 | PM = new PassManagerImpl(); | |||
| 1666 | // PM is the top level manager | |||
| 1667 | PM->setTopLevelManager(PM); | |||
| 1668 | } | |||
| 1669 | ||||
| 1670 | PassManager::~PassManager() { | |||
| 1671 | delete PM; | |||
| 1672 | } | |||
| 1673 | ||||
| 1674 | void PassManager::add(Pass *P) { | |||
| 1675 | PM->add(P); | |||
| 1676 | } | |||
| 1677 | ||||
| 1678 | /// run - Execute all of the passes scheduled for execution. Keep track of | |||
| 1679 | /// whether any of the passes modifies the module, and if so, return true. | |||
| 1680 | bool PassManager::run(Module &M) { | |||
| 1681 | return PM->run(M); | |||
| 1682 | } | |||
| 1683 | } // namespace legacy | |||
| 1684 | } // namespace llvm | |||
| 1685 | ||||
| 1686 | //===----------------------------------------------------------------------===// | |||
| 1687 | // PMStack implementation | |||
| 1688 | // | |||
| 1689 | ||||
| 1690 | // Pop Pass Manager from the stack and clear its analysis info. | |||
| 1691 | void PMStack::pop() { | |||
| 1692 | ||||
| 1693 | PMDataManager *Top = this->top(); | |||
| 1694 | Top->initializeAnalysisInfo(); | |||
| 1695 | ||||
| 1696 | S.pop_back(); | |||
| 1697 | } | |||
| 1698 | ||||
| 1699 | // Push PM on the stack and set its top level manager. | |||
| 1700 | void PMStack::push(PMDataManager *PM) { | |||
| 1701 | assert(PM && "Unable to push. Pass Manager expected")((void)0); | |||
| 1702 | assert(PM->getDepth()==0 && "Pass Manager depth set too early")((void)0); | |||
| 1703 | ||||
| 1704 | if (!this->empty()) { | |||
| 1705 | assert(PM->getPassManagerType() > this->top()->getPassManagerType()((void)0) | |||
| 1706 | && "pushing bad pass manager to PMStack")((void)0); | |||
| 1707 | PMTopLevelManager *TPM = this->top()->getTopLevelManager(); | |||
| 1708 | ||||
| 1709 | assert(TPM && "Unable to find top level manager")((void)0); | |||
| 1710 | TPM->addIndirectPassManager(PM); | |||
| 1711 | PM->setTopLevelManager(TPM); | |||
| 1712 | PM->setDepth(this->top()->getDepth()+1); | |||
| 1713 | } else { | |||
| 1714 | assert((PM->getPassManagerType() == PMT_ModulePassManager((void)0) | |||
| 1715 | || PM->getPassManagerType() == PMT_FunctionPassManager)((void)0) | |||
| 1716 | && "pushing bad pass manager to PMStack")((void)0); | |||
| 1717 | PM->setDepth(1); | |||
| 1718 | } | |||
| 1719 | ||||
| 1720 | S.push_back(PM); | |||
| 1721 | } | |||
| 1722 | ||||
| 1723 | // Dump content of the pass manager stack. | |||
| 1724 | LLVM_DUMP_METHOD__attribute__((noinline)) void PMStack::dump() const { | |||
| 1725 | for (PMDataManager *Manager : S) | |||
| 1726 | dbgs() << Manager->getAsPass()->getPassName() << ' '; | |||
| 1727 | ||||
| 1728 | if (!S.empty()) | |||
| 1729 | dbgs() << '\n'; | |||
| 1730 | } | |||
| 1731 | ||||
| 1732 | /// Find appropriate Module Pass Manager in the PM Stack and | |||
| 1733 | /// add self into that manager. | |||
| 1734 | void ModulePass::assignPassManager(PMStack &PMS, | |||
| 1735 | PassManagerType PreferredType) { | |||
| 1736 | // Find Module Pass Manager | |||
| 1737 | PassManagerType T; | |||
| 1738 | while ((T = PMS.top()->getPassManagerType()) > PMT_ModulePassManager && | |||
| 1739 | T != PreferredType) | |||
| 1740 | PMS.pop(); | |||
| 1741 | PMS.top()->add(this); | |||
| 1742 | } | |||
| 1743 | ||||
| 1744 | /// Find appropriate Function Pass Manager or Call Graph Pass Manager | |||
| 1745 | /// in the PM Stack and add self into that manager. | |||
| 1746 | void FunctionPass::assignPassManager(PMStack &PMS, | |||
| 1747 | PassManagerType /*PreferredType*/) { | |||
| 1748 | // Find Function Pass Manager | |||
| 1749 | PMDataManager *PM; | |||
| 1750 | while (PM = PMS.top(), PM->getPassManagerType() > PMT_FunctionPassManager) | |||
| 1751 | PMS.pop(); | |||
| 1752 | ||||
| 1753 | // Create new Function Pass Manager if needed. | |||
| 1754 | if (PM->getPassManagerType() != PMT_FunctionPassManager) { | |||
| 1755 | // [1] Create new Function Pass Manager | |||
| 1756 | auto *FPP = new FPPassManager; | |||
| 1757 | FPP->populateInheritedAnalysis(PMS); | |||
| 1758 | ||||
| 1759 | // [2] Set up new manager's top level manager | |||
| 1760 | PM->getTopLevelManager()->addIndirectPassManager(FPP); | |||
| 1761 | ||||
| 1762 | // [3] Assign manager to manage this new manager. This may create | |||
| 1763 | // and push new managers into PMS | |||
| 1764 | FPP->assignPassManager(PMS, PM->getPassManagerType()); | |||
| 1765 | ||||
| 1766 | // [4] Push new manager into PMS | |||
| 1767 | PMS.push(FPP); | |||
| 1768 | PM = FPP; | |||
| 1769 | } | |||
| 1770 | ||||
| 1771 | // Assign FPP as the manager of this pass. | |||
| 1772 | PM->add(this); | |||
| 1773 | } | |||
| 1774 | ||||
| 1775 | legacy::PassManagerBase::~PassManagerBase() {} |