Bug Summary

File:llvm/lib/IR/LegacyPassManager.cpp
Warning:line 716, column 24
Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name LegacyPassManager.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mframe-pointer=none -fmath-errno -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/build-llvm/lib/IR -resource-dir /usr/lib/llvm-14/lib/clang/14.0.0 -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/build-llvm/lib/IR -I /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/llvm/lib/IR -I /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/build-llvm/include -I /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/llvm/include -D NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/x86_64-linux-gnu/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/backward -internal-isystem /usr/lib/llvm-14/lib/clang/14.0.0/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-class-memaccess -Wno-redundant-move -Wno-pessimizing-move -Wno-noexcept-type -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/build-llvm/lib/IR -fdebug-prefix-map=/build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e=. -ferror-limit 19 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2021-09-04-040900-46481-1 -x c++ /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/llvm/lib/IR/LegacyPassManager.cpp
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>
37using 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
48namespace {
49// Different debug levels that can be enabled...
50enum PassDebugLevel {
51 Disabled, Arguments, Structure, Executions, Details
52};
53} // namespace
54
55static 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.
66bool PMDataManager::isPassDebuggingExecutionsOrMore() const {
67 return PassDebugging >= Executions;
68}
69
70unsigned 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
92void 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
213void 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
243namespace llvm {
244namespace legacy {
245bool debugPassSpecified() { return PassDebugging != Disabled; }
246
247//===----------------------------------------------------------------------===//
248// FunctionPassManagerImpl
249//
250/// FunctionPassManagerImpl manages FPPassManagers
251class FunctionPassManagerImpl : public Pass,
252 public PMDataManager,
253 public PMTopLevelManager {
254 virtual void anchor();
255private:
256 bool wasRun;
257public:
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);
7
Calling 'PMTopLevelManager::schedulePass'
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!")(static_cast<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
314void FunctionPassManagerImpl::anchor() {}
315
316char FunctionPassManagerImpl::ID = 0;
317
318//===----------------------------------------------------------------------===//
319// FunctionPassManagerImpl implementation
320//
321bool 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
336bool 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
348void 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.
362bool 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
380namespace {
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.
387class MPPassManager : public Pass, public PMDataManager {
388public:
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!")(static_cast<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
464char MPPassManager::ID = 0;
465} // End anonymous namespace
466
467namespace llvm {
468namespace legacy {
469//===----------------------------------------------------------------------===//
470// PassManagerImpl
471//
472
473/// PassManagerImpl manages MPPassManagers
474class PassManagerImpl : public Pass,
475 public PMDataManager,
476 public PMTopLevelManager {
477 virtual void anchor();
478
479public:
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!")(static_cast<void> (0));
516 MPPassManager *MP = static_cast<MPPassManager *>(PassManagers[N]);
517 return MP;
518 }
519};
520
521void PassManagerImpl::anchor() {}
522
523char 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.
531bool 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.
558PMTopLevelManager::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.
565void
566PMTopLevelManager::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.")(static_cast<void> (0));
590 AnalysisResolver *AR = AnalysisPass->getResolver();
591 assert(AR && "Expected analysis resolver to exist.")(static_cast<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
618void 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
628AnalysisUsage *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")(static_cast<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.
664void 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());
8
Calling 'PMTopLevelManager::findAnalysisPassInfo'
12
Returning from 'PMTopLevelManager::findAnalysisPassInfo'
676 if (PI
12.1
'PI' is non-null
&& PI->isAnalysis() && findAnalysisPass(P->getPassID())) {
13
Assuming the condition is false
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) {
14
Loop condition is true. Entering loop body
687 checkAnalysis = false;
688
689 const AnalysisUsage::VectorType &RequiredSet = AnUsage->getRequiredSet();
690 for (const AnalysisID ID : RequiredSet) {
15
Assuming '__begin2' is not equal to '__end2'
691
692 Pass *AnalysisPass = findAnalysisPass(ID);
693 if (!AnalysisPass) {
16
Assuming 'AnalysisPass' is null
17
Taking true branch
694 const PassInfo *PI = findAnalysisPassInfo(ID);
18
Calling 'PMTopLevelManager::findAnalysisPassInfo'
24
Returning from 'PMTopLevelManager::findAnalysisPassInfo'
25
'PI' initialized here
695
696 if (!PI) {
26
Assuming 'PI' is null
27
Taking true branch
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) {
28
Assuming '__begin5' is equal to '__end5'
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")(static_cast<void> (0));
716 AnalysisPass = PI->createPass();
29
Called C++ object pointer is null
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.
772Pass *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
791const PassInfo *PMTopLevelManager::findAnalysisPassInfo(AnalysisID AID) const {
792 const PassInfo *&PI = AnalysisPassInfos[AID];
19
'PI' initialized here
793 if (!PI)
9
Assuming 'PI' is non-null
10
Taking false branch
20
Assuming 'PI' is null
21
Taking true branch
794 PI = PassRegistry::getPassRegistry()->getPassInfo(AID);
22
Assigning value
795 else
796 assert(PI == PassRegistry::getPassRegistry()->getPassInfo(AID) &&(static_cast<void> (0))
797 "The pass info pointer changed for an analysis ID!")(static_cast<void> (0));
798
799 return PI;
11
Returning pointer (loaded from 'PI'), which participates in a condition later
23
Returning pointer (loaded from 'PI')
800}
801
802void 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")(static_cast<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.
821void 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
839void 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")(static_cast<void> (0));
848 if (!PI->isAnalysisGroup())
849 dbgs() << " -" << PI->getPassArgument();
850 }
851 for (PMDataManager *PM : PassManagers)
852 PM->dumpPassArguments();
853 dbgs() << "\n";
854}
855
856void 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
866PMTopLevelManager::~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.
878void PMDataManager::recordAvailableAnalysis(Pass *P) {
879 AnalysisID PI = P->getPassID();
880
881 AvailableAnalysis[PI] = P;
882
883 assert(!AvailableAnalysis.empty())(static_cast<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
896bool 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.
912void 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
930void 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
976void 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
997void 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.
1028void 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")(static_cast<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.
1103void 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//
1124void 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")(static_cast<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.
1141Pass *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.
1157void 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
1175void 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
1187void 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
1228void 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
1237void 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
1246void 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
1255void PMDataManager::dumpAnalysisUsage(StringRef Msg, const Pass *P,
1256 const AnalysisUsage::VectorType &Set) const {
1257 assert(PassDebugging >= Details)(static_cast<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.
1279void 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
1301std::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
1307PMDataManager::~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.
1315Pass *AnalysisResolver::getAnalysisIfAvailable(AnalysisID ID) const {
1316 return PM.findAnalysisPass(ID, true);
1317}
1318
1319std::tuple<Pass *, bool>
1320AnalysisResolver::findImplPass(Pass *P, AnalysisID AnalysisPI, Function &F) {
1321 return PM.getOnTheFlyPass(P, AnalysisPI, F);
1322}
1323
1324namespace llvm {
1325namespace legacy {
1326
1327//===----------------------------------------------------------------------===//
1328// FunctionPassManager implementation
1329
1330/// Create new Function pass manager
1331FunctionPassManager::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
1340FunctionPassManager::~FunctionPassManager() {
1341 delete FPM;
1342}
1343
1344void 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///
1352bool 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///
1362bool FunctionPassManager::doInitialization() {
1363 return FPM->doInitialization(*M);
1364}
1365
1366/// doFinalization - Run all of the finalizers for the function passes.
1367///
1368bool 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.
1375void 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")(static_cast<void> (0));
1380 AR->clearAnalysisImpls();
1381 }
1382}
1383
1384
1385//===----------------------------------------------------------------------===//
1386// FPPassManager implementation
1387
1388char FPPassManager::ID = 0;
1389/// Print passes managed by this manager
1390void 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.
1402bool 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
1481bool FPPassManager::runOnModule(Module &M) {
1482 bool Changed = false;
1483
1484 for (Function &F : M)
1485 Changed |= runOnFunction(F);
1486
1487 return Changed;
1488}
1489
1490bool 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
1499bool 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.
1514bool
1515MPPassManager::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))) &&(static_cast<void> (0))
1558 "Pass modifies its input and doesn't report it.")(static_cast<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.
1607void MPPassManager::addLowerLevelRequiredPass(Pass *P, Pass *RequiredPass) {
1608 assert(RequiredPass && "No required pass?")(static_cast<void> (0));
1609 assert(P->getPotentialPassManagerType() == PMT_ModulePassManager &&(static_cast<void> (0))
1610 "Unable to handle Pass that requires lower level Analysis pass")(static_cast<void> (0));
1611 assert((P->getPotentialPassManagerType() <(static_cast<void> (0))
1612 RequiredPass->getPotentialPassManagerType()) &&(static_cast<void> (0))
1613 "Unable to handle Pass that requires lower level Analysis pass")(static_cast<void> (0));
1614
1615 legacy::FunctionPassManagerImpl *FPP = OnTheFlyManagers[P];
1616 if (!FPP) {
1
Assuming 'FPP' is non-null
2
Taking false branch
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
2.1
'RequiredPassPI' is non-null
&& RequiredPassPI->isAnalysis()) {
3
Assuming the condition is false
4
Taking false branch
1628 FoundPass =
1629 ((PMTopLevelManager*)FPP)->findAnalysisPass(RequiredPass->getPassID());
1630 }
1631 if (!FoundPass
4.1
'FoundPass' is null
) {
5
Taking true branch
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);
6
Calling 'FunctionPassManagerImpl::add'
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.
1646std::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")(static_cast<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
1657namespace llvm {
1658namespace legacy {
1659
1660//===----------------------------------------------------------------------===//
1661// PassManager implementation
1662
1663/// Create new pass manager
1664PassManager::PassManager() {
1665 PM = new PassManagerImpl();
1666 // PM is the top level manager
1667 PM->setTopLevelManager(PM);
1668}
1669
1670PassManager::~PassManager() {
1671 delete PM;
1672}
1673
1674void 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.
1680bool 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.
1691void 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.
1700void PMStack::push(PMDataManager *PM) {
1701 assert(PM && "Unable to push. Pass Manager expected")(static_cast<void> (0));
1702 assert(PM->getDepth()==0 && "Pass Manager depth set too early")(static_cast<void> (0));
1703
1704 if (!this->empty()) {
1705 assert(PM->getPassManagerType() > this->top()->getPassManagerType()(static_cast<void> (0))
1706 && "pushing bad pass manager to PMStack")(static_cast<void> (0));
1707 PMTopLevelManager *TPM = this->top()->getTopLevelManager();
1708
1709 assert(TPM && "Unable to find top level manager")(static_cast<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(static_cast<void> (0))
1715 || PM->getPassManagerType() == PMT_FunctionPassManager)(static_cast<void> (0))
1716 && "pushing bad pass manager to PMStack")(static_cast<void> (0));
1717 PM->setDepth(1);
1718 }
1719
1720 S.push_back(PM);
1721}
1722
1723// Dump content of the pass manager stack.
1724LLVM_DUMP_METHOD__attribute__((noinline)) __attribute__((__used__)) 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.
1734void 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.
1746void 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
1775legacy::PassManagerBase::~PassManagerBase() {}