LLVM 20.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.
535
536 for (ImmutablePass *ImPass : getImmutablePasses())
537 Changed |= ImPass->doInitialization(M);
538
540 for (unsigned Index = 0; Index < getNumContainedManagers(); ++Index) {
541 Changed |= getContainedManager(Index)->runOnModule(M);
542 M.getContext().yield();
543 }
544
545 for (ImmutablePass *ImPass : getImmutablePasses())
546 Changed |= ImPass->doFinalization(M);
547
548 return Changed;
549}
550} // namespace legacy
551} // namespace llvm
552
553//===----------------------------------------------------------------------===//
554// PMTopLevelManager implementation
555
556/// Initialize top level manager. Create first pass manager.
558 PMDM->setTopLevelManager(this);
559 addPassManager(PMDM);
560 activeStack.push(PMDM);
561}
562
563/// Set pass P as the last user of the given analysis passes.
564void
566 unsigned PDepth = 0;
567 if (P->getResolver())
568 PDepth = P->getResolver()->getPMDataManager().getDepth();
569
570 for (Pass *AP : AnalysisPasses) {
571 // Record P as the new last user of AP.
572 auto &LastUserOfAP = LastUser[AP];
573 if (LastUserOfAP)
574 InversedLastUser[LastUserOfAP].erase(AP);
575 LastUserOfAP = P;
576 InversedLastUser[P].insert(AP);
577
578 if (P == AP)
579 continue;
580
581 // Update the last users of passes that are required transitive by AP.
582 AnalysisUsage *AnUsage = findAnalysisUsage(AP);
585 SmallVector<Pass *, 12> LastPMUses;
586 for (AnalysisID ID : IDs) {
587 Pass *AnalysisPass = findAnalysisPass(ID);
588 assert(AnalysisPass && "Expected analysis pass to exist.");
589 AnalysisResolver *AR = AnalysisPass->getResolver();
590 assert(AR && "Expected analysis resolver to exist.");
591 unsigned APDepth = AR->getPMDataManager().getDepth();
592
593 if (PDepth == APDepth)
594 LastUses.push_back(AnalysisPass);
595 else if (PDepth > APDepth)
596 LastPMUses.push_back(AnalysisPass);
597 }
598
599 setLastUser(LastUses, P);
600
601 // If this pass has a corresponding pass manager, push higher level
602 // analysis to this pass manager.
603 if (P->getResolver())
604 setLastUser(LastPMUses, P->getResolver()->getPMDataManager().getAsPass());
605
606 // If AP is the last user of other passes then make P last user of
607 // such passes.
608 auto &LastUsedByAP = InversedLastUser[AP];
609 for (Pass *L : LastUsedByAP)
610 LastUser[L] = P;
611 InversedLastUser[P].insert(LastUsedByAP.begin(), LastUsedByAP.end());
612 LastUsedByAP.clear();
613 }
614}
615
616/// Collect passes whose last user is P
618 Pass *P) {
619 auto DMI = InversedLastUser.find(P);
620 if (DMI == InversedLastUser.end())
621 return;
622
623 auto &LU = DMI->second;
624 LastUses.append(LU.begin(), LU.end());
625}
626
628 AnalysisUsage *AnUsage = nullptr;
629 auto DMI = AnUsageMap.find(P);
630 if (DMI != AnUsageMap.end())
631 AnUsage = DMI->second;
632 else {
633 // Look up the analysis usage from the pass instance (different instances
634 // of the same pass can produce different results), but unique the
635 // resulting object to reduce memory usage. This helps to greatly reduce
636 // memory usage when we have many instances of only a few pass types
637 // (e.g. instcombine, simplifycfg, etc...) which tend to share a fixed set
638 // of dependencies.
639 AnalysisUsage AU;
640 P->getAnalysisUsage(AU);
641
642 AUFoldingSetNode* Node = nullptr;
644 AUFoldingSetNode::Profile(ID, AU);
645 void *IP = nullptr;
646 if (auto *N = UniqueAnalysisUsages.FindNodeOrInsertPos(ID, IP))
647 Node = N;
648 else {
649 Node = new (AUFoldingSetNodeAllocator.Allocate()) AUFoldingSetNode(AU);
650 UniqueAnalysisUsages.InsertNode(Node, IP);
651 }
652 assert(Node && "cached analysis usage must be non null");
653
654 AnUsageMap[P] = &Node->AU;
655 AnUsage = &Node->AU;
656 }
657 return AnUsage;
658}
659
660/// Schedule pass P for execution. Make sure that passes required by
661/// P are run before P is run. Update analysis info maintained by
662/// the manager. Remove dead passes. This is a recursive function.
664
665 // TODO : Allocate function manager for this pass, other wise required set
666 // may be inserted into previous function manager
667
668 // Give pass a chance to prepare the stage.
669 P->preparePassManager(activeStack);
670
671 // If P is an analysis pass and it is available then do not
672 // generate the analysis again. Stale analysis info should not be
673 // available at this point.
674 const PassInfo *PI = findAnalysisPassInfo(P->getPassID());
675 if (PI && PI->isAnalysis() && findAnalysisPass(P->getPassID())) {
676 // Remove any cached AnalysisUsage information.
677 AnUsageMap.erase(P);
678 delete P;
679 return;
680 }
681
683
684 bool checkAnalysis = true;
685 while (checkAnalysis) {
686 checkAnalysis = false;
687
688 const AnalysisUsage::VectorType &RequiredSet = AnUsage->getRequiredSet();
689 for (const AnalysisID ID : RequiredSet) {
690
691 Pass *AnalysisPass = findAnalysisPass(ID);
692 if (!AnalysisPass) {
693 const PassInfo *PI = findAnalysisPassInfo(ID);
694
695 if (!PI) {
696 // Pass P is not in the global PassRegistry
697 dbgs() << "Pass '" << P->getPassName() << "' is not initialized." << "\n";
698 dbgs() << "Verify if there is a pass dependency cycle." << "\n";
699 dbgs() << "Required Passes:" << "\n";
700 for (const AnalysisID ID2 : RequiredSet) {
701 if (ID == ID2)
702 break;
703 Pass *AnalysisPass2 = findAnalysisPass(ID2);
704 if (AnalysisPass2) {
705 dbgs() << "\t" << AnalysisPass2->getPassName() << "\n";
706 } else {
707 dbgs() << "\t" << "Error: Required pass not found! Possible causes:" << "\n";
708 dbgs() << "\t\t" << "- Pass misconfiguration (e.g.: missing macros)" << "\n";
709 dbgs() << "\t\t" << "- Corruption of the global PassRegistry" << "\n";
710 }
711 }
712 }
713
714 assert(PI && "Expected required passes to be initialized");
715 AnalysisPass = PI->createPass();
716 if (P->getPotentialPassManagerType () ==
717 AnalysisPass->getPotentialPassManagerType())
718 // Schedule analysis pass that is managed by the same pass manager.
719 schedulePass(AnalysisPass);
720 else if (P->getPotentialPassManagerType () >
721 AnalysisPass->getPotentialPassManagerType()) {
722 // Schedule analysis pass that is managed by a new manager.
723 schedulePass(AnalysisPass);
724 // Recheck analysis passes to ensure that required analyses that
725 // are already checked are still available.
726 checkAnalysis = true;
727 } else
728 // Do not schedule this analysis. Lower level analysis
729 // passes are run on the fly.
730 delete AnalysisPass;
731 }
732 }
733 }
734
735 // Now all required passes are available.
736 if (ImmutablePass *IP = P->getAsImmutablePass()) {
737 // P is a immutable pass and it will be managed by this
738 // top level manager. Set up analysis resolver to connect them.
739 PMDataManager *DM = getAsPMDataManager();
741 P->setResolver(AR);
742 DM->initializeAnalysisImpl(P);
744 DM->recordAvailableAnalysis(IP);
745 return;
746 }
747
748 if (PI && !PI->isAnalysis() && shouldPrintBeforePass(PI->getPassArgument())) {
749 Pass *PP =
750 P->createPrinterPass(dbgs(), ("*** IR Dump Before " + P->getPassName() +
751 " (" + PI->getPassArgument() + ") ***")
752 .str());
753 PP->assignPassManager(activeStack, getTopLevelPassManagerType());
754 }
755
756 // Add the requested pass to the best available pass manager.
757 P->assignPassManager(activeStack, getTopLevelPassManagerType());
758
759 if (PI && !PI->isAnalysis() && shouldPrintAfterPass(PI->getPassArgument())) {
760 Pass *PP =
761 P->createPrinterPass(dbgs(), ("*** IR Dump After " + P->getPassName() +
762 " (" + PI->getPassArgument() + ") ***")
763 .str());
764 PP->assignPassManager(activeStack, getTopLevelPassManagerType());
765 }
766}
767
768/// Find the pass that implements Analysis AID. Search immutable
769/// passes and all pass managers. If desired pass is not found
770/// then return NULL.
772 // For immutable passes we have a direct mapping from ID to pass, so check
773 // that first.
774 if (Pass *P = ImmutablePassMap.lookup(AID))
775 return P;
776
777 // Check pass managers
779 if (Pass *P = PassManager->findAnalysisPass(AID, false))
780 return P;
781
782 // Check other pass managers
783 for (PMDataManager *IndirectPassManager : IndirectPassManagers)
784 if (Pass *P = IndirectPassManager->findAnalysisPass(AID, false))
785 return P;
786
787 return nullptr;
788}
789
791 const PassInfo *&PI = AnalysisPassInfos[AID];
792 if (!PI)
794 else
796 "The pass info pointer changed for an analysis ID!");
797
798 return PI;
799}
800
802 P->initializePass();
803 ImmutablePasses.push_back(P);
804
805 // Add this pass to the map from its analysis ID. We clobber any prior runs
806 // of the pass in the map so that the last one added is the one found when
807 // doing lookups.
808 AnalysisID AID = P->getPassID();
809 ImmutablePassMap[AID] = P;
810}
811
812// Print passes managed by this top level manager.
814
815 if (PassDebugging < Structure)
816 return;
817
818 // Print out the immutable passes
819 for (ImmutablePass *Pass : ImmutablePasses)
821
822 // Every class that derives from PMDataManager also derives from Pass
823 // (sometimes indirectly), but there's no inheritance relationship
824 // between PMDataManager and Pass, so we have to getAsPass to get
825 // from a PMDataManager* to a Pass*.
826 for (PMDataManager *Manager : PassManagers)
827 Manager->getAsPass()->dumpPassStructure(1);
828}
829
831
833 return;
834
835 dbgs() << "Pass Arguments: ";
836 for (ImmutablePass *P : ImmutablePasses)
837 if (const PassInfo *PI = findAnalysisPassInfo(P->getPassID())) {
838 assert(PI && "Expected all immutable passes to be initialized");
839 dbgs() << " -" << PI->getPassArgument();
840 }
841 for (PMDataManager *PM : PassManagers)
842 PM->dumpPassArguments();
843 dbgs() << "\n";
844}
845
847 for (PMDataManager *PM : PassManagers)
848 PM->initializeAnalysisInfo();
849
850 // Initailize other pass managers
851 for (PMDataManager *IPM : IndirectPassManagers)
852 IPM->initializeAnalysisInfo();
853}
854
855/// Destructor
857 for (PMDataManager *PM : PassManagers)
858 delete PM;
859
860 for (ImmutablePass *P : ImmutablePasses)
861 delete P;
862}
863
864//===----------------------------------------------------------------------===//
865// PMDataManager implementation
866
867/// Augement AvailableAnalysis by adding analysis made available by pass P.
869 AnalysisID PI = P->getPassID();
870
871 AvailableAnalysis[PI] = P;
872}
873
874// Return true if P preserves high level analysis used by other
875// passes managed by this manager
878 if (AnUsage->getPreservesAll())
879 return true;
880
881 const AnalysisUsage::VectorType &PreservedSet = AnUsage->getPreservedSet();
882 for (Pass *P1 : HigherLevelAnalysis) {
883 if (P1->getAsImmutablePass() == nullptr &&
884 !is_contained(PreservedSet, P1->getPassID()))
885 return false;
886 }
887
888 return true;
889}
890
891/// verifyPreservedAnalysis -- Verify analysis preserved by pass P.
893 // Don't do this unless assertions are enabled.
894#ifdef NDEBUG
895 return;
896#endif
898 const AnalysisUsage::VectorType &PreservedSet = AnUsage->getPreservedSet();
899
900 // Verify preserved analysis
901 for (AnalysisID AID : PreservedSet) {
902 if (Pass *AP = findAnalysisPass(AID, true)) {
903 TimeRegion PassTimer(getPassTimer(AP));
904 AP->verifyAnalysis();
905 }
906 }
907}
908
909/// Remove Analysis not preserved by Pass P
912 if (AnUsage->getPreservesAll())
913 return;
914
915 const AnalysisUsage::VectorType &PreservedSet = AnUsage->getPreservedSet();
916 for (DenseMap<AnalysisID, Pass*>::iterator I = AvailableAnalysis.begin(),
917 E = AvailableAnalysis.end(); I != E; ) {
919 if (Info->second->getAsImmutablePass() == nullptr &&
920 !is_contained(PreservedSet, Info->first)) {
921 // Remove this analysis
922 if (PassDebugging >= Details) {
923 Pass *S = Info->second;
924 dbgs() << " -- '" << P->getPassName() << "' is not preserving '";
925 dbgs() << S->getPassName() << "'\n";
926 }
927 AvailableAnalysis.erase(Info);
928 }
929 }
930
931 // Check inherited analysis also. If P is not preserving analysis
932 // provided by parent manager then remove it here.
934 if (!IA)
935 continue;
936
937 for (DenseMap<AnalysisID, Pass *>::iterator I = IA->begin(),
938 E = IA->end();
939 I != E;) {
941 if (Info->second->getAsImmutablePass() == nullptr &&
942 !is_contained(PreservedSet, Info->first)) {
943 // Remove this analysis
944 if (PassDebugging >= Details) {
945 Pass *S = Info->second;
946 dbgs() << " -- '" << P->getPassName() << "' is not preserving '";
947 dbgs() << S->getPassName() << "'\n";
948 }
949 IA->erase(Info);
950 }
951 }
952 }
953}
954
955/// Remove analysis passes that are not used any longer
957 enum PassDebuggingString DBG_STR) {
958
959 SmallVector<Pass *, 12> DeadPasses;
960
961 // If this is a on the fly manager then it does not have TPM.
962 if (!TPM)
963 return;
964
965 TPM->collectLastUses(DeadPasses, P);
966
967 if (PassDebugging >= Details && !DeadPasses.empty()) {
968 dbgs() << " -*- '" << P->getPassName();
969 dbgs() << "' is the last user of following pass instances.";
970 dbgs() << " Free these instances\n";
971 }
972
973 for (Pass *P : DeadPasses)
974 freePass(P, Msg, DBG_STR);
975}
976
978 enum PassDebuggingString DBG_STR) {
979 dumpPassInfo(P, FREEING_MSG, DBG_STR, Msg);
980
981 {
982 // If the pass crashes releasing memory, remember this.
984 TimeRegion PassTimer(getPassTimer(P));
985
986 P->releaseMemory();
987 }
988
989 // Remove the pass itself (if it is not already removed).
990 AvailableAnalysis.erase(P->getPassID());
991}
992
993/// Add pass P into the PassVector. Update
994/// AvailableAnalysis appropriately if ProcessAnalysis is true.
995void PMDataManager::add(Pass *P, bool ProcessAnalysis) {
996 // This manager is going to manage pass P. Set up analysis resolver
997 // to connect them.
998 AnalysisResolver *AR = new AnalysisResolver(*this);
999 P->setResolver(AR);
1000
1001 // If a FunctionPass F is the last user of ModulePass info M
1002 // then the F's manager, not F, records itself as a last user of M.
1003 SmallVector<Pass *, 12> TransferLastUses;
1004
1005 if (!ProcessAnalysis) {
1006 // Add pass
1007 PassVector.push_back(P);
1008 return;
1009 }
1010
1011 // At the moment, this pass is the last user of all required passes.
1012 SmallVector<Pass *, 12> LastUses;
1013 SmallVector<Pass *, 8> UsedPasses;
1014 SmallVector<AnalysisID, 8> ReqAnalysisNotAvailable;
1015
1016 unsigned PDepth = this->getDepth();
1017
1018 collectRequiredAndUsedAnalyses(UsedPasses, ReqAnalysisNotAvailable, P);
1019 for (Pass *PUsed : UsedPasses) {
1020 unsigned RDepth = 0;
1021
1022 assert(PUsed->getResolver() && "Analysis Resolver is not set");
1023 PMDataManager &DM = PUsed->getResolver()->getPMDataManager();
1024 RDepth = DM.getDepth();
1025
1026 if (PDepth == RDepth)
1027 LastUses.push_back(PUsed);
1028 else if (PDepth > RDepth) {
1029 // Let the parent claim responsibility of last use
1030 TransferLastUses.push_back(PUsed);
1031 // Keep track of higher level analysis used by this manager.
1032 HigherLevelAnalysis.push_back(PUsed);
1033 } else
1034 llvm_unreachable("Unable to accommodate Used Pass");
1035 }
1036
1037 // Set P as P's last user until someone starts using P.
1038 // However, if P is a Pass Manager then it does not need
1039 // to record its last user.
1040 if (!P->getAsPMDataManager())
1041 LastUses.push_back(P);
1042 TPM->setLastUser(LastUses, P);
1043
1044 if (!TransferLastUses.empty()) {
1045 Pass *My_PM = getAsPass();
1046 TPM->setLastUser(TransferLastUses, My_PM);
1047 TransferLastUses.clear();
1048 }
1049
1050 // Now, take care of required analyses that are not available.
1051 for (AnalysisID ID : ReqAnalysisNotAvailable) {
1052 const PassInfo *PI = TPM->findAnalysisPassInfo(ID);
1053 Pass *AnalysisPass = PI->createPass();
1054 this->addLowerLevelRequiredPass(P, AnalysisPass);
1055 }
1056
1057 // Take a note of analysis required and made available by this pass.
1058 // Remove the analysis not preserved by this pass
1061
1062 // Add pass
1063 PassVector.push_back(P);
1064}
1065
1066
1067/// Populate UP with analysis pass that are used or required by
1068/// pass P and are available. Populate RP_NotAvail with analysis
1069/// pass that are required by pass P but are not available.
1072 Pass *P) {
1073 AnalysisUsage *AnUsage = TPM->findAnalysisUsage(P);
1074
1075 for (const auto &UsedID : AnUsage->getUsedSet())
1076 if (Pass *AnalysisPass = findAnalysisPass(UsedID, true))
1077 UP.push_back(AnalysisPass);
1078
1079 for (const auto &RequiredID : AnUsage->getRequiredSet())
1080 if (Pass *AnalysisPass = findAnalysisPass(RequiredID, true))
1081 UP.push_back(AnalysisPass);
1082 else
1083 RP_NotAvail.push_back(RequiredID);
1084}
1085
1086// All Required analyses should be available to the pass as it runs! Here
1087// we fill in the AnalysisImpls member of the pass so that it can
1088// successfully use the getAnalysis() method to retrieve the
1089// implementations it needs.
1090//
1092 AnalysisUsage *AnUsage = TPM->findAnalysisUsage(P);
1093
1094 for (const AnalysisID ID : AnUsage->getRequiredSet()) {
1095 Pass *Impl = findAnalysisPass(ID, true);
1096 if (!Impl)
1097 // This may be analysis pass that is initialized on the fly.
1098 // If that is not the case then it will raise an assert when it is used.
1099 continue;
1100 AnalysisResolver *AR = P->getResolver();
1101 assert(AR && "Analysis Resolver is not set");
1102 AR->addAnalysisImplsPair(ID, Impl);
1103 }
1104}
1105
1106/// Find the pass that implements Analysis AID. If desired pass is not found
1107/// then return NULL.
1109
1110 // Check if AvailableAnalysis map has one entry.
1111 DenseMap<AnalysisID, Pass*>::const_iterator I = AvailableAnalysis.find(AID);
1112
1113 if (I != AvailableAnalysis.end())
1114 return I->second;
1115
1116 // Search Parents through TopLevelManager
1117 if (SearchParent)
1118 return TPM->findAnalysisPass(AID);
1119
1120 return nullptr;
1121}
1122
1123// Print list of passes that are last used by P.
1125 if (PassDebugging < Details)
1126 return;
1127
1129
1130 // If this is a on the fly manager then it does not have TPM.
1131 if (!TPM)
1132 return;
1133
1134 TPM->collectLastUses(LUses, P);
1135
1136 for (Pass *P : LUses) {
1137 dbgs() << "--" << std::string(Offset*2, ' ');
1138 P->dumpPassStructure(0);
1139 }
1140}
1141
1143 for (Pass *P : PassVector) {
1144 if (PMDataManager *PMD = P->getAsPMDataManager())
1145 PMD->dumpPassArguments();
1146 else if (const PassInfo *PI = TPM->findAnalysisPassInfo(P->getPassID()))
1147 dbgs() << " -" << PI->getPassArgument();
1148 }
1149}
1150
1152 enum PassDebuggingString S2,
1153 StringRef Msg) {
1154 if (PassDebugging < Executions)
1155 return;
1156 dbgs() << "[" << std::chrono::system_clock::now() << "] " << (void *)this
1157 << std::string(getDepth() * 2 + 1, ' ');
1158 switch (S1) {
1159 case EXECUTION_MSG:
1160 dbgs() << "Executing Pass '" << P->getPassName();
1161 break;
1162 case MODIFICATION_MSG:
1163 dbgs() << "Made Modification '" << P->getPassName();
1164 break;
1165 case FREEING_MSG:
1166 dbgs() << " Freeing Pass '" << P->getPassName();
1167 break;
1168 default:
1169 break;
1170 }
1171 switch (S2) {
1172 case ON_FUNCTION_MSG:
1173 dbgs() << "' on Function '" << Msg << "'...\n";
1174 break;
1175 case ON_MODULE_MSG:
1176 dbgs() << "' on Module '" << Msg << "'...\n";
1177 break;
1178 case ON_REGION_MSG:
1179 dbgs() << "' on Region '" << Msg << "'...\n";
1180 break;
1181 case ON_LOOP_MSG:
1182 dbgs() << "' on Loop '" << Msg << "'...\n";
1183 break;
1184 case ON_CG_MSG:
1185 dbgs() << "' on Call Graph Nodes '" << Msg << "'...\n";
1186 break;
1187 default:
1188 break;
1189 }
1190}
1191
1193 if (PassDebugging < Details)
1194 return;
1195
1196 AnalysisUsage analysisUsage;
1197 P->getAnalysisUsage(analysisUsage);
1198 dumpAnalysisUsage("Required", P, analysisUsage.getRequiredSet());
1199}
1200
1202 if (PassDebugging < Details)
1203 return;
1204
1205 AnalysisUsage analysisUsage;
1206 P->getAnalysisUsage(analysisUsage);
1207 dumpAnalysisUsage("Preserved", P, analysisUsage.getPreservedSet());
1208}
1209
1211 if (PassDebugging < Details)
1212 return;
1213
1214 AnalysisUsage analysisUsage;
1215 P->getAnalysisUsage(analysisUsage);
1216 dumpAnalysisUsage("Used", P, analysisUsage.getUsedSet());
1217}
1218
1219void PMDataManager::dumpAnalysisUsage(StringRef Msg, const Pass *P,
1220 const AnalysisUsage::VectorType &Set) const {
1221 assert(PassDebugging >= Details);
1222 if (Set.empty())
1223 return;
1224 dbgs() << (const void*)P << std::string(getDepth()*2+3, ' ') << Msg << " Analyses:";
1225 for (unsigned i = 0; i != Set.size(); ++i) {
1226 if (i) dbgs() << ',';
1227 const PassInfo *PInf = TPM->findAnalysisPassInfo(Set[i]);
1228 if (!PInf) {
1229 // Some preserved passes, such as AliasAnalysis, may not be initialized by
1230 // all drivers.
1231 dbgs() << " Uninitialized Pass";
1232 continue;
1233 }
1234 dbgs() << ' ' << PInf->getPassName();
1235 }
1236 dbgs() << '\n';
1237}
1238
1239/// Add RequiredPass into list of lower level passes required by pass P.
1240/// RequiredPass is run on the fly by Pass Manager when P requests it
1241/// through getAnalysis interface.
1242/// This should be handled by specific pass manager.
1244 if (TPM) {
1245 TPM->dumpArguments();
1246 TPM->dumpPasses();
1247 }
1248
1249 // Module Level pass may required Function Level analysis info
1250 // (e.g. dominator info). Pass manager uses on the fly function pass manager
1251 // to provide this on demand. In that case, in Pass manager terminology,
1252 // module level pass is requiring lower level analysis info managed by
1253 // lower level pass manager.
1254
1255 // When Pass manager is not able to order required analysis info, Pass manager
1256 // checks whether any lower level manager will be able to provide this
1257 // analysis info on demand or not.
1258#ifndef NDEBUG
1259 dbgs() << "Unable to schedule '" << RequiredPass->getPassName();
1260 dbgs() << "' required by '" << P->getPassName() << "'\n";
1261#endif
1262 llvm_unreachable("Unable to schedule pass");
1263}
1264
1265std::tuple<Pass *, bool> PMDataManager::getOnTheFlyPass(Pass *P, AnalysisID PI,
1266 Function &F) {
1267 llvm_unreachable("Unable to find on the fly pass");
1268}
1269
1270// Destructor
1272 for (Pass *P : PassVector)
1273 delete P;
1274}
1275
1276//===----------------------------------------------------------------------===//
1277// NOTE: Is this the right place to define this method ?
1278// getAnalysisIfAvailable - Return analysis result or null if it doesn't exist.
1280 return PM.findAnalysisPass(ID, true);
1281}
1282
1283std::tuple<Pass *, bool>
1285 return PM.getOnTheFlyPass(P, AnalysisPI, F);
1286}
1287
1288namespace llvm {
1289namespace legacy {
1290
1291//===----------------------------------------------------------------------===//
1292// FunctionPassManager implementation
1293
1294/// Create new Function pass manager
1295FunctionPassManager::FunctionPassManager(Module *m) : M(m) {
1297 // FPM is the top level manager.
1298 FPM->setTopLevelManager(FPM);
1299
1300 AnalysisResolver *AR = new AnalysisResolver(*FPM);
1301 FPM->setResolver(AR);
1302}
1303
1304FunctionPassManager::~FunctionPassManager() {
1305 delete FPM;
1306}
1307
1308void FunctionPassManager::add(Pass *P) {
1309 FPM->add(P);
1310}
1311
1312/// run - Execute all of the passes scheduled for execution. Keep
1313/// track of whether any of the passes modifies the function, and if
1314/// so, return true.
1315///
1317 handleAllErrors(F.materialize(), [&](ErrorInfoBase &EIB) {
1318 report_fatal_error(Twine("Error reading bitcode file: ") + EIB.message());
1319 });
1320 return FPM->run(F);
1321}
1322
1323
1324/// doInitialization - Run all of the initializers for the function passes.
1325///
1326bool FunctionPassManager::doInitialization() {
1327 return FPM->doInitialization(*M);
1328}
1329
1330/// doFinalization - Run all of the finalizers for the function passes.
1331///
1332bool FunctionPassManager::doFinalization() {
1333 return FPM->doFinalization(*M);
1334}
1335} // namespace legacy
1336} // namespace llvm
1337
1338/// cleanup - After running all passes, clean up pass manager cache.
1340 for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) {
1342 AnalysisResolver *AR = FP->getResolver();
1343 assert(AR && "Analysis Resolver is not set");
1344 AR->clearAnalysisImpls();
1345 }
1346}
1347
1348
1349//===----------------------------------------------------------------------===//
1350// FPPassManager implementation
1351
1352char FPPassManager::ID = 0;
1353/// Print passes managed by this manager
1355 dbgs().indent(Offset*2) << "FunctionPass Manager\n";
1356 for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) {
1358 FP->dumpPassStructure(Offset + 1);
1360 }
1361}
1362
1363/// Execute all of the passes scheduled for execution by invoking
1364/// runOnFunction method. Keep track of whether any of the passes modifies
1365/// the function, and if so, return true.
1367 if (F.isDeclaration())
1368 return false;
1369
1370 bool Changed = false;
1371 Module &M = *F.getParent();
1372 // Collect inherited analysis from Module level pass manager.
1374
1375 unsigned InstrCount, FunctionSize = 0;
1376 StringMap<std::pair<unsigned, unsigned>> FunctionToInstrCount;
1377 bool EmitICRemark = M.shouldEmitInstrCountChangedRemark();
1378 // Collect the initial size of the module.
1379 if (EmitICRemark) {
1380 InstrCount = initSizeRemarkInfo(M, FunctionToInstrCount);
1381 FunctionSize = F.getInstructionCount();
1382 }
1383
1384 // Store name outside of loop to avoid redundant calls.
1385 const StringRef Name = F.getName();
1386 llvm::TimeTraceScope FunctionScope("OptFunction", Name);
1387
1388 for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) {
1390 bool LocalChanged = false;
1391
1392 // Call getPassName only when required. The call itself is fairly cheap, but
1393 // still virtual and repeated calling adds unnecessary overhead.
1394 llvm::TimeTraceScope PassScope(
1395 "RunPass", [FP]() { return std::string(FP->getPassName()); });
1396
1399
1401
1402 {
1404 TimeRegion PassTimer(getPassTimer(FP));
1405#ifdef EXPENSIVE_CHECKS
1406 uint64_t RefHash = FP->structuralHash(F);
1407#endif
1408 LocalChanged |= FP->runOnFunction(F);
1409
1410#if defined(EXPENSIVE_CHECKS) && !defined(NDEBUG)
1411 if (!LocalChanged && (RefHash != FP->structuralHash(F))) {
1412 llvm::errs() << "Pass modifies its input and doesn't report it: "
1413 << FP->getPassName() << "\n";
1414 llvm_unreachable("Pass modifies its input and doesn't report it");
1415 }
1416#endif
1417
1418 if (EmitICRemark) {
1419 unsigned NewSize = F.getInstructionCount();
1420
1421 // Update the size of the function, emit a remark, and update the size
1422 // of the module.
1423 if (NewSize != FunctionSize) {
1424 int64_t Delta = static_cast<int64_t>(NewSize) -
1425 static_cast<int64_t>(FunctionSize);
1427 FunctionToInstrCount, &F);
1428 InstrCount = static_cast<int64_t>(InstrCount) + Delta;
1429 FunctionSize = NewSize;
1430 }
1431 }
1432 }
1433
1434 Changed |= LocalChanged;
1435 if (LocalChanged)
1438 dumpUsedSet(FP);
1439
1441 if (LocalChanged)
1445 }
1446
1447 return Changed;
1448}
1449
1451 bool Changed = false;
1452
1453 for (Function &F : M)
1454 Changed |= runOnFunction(F);
1455
1456 return Changed;
1457}
1458
1460 bool Changed = false;
1461
1462 for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index)
1463 Changed |= getContainedPass(Index)->doInitialization(M);
1464
1465 return Changed;
1466}
1467
1469 bool Changed = false;
1470
1471 for (int Index = getNumContainedPasses() - 1; Index >= 0; --Index)
1472 Changed |= getContainedPass(Index)->doFinalization(M);
1473
1474 return Changed;
1475}
1476
1477//===----------------------------------------------------------------------===//
1478// MPPassManager implementation
1479
1480/// Execute all of the passes scheduled for execution by invoking
1481/// runOnModule method. Keep track of whether any of the passes modifies
1482/// the module, and if so, return true.
1483bool
1484MPPassManager::runOnModule(Module &M) {
1485 llvm::TimeTraceScope TimeScope("OptModule", M.getName());
1486
1487 bool Changed = false;
1488
1489 // Initialize on-the-fly passes
1490 for (auto &OnTheFlyManager : OnTheFlyManagers) {
1491 legacy::FunctionPassManagerImpl *FPP = OnTheFlyManager.second;
1492 Changed |= FPP->doInitialization(M);
1493 }
1494
1495 // Initialize module passes
1496 for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index)
1497 Changed |= getContainedPass(Index)->doInitialization(M);
1498
1499 unsigned InstrCount;
1500 StringMap<std::pair<unsigned, unsigned>> FunctionToInstrCount;
1501 bool EmitICRemark = M.shouldEmitInstrCountChangedRemark();
1502 // Collect the initial size of the module.
1503 if (EmitICRemark)
1504 InstrCount = initSizeRemarkInfo(M, FunctionToInstrCount);
1505
1506 for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) {
1507 ModulePass *MP = getContainedPass(Index);
1508 bool LocalChanged = false;
1509
1510 dumpPassInfo(MP, EXECUTION_MSG, ON_MODULE_MSG, M.getModuleIdentifier());
1511 dumpRequiredSet(MP);
1512
1513 initializeAnalysisImpl(MP);
1514
1515 {
1517 TimeRegion PassTimer(getPassTimer(MP));
1518
1519#ifdef EXPENSIVE_CHECKS
1520 uint64_t RefHash = MP->structuralHash(M);
1521#endif
1522
1523 LocalChanged |= MP->runOnModule(M);
1524
1525#ifdef EXPENSIVE_CHECKS
1526 assert((LocalChanged || (RefHash == MP->structuralHash(M))) &&
1527 "Pass modifies its input and doesn't report it.");
1528#endif
1529
1530 if (EmitICRemark) {
1531 // Update the size of the module.
1532 unsigned ModuleCount = M.getInstructionCount();
1533 if (ModuleCount != InstrCount) {
1534 int64_t Delta = static_cast<int64_t>(ModuleCount) -
1535 static_cast<int64_t>(InstrCount);
1536 emitInstrCountChangedRemark(MP, M, Delta, InstrCount,
1537 FunctionToInstrCount);
1538 InstrCount = ModuleCount;
1539 }
1540 }
1541 }
1542
1543 Changed |= LocalChanged;
1544 if (LocalChanged)
1545 dumpPassInfo(MP, MODIFICATION_MSG, ON_MODULE_MSG,
1546 M.getModuleIdentifier());
1547 dumpPreservedSet(MP);
1548 dumpUsedSet(MP);
1549
1550 verifyPreservedAnalysis(MP);
1551 if (LocalChanged)
1552 removeNotPreservedAnalysis(MP);
1553 recordAvailableAnalysis(MP);
1554 removeDeadPasses(MP, M.getModuleIdentifier(), ON_MODULE_MSG);
1555 }
1556
1557 // Finalize module passes
1558 for (int Index = getNumContainedPasses() - 1; Index >= 0; --Index)
1559 Changed |= getContainedPass(Index)->doFinalization(M);
1560
1561 // Finalize on-the-fly passes
1562 for (auto &OnTheFlyManager : OnTheFlyManagers) {
1563 legacy::FunctionPassManagerImpl *FPP = OnTheFlyManager.second;
1564 // We don't know when is the last time an on-the-fly pass is run,
1565 // so we need to releaseMemory / finalize here
1566 FPP->releaseMemoryOnTheFly();
1567 Changed |= FPP->doFinalization(M);
1568 }
1569
1570 return Changed;
1571}
1572
1573/// Add RequiredPass into list of lower level passes required by pass P.
1574/// RequiredPass is run on the fly by Pass Manager when P requests it
1575/// through getAnalysis interface.
1576void MPPassManager::addLowerLevelRequiredPass(Pass *P, Pass *RequiredPass) {
1577 assert(RequiredPass && "No required pass?");
1578 assert(P->getPotentialPassManagerType() == PMT_ModulePassManager &&
1579 "Unable to handle Pass that requires lower level Analysis pass");
1580 assert((P->getPotentialPassManagerType() <
1581 RequiredPass->getPotentialPassManagerType()) &&
1582 "Unable to handle Pass that requires lower level Analysis pass");
1583
1584 legacy::FunctionPassManagerImpl *FPP = OnTheFlyManagers[P];
1585 if (!FPP) {
1587 // FPP is the top level manager.
1588 FPP->setTopLevelManager(FPP);
1589
1590 OnTheFlyManagers[P] = FPP;
1591 }
1592 const PassInfo *RequiredPassPI =
1593 TPM->findAnalysisPassInfo(RequiredPass->getPassID());
1594
1595 Pass *FoundPass = nullptr;
1596 if (RequiredPassPI && RequiredPassPI->isAnalysis()) {
1597 FoundPass =
1598 ((PMTopLevelManager*)FPP)->findAnalysisPass(RequiredPass->getPassID());
1599 }
1600 if (!FoundPass) {
1601 FoundPass = RequiredPass;
1602 // This should be guaranteed to add RequiredPass to the passmanager given
1603 // that we checked for an available analysis above.
1604 FPP->add(RequiredPass);
1605 }
1606 // Register P as the last user of FoundPass or RequiredPass.
1608 LU.push_back(FoundPass);
1609 FPP->setLastUser(LU, P);
1610}
1611
1612/// Return function pass corresponding to PassInfo PI, that is
1613/// required by module pass MP. Instantiate analysis pass, by using
1614/// its runOnFunction() for function F.
1615std::tuple<Pass *, bool> MPPassManager::getOnTheFlyPass(Pass *MP, AnalysisID PI,
1616 Function &F) {
1617 legacy::FunctionPassManagerImpl *FPP = OnTheFlyManagers[MP];
1618 assert(FPP && "Unable to find on the fly pass");
1619
1620 FPP->releaseMemoryOnTheFly();
1621 bool Changed = FPP->run(F);
1622 return std::make_tuple(((PMTopLevelManager *)FPP)->findAnalysisPass(PI),
1623 Changed);
1624}
1625
1626namespace llvm {
1627namespace legacy {
1628
1629//===----------------------------------------------------------------------===//
1630// PassManager implementation
1631
1632/// Create new pass manager
1634 PM = new PassManagerImpl();
1635 // PM is the top level manager
1636 PM->setTopLevelManager(PM);
1637}
1638
1640 delete PM;
1641}
1642
1644 PM->add(P);
1645}
1646
1647/// run - Execute all of the passes scheduled for execution. Keep track of
1648/// whether any of the passes modifies the module, and if so, return true.
1650 return PM->run(M);
1651}
1652} // namespace legacy
1653} // namespace llvm
1654
1655//===----------------------------------------------------------------------===//
1656// PMStack implementation
1657//
1658
1659// Pop Pass Manager from the stack and clear its analysis info.
1661
1662 PMDataManager *Top = this->top();
1664
1665 S.pop_back();
1666}
1667
1668// Push PM on the stack and set its top level manager.
1670 assert(PM && "Unable to push. Pass Manager expected");
1671 assert(PM->getDepth()==0 && "Pass Manager depth set too early");
1672
1673 if (!this->empty()) {
1674 assert(PM->getPassManagerType() > this->top()->getPassManagerType()
1675 && "pushing bad pass manager to PMStack");
1676 PMTopLevelManager *TPM = this->top()->getTopLevelManager();
1677
1678 assert(TPM && "Unable to find top level manager");
1679 TPM->addIndirectPassManager(PM);
1680 PM->setTopLevelManager(TPM);
1681 PM->setDepth(this->top()->getDepth()+1);
1682 } else {
1685 && "pushing bad pass manager to PMStack");
1686 PM->setDepth(1);
1687 }
1688
1689 S.push_back(PM);
1690}
1691
1692// Dump content of the pass manager stack.
1694 for (PMDataManager *Manager : S)
1695 dbgs() << Manager->getAsPass()->getPassName() << ' ';
1696
1697 if (!S.empty())
1698 dbgs() << '\n';
1699}
1700
1701/// Find appropriate Module Pass Manager in the PM Stack and
1702/// add self into that manager.
1704 PassManagerType PreferredType) {
1705 // Find Module Pass Manager
1707 while ((T = PMS.top()->getPassManagerType()) > PMT_ModulePassManager &&
1708 T != PreferredType)
1709 PMS.pop();
1710 PMS.top()->add(this);
1711}
1712
1713/// Find appropriate Function Pass Manager or Call Graph Pass Manager
1714/// in the PM Stack and add self into that manager.
1716 PassManagerType /*PreferredType*/) {
1717 // Find Function Pass Manager
1718 PMDataManager *PM;
1719 while (PM = PMS.top(), PM->getPassManagerType() > PMT_FunctionPassManager)
1720 PMS.pop();
1721
1722 // Create new Function Pass Manager if needed.
1724 // [1] Create new Function Pass Manager
1725 auto *FPP = new FPPassManager;
1726 FPP->populateInheritedAnalysis(PMS);
1727
1728 // [2] Set up new manager's top level manager
1730
1731 // [3] Assign manager to manage this new manager. This may create
1732 // and push new managers into PMS
1733 FPP->assignPassManager(PMS, PM->getPassManagerType());
1734
1735 // [4] Push new manager into PMS
1736 PMS.push(FPP);
1737 PM = FPP;
1738 }
1739
1740 // Assign FPP as the manager of this pass.
1741 PM->add(this);
1742}
1743
static const LLT S1
AMDGPU Lower Kernel Arguments
Analysis containing CSE Info
Definition: CSEInfo.cpp:27
#define clEnumVal(ENUMVAL, DESC)
Definition: CommandLine.h:684
#define LLVM_DUMP_METHOD
Mark debug helper function definitions like dump() that should not be stripped from debug builds.
Definition: Compiler.h:533
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:61
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:513
T * FindNodeOrInsertPos(const FoldingSetNodeID &ID, void *&InsertPos)
FindNodeOrInsertPos - Look up the node specified by ID.
Definition: FoldingSet.h:505
FoldingSetNodeID - This class is used to gather all the unique data bits of a node.
Definition: FoldingSet.h:327
FunctionPass class - This class is used to implement most global optimizations.
Definition: Pass.h:310
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:857
ImmutablePass class - This class is used to provide information that does not need to be run.
Definition: Pass.h:281
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:265
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:68
StringRef getPassArgument() const
getPassArgument - Return the command line option that may be passed to 'opt' that will cause this pas...
Definition: PassInfo.h:59
StringRef getPassName() const
getPassName - Return the friendly name for the pass, never returns null
Definition: PassInfo.h:54
Pass * createPass() const
createPass() - Use this method to create an instance of this pass.
Definition: PassInfo.h:85
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:162
PreservedAnalyses run(Function &IR, AnalysisManager< Function > &AM, ExtraArgTs... ExtraArgs)
Run all of the passes in this manager over the given unit of IR.
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
Used to temporarily set the debug info format of a function, module, or basic block for the duration ...
bool empty() const
Definition: SmallVector.h:94
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:439
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:163
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:5106
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:711
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
@ Offset
Definition: DWP.cpp:480
@ 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:977
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
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:1749
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:1886
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.