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