LLVM  3.7.0
LegacyPassManager.cpp
Go to the documentation of this file.
1 //===- LegacyPassManager.cpp - LLVM Pass Infrastructure Implementation ----===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file implements the legacy LLVM Pass Manager infrastructure.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 
15 #include "llvm/IR/LLVMContext.h"
20 #include "llvm/IR/Module.h"
22 #include "llvm/Support/Debug.h"
25 #include "llvm/Support/Mutex.h"
26 #include "llvm/Support/TimeValue.h"
27 #include "llvm/Support/Timer.h"
29 #include <algorithm>
30 #include <map>
31 using namespace llvm;
32 using namespace llvm::legacy;
33 
34 // See PassManagers.h for Pass Manager infrastructure overview.
35 
36 //===----------------------------------------------------------------------===//
37 // Pass debugging information. Often it is useful to find out what pass is
38 // running when a crash occurs in a utility. When this library is compiled with
39 // debugging on, a command line option (--debug-pass) is enabled that causes the
40 // pass name to be printed before it executes.
41 //
42 
43 namespace {
44 // Different debug levels that can be enabled...
46  Disabled, Arguments, Structure, Executions, Details
47 };
48 }
49 
51 PassDebugging("debug-pass", cl::Hidden,
52  cl::desc("Print PassManager debugging information"),
53  cl::values(
54  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  clEnumValEnd));
60 
61 namespace {
63 PassOptionList;
64 }
65 
66 // Print IR out before/after specified passes.
67 static PassOptionList
68 PrintBefore("print-before",
69  llvm::cl::desc("Print IR before specified passes"),
70  cl::Hidden);
71 
72 static PassOptionList
73 PrintAfter("print-after",
74  llvm::cl::desc("Print IR after specified passes"),
75  cl::Hidden);
76 
77 static cl::opt<bool>
78 PrintBeforeAll("print-before-all",
79  llvm::cl::desc("Print IR before each pass"),
80  cl::init(false));
81 static cl::opt<bool>
82 PrintAfterAll("print-after-all",
83  llvm::cl::desc("Print IR after each pass"),
84  cl::init(false));
85 
86 /// This is a helper to determine whether to print IR before or
87 /// after a pass.
88 
89 static bool ShouldPrintBeforeOrAfterPass(const PassInfo *PI,
90  PassOptionList &PassesToPrint) {
91  for (auto *PassInf : PassesToPrint) {
92  if (PassInf)
93  if (PassInf->getPassArgument() == PI->getPassArgument()) {
94  return true;
95  }
96  }
97  return false;
98 }
99 
100 /// This is a utility to check whether a pass should have IR dumped
101 /// before it.
102 static bool ShouldPrintBeforePass(const PassInfo *PI) {
104 }
105 
106 /// This is a utility to check whether a pass should have IR dumped
107 /// after it.
108 static bool ShouldPrintAfterPass(const PassInfo *PI) {
110 }
111 
112 /// isPassDebuggingExecutionsOrMore - Return true if -debug-pass=Executions
113 /// or higher is specified.
115  return PassDebugging >= Executions;
116 }
117 
118 
119 
120 
122  if (!V && !M)
123  OS << "Releasing pass '";
124  else
125  OS << "Running pass '";
126 
127  OS << P->getPassName() << "'";
128 
129  if (M) {
130  OS << " on module '" << M->getModuleIdentifier() << "'.\n";
131  return;
132  }
133  if (!V) {
134  OS << '\n';
135  return;
136  }
137 
138  OS << " on ";
139  if (isa<Function>(V))
140  OS << "function";
141  else if (isa<BasicBlock>(V))
142  OS << "basic block";
143  else
144  OS << "value";
145 
146  OS << " '";
147  V->printAsOperand(OS, /*PrintTy=*/false, M);
148  OS << "'\n";
149 }
150 
151 
152 namespace {
153 //===----------------------------------------------------------------------===//
154 // BBPassManager
155 //
156 /// BBPassManager manages BasicBlockPass. It batches all the
157 /// pass together and sequence them to process one basic block before
158 /// processing next basic block.
159 class BBPassManager : public PMDataManager, public FunctionPass {
160 
161 public:
162  static char ID;
163  explicit BBPassManager()
164  : PMDataManager(), FunctionPass(ID) {}
165 
166  /// Execute all of the passes scheduled for execution. Keep track of
167  /// whether any of the passes modifies the function, and if so, return true.
168  bool runOnFunction(Function &F) override;
169 
170  /// Pass Manager itself does not invalidate any analysis info.
171  void getAnalysisUsage(AnalysisUsage &Info) const override {
172  Info.setPreservesAll();
173  }
174 
175  bool doInitialization(Module &M) override;
176  bool doInitialization(Function &F);
177  bool doFinalization(Module &M) override;
178  bool doFinalization(Function &F);
179 
180  PMDataManager *getAsPMDataManager() override { return this; }
181  Pass *getAsPass() override { return this; }
182 
183  const char *getPassName() const override {
184  return "BasicBlock Pass Manager";
185  }
186 
187  // Print passes managed by this manager
188  void dumpPassStructure(unsigned Offset) override {
189  dbgs().indent(Offset*2) << "BasicBlockPass Manager\n";
190  for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) {
191  BasicBlockPass *BP = getContainedPass(Index);
192  BP->dumpPassStructure(Offset + 1);
193  dumpLastUses(BP, Offset+1);
194  }
195  }
196 
197  BasicBlockPass *getContainedPass(unsigned N) {
198  assert(N < PassVector.size() && "Pass number out of range!");
199  BasicBlockPass *BP = static_cast<BasicBlockPass *>(PassVector[N]);
200  return BP;
201  }
202 
203  PassManagerType getPassManagerType() const override {
205  }
206 };
207 
208 char BBPassManager::ID = 0;
209 } // End anonymous namespace
210 
211 namespace llvm {
212 namespace legacy {
213 //===----------------------------------------------------------------------===//
214 // FunctionPassManagerImpl
215 //
216 /// FunctionPassManagerImpl manages FPPassManagers
218  public PMDataManager,
219  public PMTopLevelManager {
220  virtual void anchor();
221 private:
222  bool wasRun;
223 public:
224  static char ID;
227  PMTopLevelManager(new FPPassManager()), wasRun(false) {}
228 
229  /// \copydoc FunctionPassManager::add()
230  void add(Pass *P) {
231  schedulePass(P);
232  }
233 
234  /// createPrinterPass - Get a function printer pass.
236  const std::string &Banner) const override {
237  return createPrintFunctionPass(O, Banner);
238  }
239 
240  // Prepare for running an on the fly pass, freeing memory if needed
241  // from a previous run.
242  void releaseMemoryOnTheFly();
243 
244  /// run - Execute all of the passes scheduled for execution. Keep track of
245  /// whether any of the passes modifies the module, and if so, return true.
246  bool run(Function &F);
247 
248  /// doInitialization - Run all of the initializers for the function passes.
249  ///
250  bool doInitialization(Module &M) override;
251 
252  /// doFinalization - Run all of the finalizers for the function passes.
253  ///
254  bool doFinalization(Module &M) override;
255 
256 
257  PMDataManager *getAsPMDataManager() override { return this; }
258  Pass *getAsPass() override { return this; }
261  }
262 
263  /// Pass Manager itself does not invalidate any analysis info.
264  void getAnalysisUsage(AnalysisUsage &Info) const override {
265  Info.setPreservesAll();
266  }
267 
269  assert(N < PassManagers.size() && "Pass number out of range!");
270  FPPassManager *FP = static_cast<FPPassManager *>(PassManagers[N]);
271  return FP;
272  }
273 };
274 
275 void FunctionPassManagerImpl::anchor() {}
276 
278 } // End of legacy namespace
279 } // End of llvm namespace
280 
281 namespace {
282 //===----------------------------------------------------------------------===//
283 // MPPassManager
284 //
285 /// MPPassManager manages ModulePasses and function pass managers.
286 /// It batches all Module passes and function pass managers together and
287 /// sequences them to process one module.
288 class MPPassManager : public Pass, public PMDataManager {
289 public:
290  static char ID;
291  explicit MPPassManager() :
293 
294  // Delete on the fly managers.
295  ~MPPassManager() override {
296  for (auto &OnTheFlyManager : OnTheFlyManagers) {
297  FunctionPassManagerImpl *FPP = OnTheFlyManager.second;
298  delete FPP;
299  }
300  }
301 
302  /// createPrinterPass - Get a module printer pass.
303  Pass *createPrinterPass(raw_ostream &O,
304  const std::string &Banner) const override {
305  return createPrintModulePass(O, Banner);
306  }
307 
308  /// run - Execute all of the passes scheduled for execution. Keep track of
309  /// whether any of the passes modifies the module, and if so, return true.
310  bool runOnModule(Module &M);
311 
314 
315  /// doInitialization - Run all of the initializers for the module passes.
316  ///
317  bool doInitialization();
318 
319  /// doFinalization - Run all of the finalizers for the module passes.
320  ///
321  bool doFinalization();
322 
323  /// Pass Manager itself does not invalidate any analysis info.
324  void getAnalysisUsage(AnalysisUsage &Info) const override {
325  Info.setPreservesAll();
326  }
327 
328  /// Add RequiredPass into list of lower level passes required by pass P.
329  /// RequiredPass is run on the fly by Pass Manager when P requests it
330  /// through getAnalysis interface.
331  void addLowerLevelRequiredPass(Pass *P, Pass *RequiredPass) override;
332 
333  /// Return function pass corresponding to PassInfo PI, that is
334  /// required by module pass MP. Instantiate analysis pass, by using
335  /// its runOnFunction() for function F.
336  Pass* getOnTheFlyPass(Pass *MP, AnalysisID PI, Function &F) override;
337 
338  const char *getPassName() const override {
339  return "Module Pass Manager";
340  }
341 
342  PMDataManager *getAsPMDataManager() override { return this; }
343  Pass *getAsPass() override { return this; }
344 
345  // Print passes managed by this manager
346  void dumpPassStructure(unsigned Offset) override {
347  dbgs().indent(Offset*2) << "ModulePass Manager\n";
348  for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) {
349  ModulePass *MP = getContainedPass(Index);
350  MP->dumpPassStructure(Offset + 1);
351  std::map<Pass *, FunctionPassManagerImpl *>::const_iterator I =
352  OnTheFlyManagers.find(MP);
353  if (I != OnTheFlyManagers.end())
354  I->second->dumpPassStructure(Offset + 2);
355  dumpLastUses(MP, Offset+1);
356  }
357  }
358 
359  ModulePass *getContainedPass(unsigned N) {
360  assert(N < PassVector.size() && "Pass number out of range!");
361  return static_cast<ModulePass *>(PassVector[N]);
362  }
363 
364  PassManagerType getPassManagerType() const override {
365  return PMT_ModulePassManager;
366  }
367 
368  private:
369  /// Collection of on the fly FPPassManagers. These managers manage
370  /// function passes that are required by module passes.
371  std::map<Pass *, FunctionPassManagerImpl *> OnTheFlyManagers;
372 };
373 
374 char MPPassManager::ID = 0;
375 } // End anonymous namespace
376 
377 namespace llvm {
378 namespace legacy {
379 //===----------------------------------------------------------------------===//
380 // PassManagerImpl
381 //
382 
383 /// PassManagerImpl manages MPPassManagers
384 class PassManagerImpl : public Pass,
385  public PMDataManager,
386  public PMTopLevelManager {
387  virtual void anchor();
388 
389 public:
390  static char ID;
391  explicit PassManagerImpl() :
393  PMTopLevelManager(new MPPassManager()) {}
394 
395  /// \copydoc PassManager::add()
396  void add(Pass *P) {
397  schedulePass(P);
398  }
399 
400  /// createPrinterPass - Get a module printer pass.
402  const std::string &Banner) const override {
403  return createPrintModulePass(O, Banner);
404  }
405 
406  /// run - Execute all of the passes scheduled for execution. Keep track of
407  /// whether any of the passes modifies the module, and if so, return true.
408  bool run(Module &M);
409 
412 
413  /// doInitialization - Run all of the initializers for the module passes.
414  ///
415  bool doInitialization();
416 
417  /// doFinalization - Run all of the finalizers for the module passes.
418  ///
419  bool doFinalization();
420 
421  /// Pass Manager itself does not invalidate any analysis info.
422  void getAnalysisUsage(AnalysisUsage &Info) const override {
423  Info.setPreservesAll();
424  }
425 
426  PMDataManager *getAsPMDataManager() override { return this; }
427  Pass *getAsPass() override { return this; }
429  return PMT_ModulePassManager;
430  }
431 
432  MPPassManager *getContainedManager(unsigned N) {
433  assert(N < PassManagers.size() && "Pass number out of range!");
434  MPPassManager *MP = static_cast<MPPassManager *>(PassManagers[N]);
435  return MP;
436  }
437 };
438 
439 void PassManagerImpl::anchor() {}
440 
441 char PassManagerImpl::ID = 0;
442 } // End of legacy namespace
443 } // End of llvm namespace
444 
445 namespace {
446 
447 //===----------------------------------------------------------------------===//
448 /// TimingInfo Class - This class is used to calculate information about the
449 /// amount of time each pass takes to execute. This only happens when
450 /// -time-passes is enabled on the command line.
451 ///
452 
453 static ManagedStatic<sys::SmartMutex<true> > TimingInfoMutex;
454 
455 class TimingInfo {
456  DenseMap<Pass*, Timer*> TimingData;
457  TimerGroup TG;
458 public:
459  // Use 'create' member to get this.
460  TimingInfo() : TG("... Pass execution timing report ...") {}
461 
462  // TimingDtor - Print out information about timing information
463  ~TimingInfo() {
464  // Delete all of the timers, which accumulate their info into the
465  // TimerGroup.
466  for (auto &I : TimingData)
467  delete I.second;
468  // TimerGroup is deleted next, printing the report.
469  }
470 
471  // createTheTimeInfo - This method either initializes the TheTimeInfo pointer
472  // to a non-null value (if the -time-passes option is enabled) or it leaves it
473  // null. It may be called multiple times.
474  static void createTheTimeInfo();
475 
476  /// getPassTimer - Return the timer for the specified pass if it exists.
477  Timer *getPassTimer(Pass *P) {
478  if (P->getAsPMDataManager())
479  return nullptr;
480 
481  sys::SmartScopedLock<true> Lock(*TimingInfoMutex);
482  Timer *&T = TimingData[P];
483  if (!T)
484  T = new Timer(P->getPassName(), TG);
485  return T;
486  }
487 };
488 
489 } // End of anon namespace
490 
491 static TimingInfo *TheTimeInfo;
492 
493 //===----------------------------------------------------------------------===//
494 // PMTopLevelManager implementation
495 
496 /// Initialize top level manager. Create first pass manager.
498  PMDM->setTopLevelManager(this);
499  addPassManager(PMDM);
500  activeStack.push(PMDM);
501 }
502 
503 /// Set pass P as the last user of the given analysis passes.
504 void
506  unsigned PDepth = 0;
507  if (P->getResolver())
508  PDepth = P->getResolver()->getPMDataManager().getDepth();
509 
510  for (Pass *AP : AnalysisPasses) {
511  LastUser[AP] = P;
512 
513  if (P == AP)
514  continue;
515 
516  // Update the last users of passes that are required transitive by AP.
517  AnalysisUsage *AnUsage = findAnalysisUsage(AP);
518  const AnalysisUsage::VectorType &IDs = AnUsage->getRequiredTransitiveSet();
519  SmallVector<Pass *, 12> LastUses;
520  SmallVector<Pass *, 12> LastPMUses;
522  E = IDs.end(); I != E; ++I) {
523  Pass *AnalysisPass = findAnalysisPass(*I);
524  assert(AnalysisPass && "Expected analysis pass to exist.");
525  AnalysisResolver *AR = AnalysisPass->getResolver();
526  assert(AR && "Expected analysis resolver to exist.");
527  unsigned APDepth = AR->getPMDataManager().getDepth();
528 
529  if (PDepth == APDepth)
530  LastUses.push_back(AnalysisPass);
531  else if (PDepth > APDepth)
532  LastPMUses.push_back(AnalysisPass);
533  }
534 
535  setLastUser(LastUses, P);
536 
537  // If this pass has a corresponding pass manager, push higher level
538  // analysis to this pass manager.
539  if (P->getResolver())
540  setLastUser(LastPMUses, P->getResolver()->getPMDataManager().getAsPass());
541 
542 
543  // If AP is the last user of other passes then make P last user of
544  // such passes.
545  for (DenseMap<Pass *, Pass *>::iterator LUI = LastUser.begin(),
546  LUE = LastUser.end(); LUI != LUE; ++LUI) {
547  if (LUI->second == AP)
548  // DenseMap iterator is not invalidated here because
549  // this is just updating existing entries.
550  LastUser[LUI->first] = P;
551  }
552  }
553 }
554 
555 /// Collect passes whose last user is P
557  Pass *P) {
559  InversedLastUser.find(P);
560  if (DMI == InversedLastUser.end())
561  return;
562 
563  SmallPtrSet<Pass *, 8> &LU = DMI->second;
564  for (Pass *LUP : LU) {
565  LastUses.push_back(LUP);
566  }
567 
568 }
569 
571  AnalysisUsage *AnUsage = nullptr;
572  DenseMap<Pass *, AnalysisUsage *>::iterator DMI = AnUsageMap.find(P);
573  if (DMI != AnUsageMap.end())
574  AnUsage = DMI->second;
575  else {
576  AnUsage = new AnalysisUsage();
577  P->getAnalysisUsage(*AnUsage);
578  AnUsageMap[P] = AnUsage;
579  }
580  return AnUsage;
581 }
582 
583 /// Schedule pass P for execution. Make sure that passes required by
584 /// P are run before P is run. Update analysis info maintained by
585 /// the manager. Remove dead passes. This is a recursive function.
587 
588  // TODO : Allocate function manager for this pass, other wise required set
589  // may be inserted into previous function manager
590 
591  // Give pass a chance to prepare the stage.
593 
594  // If P is an analysis pass and it is available then do not
595  // generate the analysis again. Stale analysis info should not be
596  // available at this point.
597  const PassInfo *PI = findAnalysisPassInfo(P->getPassID());
598  if (PI && PI->isAnalysis() && findAnalysisPass(P->getPassID())) {
599  delete P;
600  return;
601  }
602 
603  AnalysisUsage *AnUsage = findAnalysisUsage(P);
604 
605  bool checkAnalysis = true;
606  while (checkAnalysis) {
607  checkAnalysis = false;
608 
609  const AnalysisUsage::VectorType &RequiredSet = AnUsage->getRequiredSet();
611  E = RequiredSet.end(); I != E; ++I) {
612 
613  Pass *AnalysisPass = findAnalysisPass(*I);
614  if (!AnalysisPass) {
615  const PassInfo *PI = findAnalysisPassInfo(*I);
616 
617  if (!PI) {
618  // Pass P is not in the global PassRegistry
619  dbgs() << "Pass '" << P->getPassName() << "' is not initialized." << "\n";
620  dbgs() << "Verify if there is a pass dependency cycle." << "\n";
621  dbgs() << "Required Passes:" << "\n";
622  for (AnalysisUsage::VectorType::const_iterator I2 = RequiredSet.begin(),
623  E = RequiredSet.end(); I2 != E && I2 != I; ++I2) {
624  Pass *AnalysisPass2 = findAnalysisPass(*I2);
625  if (AnalysisPass2) {
626  dbgs() << "\t" << AnalysisPass2->getPassName() << "\n";
627  } else {
628  dbgs() << "\t" << "Error: Required pass not found! Possible causes:" << "\n";
629  dbgs() << "\t\t" << "- Pass misconfiguration (e.g.: missing macros)" << "\n";
630  dbgs() << "\t\t" << "- Corruption of the global PassRegistry" << "\n";
631  }
632  }
633  }
634 
635  assert(PI && "Expected required passes to be initialized");
636  AnalysisPass = PI->createPass();
637  if (P->getPotentialPassManagerType () ==
638  AnalysisPass->getPotentialPassManagerType())
639  // Schedule analysis pass that is managed by the same pass manager.
640  schedulePass(AnalysisPass);
641  else if (P->getPotentialPassManagerType () >
642  AnalysisPass->getPotentialPassManagerType()) {
643  // Schedule analysis pass that is managed by a new manager.
644  schedulePass(AnalysisPass);
645  // Recheck analysis passes to ensure that required analyses that
646  // are already checked are still available.
647  checkAnalysis = true;
648  } else
649  // Do not schedule this analysis. Lower level analysis
650  // passes are run on the fly.
651  delete AnalysisPass;
652  }
653  }
654  }
655 
656  // Now all required passes are available.
657  if (ImmutablePass *IP = P->getAsImmutablePass()) {
658  // P is a immutable pass and it will be managed by this
659  // top level manager. Set up analysis resolver to connect them.
660  PMDataManager *DM = getAsPMDataManager();
661  AnalysisResolver *AR = new AnalysisResolver(*DM);
662  P->setResolver(AR);
663  DM->initializeAnalysisImpl(P);
666  return;
667  }
668 
669  if (PI && !PI->isAnalysis() && ShouldPrintBeforePass(PI)) {
670  Pass *PP = P->createPrinterPass(
671  dbgs(), std::string("*** IR Dump Before ") + P->getPassName() + " ***");
672  PP->assignPassManager(activeStack, getTopLevelPassManagerType());
673  }
674 
675  // Add the requested pass to the best available pass manager.
676  P->assignPassManager(activeStack, getTopLevelPassManagerType());
677 
678  if (PI && !PI->isAnalysis() && ShouldPrintAfterPass(PI)) {
679  Pass *PP = P->createPrinterPass(
680  dbgs(), std::string("*** IR Dump After ") + P->getPassName() + " ***");
681  PP->assignPassManager(activeStack, getTopLevelPassManagerType());
682  }
683 }
684 
685 /// Find the pass that implements Analysis AID. Search immutable
686 /// passes and all pass managers. If desired pass is not found
687 /// then return NULL.
689 
690  // Check pass managers
692  if (Pass *P = PassManager->findAnalysisPass(AID, false))
693  return P;
694 
695  // Check other pass managers
696  for (PMDataManager *IndirectPassManager : IndirectPassManagers)
697  if (Pass *P = IndirectPassManager->findAnalysisPass(AID, false))
698  return P;
699 
700  // Check the immutable passes. Iterate in reverse order so that we find
701  // the most recently registered passes first.
702  for (auto I = ImmutablePasses.rbegin(), E = ImmutablePasses.rend(); I != E;
703  ++I) {
704  AnalysisID PI = (*I)->getPassID();
705  if (PI == AID)
706  return *I;
707 
708  // If Pass not found then check the interfaces implemented by Immutable Pass
709  const PassInfo *PassInf = findAnalysisPassInfo(PI);
710  assert(PassInf && "Expected all immutable passes to be initialized");
711  const std::vector<const PassInfo*> &ImmPI =
712  PassInf->getInterfacesImplemented();
713  for (const PassInfo *PI : ImmPI)
714  if (PI->getTypeInfo() == AID)
715  return *I;
716  }
717 
718  return nullptr;
719 }
720 
722  const PassInfo *&PI = AnalysisPassInfos[AID];
723  if (!PI)
725  else
726  assert(PI == PassRegistry::getPassRegistry()->getPassInfo(AID) &&
727  "The pass info pointer changed for an analysis ID!");
728 
729  return PI;
730 }
731 
732 // Print passes managed by this top level manager.
734 
735  if (PassDebugging < Structure)
736  return;
737 
738  // Print out the immutable passes
739  for (unsigned i = 0, e = ImmutablePasses.size(); i != e; ++i) {
740  ImmutablePasses[i]->dumpPassStructure(0);
741  }
742 
743  // Every class that derives from PMDataManager also derives from Pass
744  // (sometimes indirectly), but there's no inheritance relationship
745  // between PMDataManager and Pass, so we have to getAsPass to get
746  // from a PMDataManager* to a Pass*.
747  for (PMDataManager *Manager : PassManagers)
748  Manager->getAsPass()->dumpPassStructure(1);
749 }
750 
752 
753  if (PassDebugging < Arguments)
754  return;
755 
756  dbgs() << "Pass Arguments: ";
758  ImmutablePasses.begin(), E = ImmutablePasses.end(); I != E; ++I)
759  if (const PassInfo *PI = findAnalysisPassInfo((*I)->getPassID())) {
760  assert(PI && "Expected all immutable passes to be initialized");
761  if (!PI->isAnalysisGroup())
762  dbgs() << " -" << PI->getPassArgument();
763  }
765  PassManagers.begin(), E = PassManagers.end(); I != E; ++I)
766  (*I)->dumpPassArguments();
767  dbgs() << "\n";
768 }
769 
772  E = PassManagers.end(); I != E; ++I)
773  (*I)->initializeAnalysisInfo();
774 
775  // Initailize other pass managers
777  I = IndirectPassManagers.begin(), E = IndirectPassManagers.end();
778  I != E; ++I)
779  (*I)->initializeAnalysisInfo();
780 
781  for (DenseMap<Pass *, Pass *>::iterator DMI = LastUser.begin(),
782  DME = LastUser.end(); DMI != DME; ++DMI) {
783  DenseMap<Pass *, SmallPtrSet<Pass *, 8> >::iterator InvDMI =
784  InversedLastUser.find(DMI->second);
785  if (InvDMI != InversedLastUser.end()) {
786  SmallPtrSet<Pass *, 8> &L = InvDMI->second;
787  L.insert(DMI->first);
788  } else {
789  SmallPtrSet<Pass *, 8> L; L.insert(DMI->first);
790  InversedLastUser[DMI->second] = L;
791  }
792  }
793 }
794 
795 /// Destructor
798  E = PassManagers.end(); I != E; ++I)
799  delete *I;
800 
802  I = ImmutablePasses.begin(), E = ImmutablePasses.end(); I != E; ++I)
803  delete *I;
804 
805  for (DenseMap<Pass *, AnalysisUsage *>::iterator DMI = AnUsageMap.begin(),
806  DME = AnUsageMap.end(); DMI != DME; ++DMI)
807  delete DMI->second;
808 }
809 
810 //===----------------------------------------------------------------------===//
811 // PMDataManager implementation
812 
813 /// Augement AvailableAnalysis by adding analysis made available by pass P.
815  AnalysisID PI = P->getPassID();
816 
817  AvailableAnalysis[PI] = P;
818 
819  assert(!AvailableAnalysis.empty());
820 
821  // This pass is the current implementation of all of the interfaces it
822  // implements as well.
823  const PassInfo *PInf = TPM->findAnalysisPassInfo(PI);
824  if (!PInf) return;
825  const std::vector<const PassInfo*> &II = PInf->getInterfacesImplemented();
826  for (unsigned i = 0, e = II.size(); i != e; ++i)
827  AvailableAnalysis[II[i]->getTypeInfo()] = P;
828 }
829 
830 // Return true if P preserves high level analysis used by other
831 // passes managed by this manager
833  AnalysisUsage *AnUsage = TPM->findAnalysisUsage(P);
834  if (AnUsage->getPreservesAll())
835  return true;
836 
837  const AnalysisUsage::VectorType &PreservedSet = AnUsage->getPreservedSet();
838  for (SmallVectorImpl<Pass *>::iterator I = HigherLevelAnalysis.begin(),
839  E = HigherLevelAnalysis.end(); I != E; ++I) {
840  Pass *P1 = *I;
841  if (P1->getAsImmutablePass() == nullptr &&
842  std::find(PreservedSet.begin(), PreservedSet.end(),
843  P1->getPassID()) ==
844  PreservedSet.end())
845  return false;
846  }
847 
848  return true;
849 }
850 
851 /// verifyPreservedAnalysis -- Verify analysis preserved by pass P.
853  // Don't do this unless assertions are enabled.
854 #ifdef NDEBUG
855  return;
856 #endif
857  AnalysisUsage *AnUsage = TPM->findAnalysisUsage(P);
858  const AnalysisUsage::VectorType &PreservedSet = AnUsage->getPreservedSet();
859 
860  // Verify preserved analysis
861  for (AnalysisUsage::VectorType::const_iterator I = PreservedSet.begin(),
862  E = PreservedSet.end(); I != E; ++I) {
863  AnalysisID AID = *I;
864  if (Pass *AP = findAnalysisPass(AID, true)) {
865  TimeRegion PassTimer(getPassTimer(AP));
866  AP->verifyAnalysis();
867  }
868  }
869 }
870 
871 /// Remove Analysis not preserved by Pass P
873  AnalysisUsage *AnUsage = TPM->findAnalysisUsage(P);
874  if (AnUsage->getPreservesAll())
875  return;
876 
877  const AnalysisUsage::VectorType &PreservedSet = AnUsage->getPreservedSet();
878  for (DenseMap<AnalysisID, Pass*>::iterator I = AvailableAnalysis.begin(),
879  E = AvailableAnalysis.end(); I != E; ) {
881  if (Info->second->getAsImmutablePass() == nullptr &&
882  std::find(PreservedSet.begin(), PreservedSet.end(), Info->first) ==
883  PreservedSet.end()) {
884  // Remove this analysis
885  if (PassDebugging >= Details) {
886  Pass *S = Info->second;
887  dbgs() << " -- '" << P->getPassName() << "' is not preserving '";
888  dbgs() << S->getPassName() << "'\n";
889  }
890  AvailableAnalysis.erase(Info);
891  }
892  }
893 
894  // Check inherited analysis also. If P is not preserving analysis
895  // provided by parent manager then remove it here.
896  for (unsigned Index = 0; Index < PMT_Last; ++Index) {
897 
898  if (!InheritedAnalysis[Index])
899  continue;
900 
902  I = InheritedAnalysis[Index]->begin(),
903  E = InheritedAnalysis[Index]->end(); I != E; ) {
905  if (Info->second->getAsImmutablePass() == nullptr &&
906  std::find(PreservedSet.begin(), PreservedSet.end(), Info->first) ==
907  PreservedSet.end()) {
908  // Remove this analysis
909  if (PassDebugging >= Details) {
910  Pass *S = Info->second;
911  dbgs() << " -- '" << P->getPassName() << "' is not preserving '";
912  dbgs() << S->getPassName() << "'\n";
913  }
914  InheritedAnalysis[Index]->erase(Info);
915  }
916  }
917  }
918 }
919 
920 /// Remove analysis passes that are not used any longer
922  enum PassDebuggingString DBG_STR) {
923 
924  SmallVector<Pass *, 12> DeadPasses;
925 
926  // If this is a on the fly manager then it does not have TPM.
927  if (!TPM)
928  return;
929 
930  TPM->collectLastUses(DeadPasses, P);
931 
932  if (PassDebugging >= Details && !DeadPasses.empty()) {
933  dbgs() << " -*- '" << P->getPassName();
934  dbgs() << "' is the last user of following pass instances.";
935  dbgs() << " Free these instances\n";
936  }
937 
938  for (SmallVectorImpl<Pass *>::iterator I = DeadPasses.begin(),
939  E = DeadPasses.end(); I != E; ++I)
940  freePass(*I, Msg, DBG_STR);
941 }
942 
944  enum PassDebuggingString DBG_STR) {
945  dumpPassInfo(P, FREEING_MSG, DBG_STR, Msg);
946 
947  {
948  // If the pass crashes releasing memory, remember this.
950  TimeRegion PassTimer(getPassTimer(P));
951 
952  P->releaseMemory();
953  }
954 
955  AnalysisID PI = P->getPassID();
956  if (const PassInfo *PInf = TPM->findAnalysisPassInfo(PI)) {
957  // Remove the pass itself (if it is not already removed).
958  AvailableAnalysis.erase(PI);
959 
960  // Remove all interfaces this pass implements, for which it is also
961  // listed as the available implementation.
962  const std::vector<const PassInfo*> &II = PInf->getInterfacesImplemented();
963  for (unsigned i = 0, e = II.size(); i != e; ++i) {
965  AvailableAnalysis.find(II[i]->getTypeInfo());
966  if (Pos != AvailableAnalysis.end() && Pos->second == P)
967  AvailableAnalysis.erase(Pos);
968  }
969  }
970 }
971 
972 /// Add pass P into the PassVector. Update
973 /// AvailableAnalysis appropriately if ProcessAnalysis is true.
974 void PMDataManager::add(Pass *P, bool ProcessAnalysis) {
975  // This manager is going to manage pass P. Set up analysis resolver
976  // to connect them.
977  AnalysisResolver *AR = new AnalysisResolver(*this);
978  P->setResolver(AR);
979 
980  // If a FunctionPass F is the last user of ModulePass info M
981  // then the F's manager, not F, records itself as a last user of M.
982  SmallVector<Pass *, 12> TransferLastUses;
983 
984  if (!ProcessAnalysis) {
985  // Add pass
986  PassVector.push_back(P);
987  return;
988  }
989 
990  // At the moment, this pass is the last user of all required passes.
991  SmallVector<Pass *, 12> LastUses;
992  SmallVector<Pass *, 8> RequiredPasses;
993  SmallVector<AnalysisID, 8> ReqAnalysisNotAvailable;
994 
995  unsigned PDepth = this->getDepth();
996 
997  collectRequiredAnalysis(RequiredPasses,
998  ReqAnalysisNotAvailable, P);
999  for (SmallVectorImpl<Pass *>::iterator I = RequiredPasses.begin(),
1000  E = RequiredPasses.end(); I != E; ++I) {
1001  Pass *PRequired = *I;
1002  unsigned RDepth = 0;
1003 
1004  assert(PRequired->getResolver() && "Analysis Resolver is not set");
1005  PMDataManager &DM = PRequired->getResolver()->getPMDataManager();
1006  RDepth = DM.getDepth();
1007 
1008  if (PDepth == RDepth)
1009  LastUses.push_back(PRequired);
1010  else if (PDepth > RDepth) {
1011  // Let the parent claim responsibility of last use
1012  TransferLastUses.push_back(PRequired);
1013  // Keep track of higher level analysis used by this manager.
1014  HigherLevelAnalysis.push_back(PRequired);
1015  } else
1016  llvm_unreachable("Unable to accommodate Required Pass");
1017  }
1018 
1019  // Set P as P's last user until someone starts using P.
1020  // However, if P is a Pass Manager then it does not need
1021  // to record its last user.
1022  if (!P->getAsPMDataManager())
1023  LastUses.push_back(P);
1024  TPM->setLastUser(LastUses, P);
1025 
1026  if (!TransferLastUses.empty()) {
1027  Pass *My_PM = getAsPass();
1028  TPM->setLastUser(TransferLastUses, My_PM);
1029  TransferLastUses.clear();
1030  }
1031 
1032  // Now, take care of required analyses that are not available.
1034  I = ReqAnalysisNotAvailable.begin(),
1035  E = ReqAnalysisNotAvailable.end() ;I != E; ++I) {
1036  const PassInfo *PI = TPM->findAnalysisPassInfo(*I);
1037  Pass *AnalysisPass = PI->createPass();
1038  this->addLowerLevelRequiredPass(P, AnalysisPass);
1039  }
1040 
1041  // Take a note of analysis required and made available by this pass.
1042  // Remove the analysis not preserved by this pass
1045 
1046  // Add pass
1047  PassVector.push_back(P);
1048 }
1049 
1050 
1051 /// Populate RP with analysis pass that are required by
1052 /// pass P and are available. Populate RP_NotAvail with analysis
1053 /// pass that are required by pass P but are not available.
1055  SmallVectorImpl<AnalysisID> &RP_NotAvail,
1056  Pass *P) {
1057  AnalysisUsage *AnUsage = TPM->findAnalysisUsage(P);
1058  const AnalysisUsage::VectorType &RequiredSet = AnUsage->getRequiredSet();
1060  I = RequiredSet.begin(), E = RequiredSet.end(); I != E; ++I) {
1061  if (Pass *AnalysisPass = findAnalysisPass(*I, true))
1062  RP.push_back(AnalysisPass);
1063  else
1064  RP_NotAvail.push_back(*I);
1065  }
1066 
1067  const AnalysisUsage::VectorType &IDs = AnUsage->getRequiredTransitiveSet();
1069  E = IDs.end(); I != E; ++I) {
1070  if (Pass *AnalysisPass = findAnalysisPass(*I, true))
1071  RP.push_back(AnalysisPass);
1072  else
1073  RP_NotAvail.push_back(*I);
1074  }
1075 }
1076 
1077 // All Required analyses should be available to the pass as it runs! Here
1078 // we fill in the AnalysisImpls member of the pass so that it can
1079 // successfully use the getAnalysis() method to retrieve the
1080 // implementations it needs.
1081 //
1083  AnalysisUsage *AnUsage = TPM->findAnalysisUsage(P);
1084 
1086  I = AnUsage->getRequiredSet().begin(),
1087  E = AnUsage->getRequiredSet().end(); I != E; ++I) {
1088  Pass *Impl = findAnalysisPass(*I, true);
1089  if (!Impl)
1090  // This may be analysis pass that is initialized on the fly.
1091  // If that is not the case then it will raise an assert when it is used.
1092  continue;
1093  AnalysisResolver *AR = P->getResolver();
1094  assert(AR && "Analysis Resolver is not set");
1095  AR->addAnalysisImplsPair(*I, Impl);
1096  }
1097 }
1098 
1099 /// Find the pass that implements Analysis AID. If desired pass is not found
1100 /// then return NULL.
1102 
1103  // Check if AvailableAnalysis map has one entry.
1104  DenseMap<AnalysisID, Pass*>::const_iterator I = AvailableAnalysis.find(AID);
1105 
1106  if (I != AvailableAnalysis.end())
1107  return I->second;
1108 
1109  // Search Parents through TopLevelManager
1110  if (SearchParent)
1111  return TPM->findAnalysisPass(AID);
1112 
1113  return nullptr;
1114 }
1115 
1116 // Print list of passes that are last used by P.
1117 void PMDataManager::dumpLastUses(Pass *P, unsigned Offset) const{
1118 
1120 
1121  // If this is a on the fly manager then it does not have TPM.
1122  if (!TPM)
1123  return;
1124 
1125  TPM->collectLastUses(LUses, P);
1126 
1127  for (SmallVectorImpl<Pass *>::iterator I = LUses.begin(),
1128  E = LUses.end(); I != E; ++I) {
1129  dbgs() << "--" << std::string(Offset*2, ' ');
1130  (*I)->dumpPassStructure(0);
1131  }
1132 }
1133 
1136  E = PassVector.end(); I != E; ++I) {
1137  if (PMDataManager *PMD = (*I)->getAsPMDataManager())
1138  PMD->dumpPassArguments();
1139  else
1140  if (const PassInfo *PI =
1141  TPM->findAnalysisPassInfo((*I)->getPassID()))
1142  if (!PI->isAnalysisGroup())
1143  dbgs() << " -" << PI->getPassArgument();
1144  }
1145 }
1146 
1148  enum PassDebuggingString S2,
1149  StringRef Msg) {
1150  if (PassDebugging < Executions)
1151  return;
1152  dbgs() << "[" << sys::TimeValue::now().str() << "] " << (void *)this
1153  << std::string(getDepth() * 2 + 1, ' ');
1154  switch (S1) {
1155  case EXECUTION_MSG:
1156  dbgs() << "Executing Pass '" << P->getPassName();
1157  break;
1158  case MODIFICATION_MSG:
1159  dbgs() << "Made Modification '" << P->getPassName();
1160  break;
1161  case FREEING_MSG:
1162  dbgs() << " Freeing Pass '" << P->getPassName();
1163  break;
1164  default:
1165  break;
1166  }
1167  switch (S2) {
1168  case ON_BASICBLOCK_MSG:
1169  dbgs() << "' on BasicBlock '" << Msg << "'...\n";
1170  break;
1171  case ON_FUNCTION_MSG:
1172  dbgs() << "' on Function '" << Msg << "'...\n";
1173  break;
1174  case ON_MODULE_MSG:
1175  dbgs() << "' on Module '" << Msg << "'...\n";
1176  break;
1177  case ON_REGION_MSG:
1178  dbgs() << "' on Region '" << Msg << "'...\n";
1179  break;
1180  case ON_LOOP_MSG:
1181  dbgs() << "' on Loop '" << Msg << "'...\n";
1182  break;
1183  case ON_CG_MSG:
1184  dbgs() << "' on Call Graph Nodes '" << Msg << "'...\n";
1185  break;
1186  default:
1187  break;
1188  }
1189 }
1190 
1192  if (PassDebugging < Details)
1193  return;
1194 
1195  AnalysisUsage analysisUsage;
1196  P->getAnalysisUsage(analysisUsage);
1197  dumpAnalysisUsage("Required", P, analysisUsage.getRequiredSet());
1198 }
1199 
1201  if (PassDebugging < Details)
1202  return;
1203 
1204  AnalysisUsage analysisUsage;
1205  P->getAnalysisUsage(analysisUsage);
1206  dumpAnalysisUsage("Preserved", P, analysisUsage.getPreservedSet());
1207 }
1208 
1209 void PMDataManager::dumpAnalysisUsage(StringRef Msg, const Pass *P,
1210  const AnalysisUsage::VectorType &Set) const {
1211  assert(PassDebugging >= Details);
1212  if (Set.empty())
1213  return;
1214  dbgs() << (const void*)P << std::string(getDepth()*2+3, ' ') << Msg << " Analyses:";
1215  for (unsigned i = 0; i != Set.size(); ++i) {
1216  if (i) dbgs() << ',';
1217  const PassInfo *PInf = TPM->findAnalysisPassInfo(Set[i]);
1218  if (!PInf) {
1219  // Some preserved passes, such as AliasAnalysis, may not be initialized by
1220  // all drivers.
1221  dbgs() << " Uninitialized Pass";
1222  continue;
1223  }
1224  dbgs() << ' ' << PInf->getPassName();
1225  }
1226  dbgs() << '\n';
1227 }
1228 
1229 /// Add RequiredPass into list of lower level passes required by pass P.
1230 /// RequiredPass is run on the fly by Pass Manager when P requests it
1231 /// through getAnalysis interface.
1232 /// This should be handled by specific pass manager.
1234  if (TPM) {
1235  TPM->dumpArguments();
1236  TPM->dumpPasses();
1237  }
1238 
1239  // Module Level pass may required Function Level analysis info
1240  // (e.g. dominator info). Pass manager uses on the fly function pass manager
1241  // to provide this on demand. In that case, in Pass manager terminology,
1242  // module level pass is requiring lower level analysis info managed by
1243  // lower level pass manager.
1244 
1245  // When Pass manager is not able to order required analysis info, Pass manager
1246  // checks whether any lower level manager will be able to provide this
1247  // analysis info on demand or not.
1248 #ifndef NDEBUG
1249  dbgs() << "Unable to schedule '" << RequiredPass->getPassName();
1250  dbgs() << "' required by '" << P->getPassName() << "'\n";
1251 #endif
1252  llvm_unreachable("Unable to schedule pass");
1253 }
1254 
1256  llvm_unreachable("Unable to find on the fly pass");
1257 }
1258 
1259 // Destructor
1262  E = PassVector.end(); I != E; ++I)
1263  delete *I;
1264 }
1265 
1266 //===----------------------------------------------------------------------===//
1267 // NOTE: Is this the right place to define this method ?
1268 // getAnalysisIfAvailable - Return analysis result or null if it doesn't exist.
1270  return PM.findAnalysisPass(ID, dir);
1271 }
1272 
1274  Function &F) {
1275  return PM.getOnTheFlyPass(P, AnalysisPI, F);
1276 }
1277 
1278 //===----------------------------------------------------------------------===//
1279 // BBPassManager implementation
1280 
1281 /// Execute all of the passes scheduled for execution by invoking
1282 /// runOnBasicBlock method. Keep track of whether any of the passes modifies
1283 /// the function, and if so, return true.
1284 bool BBPassManager::runOnFunction(Function &F) {
1285  if (F.isDeclaration())
1286  return false;
1287 
1288  bool Changed = doInitialization(F);
1289 
1290  for (Function::iterator I = F.begin(), E = F.end(); I != E; ++I)
1291  for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) {
1292  BasicBlockPass *BP = getContainedPass(Index);
1293  bool LocalChanged = false;
1294 
1295  dumpPassInfo(BP, EXECUTION_MSG, ON_BASICBLOCK_MSG, I->getName());
1296  dumpRequiredSet(BP);
1297 
1298  initializeAnalysisImpl(BP);
1299 
1300  {
1301  // If the pass crashes, remember this.
1303  TimeRegion PassTimer(getPassTimer(BP));
1304 
1305  LocalChanged |= BP->runOnBasicBlock(*I);
1306  }
1307 
1308  Changed |= LocalChanged;
1309  if (LocalChanged)
1310  dumpPassInfo(BP, MODIFICATION_MSG, ON_BASICBLOCK_MSG,
1311  I->getName());
1312  dumpPreservedSet(BP);
1313 
1314  verifyPreservedAnalysis(BP);
1315  removeNotPreservedAnalysis(BP);
1316  recordAvailableAnalysis(BP);
1317  removeDeadPasses(BP, I->getName(), ON_BASICBLOCK_MSG);
1318  }
1319 
1320  return doFinalization(F) || Changed;
1321 }
1322 
1323 // Implement doInitialization and doFinalization
1324 bool BBPassManager::doInitialization(Module &M) {
1325  bool Changed = false;
1326 
1327  for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index)
1328  Changed |= getContainedPass(Index)->doInitialization(M);
1329 
1330  return Changed;
1331 }
1332 
1333 bool BBPassManager::doFinalization(Module &M) {
1334  bool Changed = false;
1335 
1336  for (int Index = getNumContainedPasses() - 1; Index >= 0; --Index)
1337  Changed |= getContainedPass(Index)->doFinalization(M);
1338 
1339  return Changed;
1340 }
1341 
1342 bool BBPassManager::doInitialization(Function &F) {
1343  bool Changed = false;
1344 
1345  for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) {
1346  BasicBlockPass *BP = getContainedPass(Index);
1347  Changed |= BP->doInitialization(F);
1348  }
1349 
1350  return Changed;
1351 }
1352 
1353 bool BBPassManager::doFinalization(Function &F) {
1354  bool Changed = false;
1355 
1356  for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) {
1357  BasicBlockPass *BP = getContainedPass(Index);
1358  Changed |= BP->doFinalization(F);
1359  }
1360 
1361  return Changed;
1362 }
1363 
1364 
1365 //===----------------------------------------------------------------------===//
1366 // FunctionPassManager implementation
1367 
1368 /// Create new Function pass manager
1370  FPM = new FunctionPassManagerImpl();
1371  // FPM is the top level manager.
1372  FPM->setTopLevelManager(FPM);
1373 
1374  AnalysisResolver *AR = new AnalysisResolver(*FPM);
1375  FPM->setResolver(AR);
1376 }
1377 
1379  delete FPM;
1380 }
1381 
1383  FPM->add(P);
1384 }
1385 
1386 /// run - Execute all of the passes scheduled for execution. Keep
1387 /// track of whether any of the passes modifies the function, and if
1388 /// so, return true.
1389 ///
1391  if (std::error_code EC = F.materialize())
1392  report_fatal_error("Error reading bitcode file: " + EC.message());
1393  return FPM->run(F);
1394 }
1395 
1396 
1397 /// doInitialization - Run all of the initializers for the function passes.
1398 ///
1400  return FPM->doInitialization(*M);
1401 }
1402 
1403 /// doFinalization - Run all of the finalizers for the function passes.
1404 ///
1406  return FPM->doFinalization(*M);
1407 }
1408 
1409 //===----------------------------------------------------------------------===//
1410 // FunctionPassManagerImpl implementation
1411 //
1413  bool Changed = false;
1414 
1415  dumpArguments();
1416  dumpPasses();
1417 
1418  for (ImmutablePass *ImPass : getImmutablePasses())
1419  Changed |= ImPass->doInitialization(M);
1420 
1421  for (unsigned Index = 0; Index < getNumContainedManagers(); ++Index)
1422  Changed |= getContainedManager(Index)->doInitialization(M);
1423 
1424  return Changed;
1425 }
1426 
1428  bool Changed = false;
1429 
1430  for (int Index = getNumContainedManagers() - 1; Index >= 0; --Index)
1431  Changed |= getContainedManager(Index)->doFinalization(M);
1432 
1433  for (ImmutablePass *ImPass : getImmutablePasses())
1434  Changed |= ImPass->doFinalization(M);
1435 
1436  return Changed;
1437 }
1438 
1439 /// cleanup - After running all passes, clean up pass manager cache.
1441  for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) {
1442  FunctionPass *FP = getContainedPass(Index);
1443  AnalysisResolver *AR = FP->getResolver();
1444  assert(AR && "Analysis Resolver is not set");
1445  AR->clearAnalysisImpls();
1446  }
1447 }
1448 
1450  if (!wasRun)
1451  return;
1452  for (unsigned Index = 0; Index < getNumContainedManagers(); ++Index) {
1453  FPPassManager *FPPM = getContainedManager(Index);
1454  for (unsigned Index = 0; Index < FPPM->getNumContainedPasses(); ++Index) {
1455  FPPM->getContainedPass(Index)->releaseMemory();
1456  }
1457  }
1458  wasRun = false;
1459 }
1460 
1461 // Execute all the passes managed by this top level manager.
1462 // Return true if any function is modified by a pass.
1464  bool Changed = false;
1465  TimingInfo::createTheTimeInfo();
1466 
1468  for (unsigned Index = 0; Index < getNumContainedManagers(); ++Index) {
1469  Changed |= getContainedManager(Index)->runOnFunction(F);
1470  F.getContext().yield();
1471  }
1472 
1473  for (unsigned Index = 0; Index < getNumContainedManagers(); ++Index)
1474  getContainedManager(Index)->cleanup();
1475 
1476  wasRun = true;
1477  return Changed;
1478 }
1479 
1480 //===----------------------------------------------------------------------===//
1481 // FPPassManager implementation
1482 
1483 char FPPassManager::ID = 0;
1484 /// Print passes managed by this manager
1485 void FPPassManager::dumpPassStructure(unsigned Offset) {
1486  dbgs().indent(Offset*2) << "FunctionPass Manager\n";
1487  for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) {
1488  FunctionPass *FP = getContainedPass(Index);
1489  FP->dumpPassStructure(Offset + 1);
1490  dumpLastUses(FP, Offset+1);
1491  }
1492 }
1493 
1494 
1495 /// Execute all of the passes scheduled for execution by invoking
1496 /// runOnFunction method. Keep track of whether any of the passes modifies
1497 /// the function, and if so, return true.
1499  if (F.isDeclaration())
1500  return false;
1501 
1502  bool Changed = false;
1503 
1504  // Collect inherited analysis from Module level pass manager.
1505  populateInheritedAnalysis(TPM->activeStack);
1506 
1507  for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) {
1508  FunctionPass *FP = getContainedPass(Index);
1509  bool LocalChanged = false;
1510 
1511  dumpPassInfo(FP, EXECUTION_MSG, ON_FUNCTION_MSG, F.getName());
1512  dumpRequiredSet(FP);
1513 
1514  initializeAnalysisImpl(FP);
1515 
1516  {
1518  TimeRegion PassTimer(getPassTimer(FP));
1519 
1520  LocalChanged |= FP->runOnFunction(F);
1521  }
1522 
1523  Changed |= LocalChanged;
1524  if (LocalChanged)
1525  dumpPassInfo(FP, MODIFICATION_MSG, ON_FUNCTION_MSG, F.getName());
1526  dumpPreservedSet(FP);
1527 
1528  verifyPreservedAnalysis(FP);
1529  removeNotPreservedAnalysis(FP);
1530  recordAvailableAnalysis(FP);
1531  removeDeadPasses(FP, F.getName(), ON_FUNCTION_MSG);
1532  }
1533  return Changed;
1534 }
1535 
1537  bool Changed = false;
1538 
1539  for (Function &F : M)
1540  Changed |= runOnFunction(F);
1541 
1542  return Changed;
1543 }
1544 
1546  bool Changed = false;
1547 
1548  for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index)
1549  Changed |= getContainedPass(Index)->doInitialization(M);
1550 
1551  return Changed;
1552 }
1553 
1555  bool Changed = false;
1556 
1557  for (int Index = getNumContainedPasses() - 1; Index >= 0; --Index)
1558  Changed |= getContainedPass(Index)->doFinalization(M);
1559 
1560  return Changed;
1561 }
1562 
1563 //===----------------------------------------------------------------------===//
1564 // MPPassManager implementation
1565 
1566 /// Execute all of the passes scheduled for execution by invoking
1567 /// runOnModule method. Keep track of whether any of the passes modifies
1568 /// the module, and if so, return true.
1569 bool
1570 MPPassManager::runOnModule(Module &M) {
1571  bool Changed = false;
1572 
1573  // Initialize on-the-fly passes
1574  for (auto &OnTheFlyManager : OnTheFlyManagers) {
1575  FunctionPassManagerImpl *FPP = OnTheFlyManager.second;
1576  Changed |= FPP->doInitialization(M);
1577  }
1578 
1579  // Initialize module passes
1580  for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index)
1581  Changed |= getContainedPass(Index)->doInitialization(M);
1582 
1583  for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) {
1584  ModulePass *MP = getContainedPass(Index);
1585  bool LocalChanged = false;
1586 
1587  dumpPassInfo(MP, EXECUTION_MSG, ON_MODULE_MSG, M.getModuleIdentifier());
1588  dumpRequiredSet(MP);
1589 
1590  initializeAnalysisImpl(MP);
1591 
1592  {
1594  TimeRegion PassTimer(getPassTimer(MP));
1595 
1596  LocalChanged |= MP->runOnModule(M);
1597  }
1598 
1599  Changed |= LocalChanged;
1600  if (LocalChanged)
1601  dumpPassInfo(MP, MODIFICATION_MSG, ON_MODULE_MSG,
1602  M.getModuleIdentifier());
1603  dumpPreservedSet(MP);
1604 
1605  verifyPreservedAnalysis(MP);
1606  removeNotPreservedAnalysis(MP);
1607  recordAvailableAnalysis(MP);
1608  removeDeadPasses(MP, M.getModuleIdentifier(), ON_MODULE_MSG);
1609  }
1610 
1611  // Finalize module passes
1612  for (int Index = getNumContainedPasses() - 1; Index >= 0; --Index)
1613  Changed |= getContainedPass(Index)->doFinalization(M);
1614 
1615  // Finalize on-the-fly passes
1616  for (auto &OnTheFlyManager : OnTheFlyManagers) {
1617  FunctionPassManagerImpl *FPP = OnTheFlyManager.second;
1618  // We don't know when is the last time an on-the-fly pass is run,
1619  // so we need to releaseMemory / finalize here
1620  FPP->releaseMemoryOnTheFly();
1621  Changed |= FPP->doFinalization(M);
1622  }
1623 
1624  return Changed;
1625 }
1626 
1627 /// Add RequiredPass into list of lower level passes required by pass P.
1628 /// RequiredPass is run on the fly by Pass Manager when P requests it
1629 /// through getAnalysis interface.
1630 void MPPassManager::addLowerLevelRequiredPass(Pass *P, Pass *RequiredPass) {
1632  "Unable to handle Pass that requires lower level Analysis pass");
1633  assert((P->getPotentialPassManagerType() <
1634  RequiredPass->getPotentialPassManagerType()) &&
1635  "Unable to handle Pass that requires lower level Analysis pass");
1636  if (!RequiredPass)
1637  return;
1638 
1639  FunctionPassManagerImpl *FPP = OnTheFlyManagers[P];
1640  if (!FPP) {
1641  FPP = new FunctionPassManagerImpl();
1642  // FPP is the top level manager.
1643  FPP->setTopLevelManager(FPP);
1644 
1645  OnTheFlyManagers[P] = FPP;
1646  }
1647  const PassInfo *RequiredPassPI =
1648  TPM->findAnalysisPassInfo(RequiredPass->getPassID());
1649 
1650  Pass *FoundPass = nullptr;
1651  if (RequiredPassPI && RequiredPassPI->isAnalysis()) {
1652  FoundPass =
1653  ((PMTopLevelManager*)FPP)->findAnalysisPass(RequiredPass->getPassID());
1654  }
1655  if (!FoundPass) {
1656  FoundPass = RequiredPass;
1657  // This should be guaranteed to add RequiredPass to the passmanager given
1658  // that we checked for an available analysis above.
1659  FPP->add(RequiredPass);
1660  }
1661  // Register P as the last user of FoundPass or RequiredPass.
1663  LU.push_back(FoundPass);
1664  FPP->setLastUser(LU, P);
1665 }
1666 
1667 /// Return function pass corresponding to PassInfo PI, that is
1668 /// required by module pass MP. Instantiate analysis pass, by using
1669 /// its runOnFunction() for function F.
1670 Pass* MPPassManager::getOnTheFlyPass(Pass *MP, AnalysisID PI, Function &F){
1671  FunctionPassManagerImpl *FPP = OnTheFlyManagers[MP];
1672  assert(FPP && "Unable to find on the fly pass");
1673 
1674  FPP->releaseMemoryOnTheFly();
1675  FPP->run(F);
1676  return ((PMTopLevelManager*)FPP)->findAnalysisPass(PI);
1677 }
1678 
1679 
1680 //===----------------------------------------------------------------------===//
1681 // PassManagerImpl implementation
1682 
1683 //
1684 /// run - Execute all of the passes scheduled for execution. Keep track of
1685 /// whether any of the passes modifies the module, and if so, return true.
1687  bool Changed = false;
1688  TimingInfo::createTheTimeInfo();
1689 
1690  dumpArguments();
1691  dumpPasses();
1692 
1693  for (ImmutablePass *ImPass : getImmutablePasses())
1694  Changed |= ImPass->doInitialization(M);
1695 
1697  for (unsigned Index = 0; Index < getNumContainedManagers(); ++Index) {
1698  Changed |= getContainedManager(Index)->runOnModule(M);
1699  M.getContext().yield();
1700  }
1701 
1702  for (ImmutablePass *ImPass : getImmutablePasses())
1703  Changed |= ImPass->doFinalization(M);
1704 
1705  return Changed;
1706 }
1707 
1708 //===----------------------------------------------------------------------===//
1709 // PassManager implementation
1710 
1711 /// Create new pass manager
1713  PM = new PassManagerImpl();
1714  // PM is the top level manager
1715  PM->setTopLevelManager(PM);
1716 }
1717 
1719  delete PM;
1720 }
1721 
1723  PM->add(P);
1724 }
1725 
1726 /// run - Execute all of the passes scheduled for execution. Keep track of
1727 /// whether any of the passes modifies the module, and if so, return true.
1729  return PM->run(M);
1730 }
1731 
1732 //===----------------------------------------------------------------------===//
1733 // TimingInfo implementation
1734 
1735 bool llvm::TimePassesIsEnabled = false;
1736 static cl::opt<bool,true>
1738  cl::desc("Time each pass, printing elapsed time for each on exit"));
1739 
1740 // createTheTimeInfo - This method either initializes the TheTimeInfo pointer to
1741 // a non-null value (if the -time-passes option is enabled) or it leaves it
1742 // null. It may be called multiple times.
1743 void TimingInfo::createTheTimeInfo() {
1744  if (!TimePassesIsEnabled || TheTimeInfo) return;
1745 
1746  // Constructed the first time this is called, iff -time-passes is enabled.
1747  // This guarantees that the object will be constructed before static globals,
1748  // thus it will be destroyed before them.
1749  static ManagedStatic<TimingInfo> TTI;
1750  TheTimeInfo = &*TTI;
1751 }
1752 
1753 /// If TimingInfo is enabled then start pass timer.
1755  if (TheTimeInfo)
1756  return TheTimeInfo->getPassTimer(P);
1757  return nullptr;
1758 }
1759 
1760 //===----------------------------------------------------------------------===//
1761 // PMStack implementation
1762 //
1763 
1764 // Pop Pass Manager from the stack and clear its analysis info.
1766 
1767  PMDataManager *Top = this->top();
1768  Top->initializeAnalysisInfo();
1769 
1770  S.pop_back();
1771 }
1772 
1773 // Push PM on the stack and set its top level manager.
1775  assert(PM && "Unable to push. Pass Manager expected");
1776  assert(PM->getDepth()==0 && "Pass Manager depth set too early");
1777 
1778  if (!this->empty()) {
1779  assert(PM->getPassManagerType() > this->top()->getPassManagerType()
1780  && "pushing bad pass manager to PMStack");
1781  PMTopLevelManager *TPM = this->top()->getTopLevelManager();
1782 
1783  assert(TPM && "Unable to find top level manager");
1784  TPM->addIndirectPassManager(PM);
1785  PM->setTopLevelManager(TPM);
1786  PM->setDepth(this->top()->getDepth()+1);
1787  } else {
1788  assert((PM->getPassManagerType() == PMT_ModulePassManager
1790  && "pushing bad pass manager to PMStack");
1791  PM->setDepth(1);
1792  }
1793 
1794  S.push_back(PM);
1795 }
1796 
1797 // Dump content of the pass manager stack.
1798 void PMStack::dump() const {
1799  for (PMDataManager *Manager : S)
1800  dbgs() << Manager->getAsPass()->getPassName() << ' ';
1801 
1802  if (!S.empty())
1803  dbgs() << '\n';
1804 }
1805 
1806 /// Find appropriate Module Pass Manager in the PM Stack and
1807 /// add self into that manager.
1809  PassManagerType PreferredType) {
1810  // Find Module Pass Manager
1811  while (!PMS.empty()) {
1812  PassManagerType TopPMType = PMS.top()->getPassManagerType();
1813  if (TopPMType == PreferredType)
1814  break; // We found desired pass manager
1815  else if (TopPMType > PMT_ModulePassManager)
1816  PMS.pop(); // Pop children pass managers
1817  else
1818  break;
1819  }
1820  assert(!PMS.empty() && "Unable to find appropriate Pass Manager");
1821  PMS.top()->add(this);
1822 }
1823 
1824 /// Find appropriate Function Pass Manager or Call Graph Pass Manager
1825 /// in the PM Stack and add self into that manager.
1827  PassManagerType PreferredType) {
1828 
1829  // Find Function Pass Manager
1830  while (!PMS.empty()) {
1832  PMS.pop();
1833  else
1834  break;
1835  }
1836 
1837  // Create new Function Pass Manager if needed.
1838  FPPassManager *FPP;
1840  FPP = (FPPassManager *)PMS.top();
1841  } else {
1842  assert(!PMS.empty() && "Unable to create Function Pass Manager");
1843  PMDataManager *PMD = PMS.top();
1844 
1845  // [1] Create new Function Pass Manager
1846  FPP = new FPPassManager();
1847  FPP->populateInheritedAnalysis(PMS);
1848 
1849  // [2] Set up new manager's top level manager
1850  PMTopLevelManager *TPM = PMD->getTopLevelManager();
1851  TPM->addIndirectPassManager(FPP);
1852 
1853  // [3] Assign manager to manage this new manager. This may create
1854  // and push new managers into PMS
1855  FPP->assignPassManager(PMS, PMD->getPassManagerType());
1856 
1857  // [4] Push new manager into PMS
1858  PMS.push(FPP);
1859  }
1860 
1861  // Assign FPP as the manager of this pass.
1862  FPP->add(this);
1863 }
1864 
1865 /// Find appropriate Basic Pass Manager or Call Graph Pass Manager
1866 /// in the PM Stack and add self into that manager.
1868  PassManagerType PreferredType) {
1869  BBPassManager *BBP;
1870 
1871  // Basic Pass Manager is a leaf pass manager. It does not handle
1872  // any other pass manager.
1873  if (!PMS.empty() &&
1875  BBP = (BBPassManager *)PMS.top();
1876  } else {
1877  // If leaf manager is not Basic Block Pass manager then create new
1878  // basic Block Pass manager.
1879  assert(!PMS.empty() && "Unable to create BasicBlock Pass Manager");
1880  PMDataManager *PMD = PMS.top();
1881 
1882  // [1] Create new Basic Block Manager
1883  BBP = new BBPassManager();
1884 
1885  // [2] Set up new manager's top level manager
1886  // Basic Block Pass Manager does not live by itself
1887  PMTopLevelManager *TPM = PMD->getTopLevelManager();
1888  TPM->addIndirectPassManager(BBP);
1889 
1890  // [3] Assign manager to manage this new manager. This may create
1891  // and push new managers into PMS
1892  BBP->assignPassManager(PMS, PreferredType);
1893 
1894  // [4] Push new manager into PMS
1895  PMS.push(BBP);
1896  }
1897 
1898  // Assign BBP as the manager of this pass.
1899  BBP->add(this);
1900 }
1901 
PMTopLevelManager * TPM
Pass interface - Implemented by all 'passes'.
Definition: Pass.h:82
std::string str() const
Provides conversion of the TimeValue into a readable time & date.
bool preserveHigherLevelAnalysis(Pass *P)
ValuesClass< DataType > LLVM_END_WITH_NULL values(const char *Arg, DataType Val, const char *Desc,...)
Definition: CommandLine.h:536
const_iterator end(StringRef path)
Get end iterator over path.
Definition: Path.cpp:240
PassManagerType
Different types of internal pass managers.
Definition: Pass.h:55
static TimingInfo * TheTimeInfo
BBPassManager.
Definition: Pass.h:62
virtual Pass * createPrinterPass(raw_ostream &O, const std::string &Banner) const =0
createPrinterPass - Get a Pass appropriate to print the IR this pass operates on (Module, Function or MachineFunction).
static TimeValue now()
This is a static constructor that returns a TimeValue that represents the current time...
static PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
LLVMContext & getContext() const
getContext - Return a reference to the LLVMContext associated with this function. ...
Definition: Function.cpp:223
Pass * findAnalysisPass(AnalysisID AID, bool Direction)
Find the pass that implements Analysis AID.
const char * getPassName() const
getPassName - Return the friendly name for the pass, never returns null
Definition: PassInfo.h:68
static cl::opt< bool, true > EnableTiming("time-passes", cl::location(TimePassesIsEnabled), cl::desc("Time each pass, printing elapsed time for each on exit"))
virtual PMDataManager * getAsPMDataManager()
Definition: Pass.cpp:98
void dumpLastUses(Pass *P, unsigned Offset) const
virtual void dumpPassStructure(unsigned Offset=0)
Definition: Pass.cpp:53
virtual bool runOnModule(Module &M)=0
runOnModule - Virtual method overriden by subclasses to process the module being operated on...
const std::vector< const PassInfo * > & getInterfacesImplemented() const
getInterfacesImplemented - Return a list of all of the analysis group interfaces implemented by this ...
Definition: PassInfo.h:136
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:114
FunctionPassManagerImpl manages FPPassManagers.
bool doInitialization(Module &M) override
doInitialization - Run all of the initializers for the function passes.
AnalysisID getPassID() const
getPassID - Return the PassID number that corresponds to this pass.
Definition: Pass.h:104
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:82
iterator end()
Definition: Function.h:459
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...
#define clEnumValEnd
Definition: CommandLine.h:498
virtual void getAnalysisUsage(AnalysisUsage &) const
getAnalysisUsage - This function should be overriden by passes that need analysis information to do t...
Definition: Pass.cpp:78
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...
unsigned getNumContainedManagers() const
virtual bool doInitialization(Function &)
doInitialization - Virtual method overridden by BasicBlockPass subclasses to do any necessary per-fun...
Definition: Pass.cpp:161
raw_ostream & indent(unsigned NumSpaces)
indent - Insert 'NumSpaces' spaces.
PMDataManager * getAsPMDataManager() override
static PassOptionList PrintBefore("print-before", llvm::cl::desc("Print IR before specified passes"), cl::Hidden)
virtual const char * getPassName() const
getPassName - Return a nice clean name for a pass.
Definition: Pass.cpp:61
static bool ShouldPrintBeforeOrAfterPass(const PassInfo *PI, PassOptionList &PassesToPrint)
This is a helper to determine whether to print IR before or after a pass.
const VectorType & getPreservedSet() const
void collectRequiredAnalysis(SmallVectorImpl< Pass * > &RequiredPasses, SmallVectorImpl< AnalysisID > &ReqPassNotAvailable, Pass *P)
Populate RequiredPasses with analysis pass that are required by pass P and are available.
const_iterator begin(StringRef path)
Get begin iterator over path.
Definition: Path.cpp:232
void dumpRequiredSet(const Pass *P) const
F(f)
void yield()
Calls the yield callback (if applicable).
PMTopLevelManager(PMDataManager *PMDM)
Initialize top level manager. Create first pass manager.
virtual void preparePassManager(PMStack &)
Check if available pass managers are suitable for this pass or not.
Definition: Pass.cpp:69
void dumpPassInfo(Pass *P, enum PassDebuggingString S1, enum PassDebuggingString S2, StringRef Msg)
static sys::Mutex Lock
virtual PassManagerType getPassManagerType() const
bool isAnalysis() const
Definition: PassInfo.h:89
void setResolver(AnalysisResolver *AR)
Definition: Pass.cpp:102
Pass * createPass() const
createPass() - Use this method to create an instance of this pass.
Definition: PassInfo.h:117
LLVM_ATTRIBUTE_NORETURN void report_fatal_error(const char *reason, bool gen_crash_diag=true)
Reports a serious error, calling any installed error handler.
DenseMap< AnalysisID, Pass * > * InheritedAnalysis[PMT_Last]
PMTopLevelManager manages LastUser info and collects common APIs used by top level pass managers...
Timer * getPassTimer(Pass *)
If TimingInfo is enabled then start pass timer.
void setDepth(unsigned newDepth)
StringRef getName() const
Return a constant reference to the value's name.
Definition: Value.cpp:188
bool doFinalization(Module &M) override
doFinalization - Run all of the finalizers for the function passes.
The TimeRegion class is used as a helper class to call the startTimer() and stopTimer() methods of th...
Definition: Timer.h:126
void schedulePass(Pass *P)
Schedule pass P for execution.
void add(Pass *P) override
Add a pass to the queue of passes to run.
void freePass(Pass *P, StringRef Msg, enum PassDebuggingString)
Remove P.
void dumpPassStructure(unsigned Offset) override
Print passes managed by this manager.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition: ErrorHandling.h:98
bool isPassDebuggingExecutionsOrMore() const
isPassDebuggingExecutionsOrMore - Return true if -debug-pass=Executions or higher is specified...
virtual ~PMTopLevelManager()
Destructor.
virtual bool doFinalization(Module &)
doFinalization - Virtual method overriden by subclasses to do any necessary clean up after all passes...
Definition: Pass.h:116
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: APInt.h:33
void verifyPreservedAnalysis(Pass *P)
verifyPreservedAnalysis – Verify analysis presreved by pass P.
void initializeAnalysisInfo()
Initialize available analysis information.
MPPassManager.
Definition: Pass.h:57
virtual void addLowerLevelRequiredPass(Pass *P, Pass *RequiredPass)
Add RequiredPass into list of lower level passes required by pass P.
void populateInheritedAnalysis(PMStack &PMS)
FPPassManager manages BBPassManagers and FunctionPasses.
PMStack - This class implements a stack data structure of PMDataManager pointers. ...
void initializeAnalysisImpl(Pass *P)
All Required analyses should be available to the pass as it runs! Here we fill in the AnalysisImpls m...
const std::string & getModuleIdentifier() const
Get the module identifier which is, essentially, the name of the module.
Definition: Module.h:242
#define false
Definition: ConvertUTF.c:65
#define clEnumVal(ENUMVAL, DESC)
Definition: CommandLine.h:496
PassManagerPrettyStackEntry - This is used to print informative information about what pass is runnin...
unsigned getDepth() const
void assignPassManager(PMStack &PMS, PassManagerType T) override
Find appropriate Module Pass Manager in the PM Stack and add self into that manager.
Timer - This class is used to track the amount of time spent between invocations of its startTimer()/...
Definition: Timer.h:79
bool LLVM_ATTRIBUTE_UNUSED_RESULT empty() const
Definition: SmallVector.h:57
PassManagerType getTopLevelPassManagerType() override
Pass * getAnalysisIfAvailable(AnalysisID ID, bool Direction) const
Return analysis result or null if it doesn't exist.
#define T
void add(Pass *P, bool ProcessAnalysis=true)
Add pass P into the PassVector.
bool run(Module &M)
run - Execute all of the passes scheduled for execution.
unsigned getNumContainedPasses() const
PassManagerType getTopLevelPassManagerType() override
void add(Pass *P) override
Add a pass to the queue of passes to run.
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: ArrayRef.h:31
virtual Pass * getAsPass()=0
bool doFinalization(Module &M) override
doFinalization - Run all of the finalizers for the function passes.
virtual bool doFinalization(Function &)
doFinalization - Virtual method overriden by BasicBlockPass subclasses to do any post processing need...
Definition: Pass.cpp:166
iterator begin()
Definition: Function.h:457
bool run(Function &F)
run - Execute all of the passes scheduled for execution.
virtual ImmutablePass * getAsImmutablePass()
Definition: Pass.cpp:94
virtual bool doInitialization(Module &)
doInitialization - Virtual method overridden by subclasses to do any necessary initialization before ...
Definition: Pass.h:111
static PassOptionList PrintAfter("print-after", llvm::cl::desc("Print IR after specified passes"), cl::Hidden)
#define P(N)
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:325
void assignPassManager(PMStack &PMS, PassManagerType T) override
Find appropriate Basic Pass Manager or Call Graph Pass Manager in the PM Stack and add self into that...
* if(!EatIfPresent(lltok::kw_thread_local)) return false
ParseOptionalThreadLocal := /*empty.
FPPassManager * getContainedManager(unsigned N)
void dumpPreservedSet(const Pass *P) const
void print(raw_ostream &OS) const override
print - Emit information about this stack frame to OS.
const VectorType & getRequiredTransitiveSet() const
void addIndirectPassManager(PMDataManager *Manager)
std::pair< iterator, bool > insert(PtrType Ptr)
Inserts Ptr if and only if there is no element in the container equal to Ptr.
Definition: SmallPtrSet.h:264
void collectLastUses(SmallVectorImpl< Pass * > &LastUses, Pass *P)
Collect passes whose last user is P.
AnalysisResolver * getResolver() const
Definition: Pass.h:145
Represent the analysis usage information of a pass.
static GCMetadataPrinterRegistry::Add< ErlangGCPrinter > X("erlang","erlang-compatible garbage collector")
PassManagerImpl manages MPPassManagers.
FunctionPass class - This class is used to implement most global optimizations.
Definition: Pass.h:294
static cl::opt< bool > PrintBeforeAll("print-before-all", llvm::cl::desc("Print IR before each pass"), cl::init(false))
void getAnalysisUsage(AnalysisUsage &Info) const override
Pass Manager itself does not invalidate any analysis info.
SmallVectorImpl< ImmutablePass * > & getImmutablePasses()
PassInfo class - An instance of this class exists for every pass known by the system, and can be obtained from a live Pass by calling its getPassInfo() method.
Definition: PassInfo.h:30
bool doInitialization(Module &M) override
doInitialization - Run all of the initializers for the function passes.
bool run(Module &M)
run - Execute all of the passes scheduled for execution.
BasicBlockPass class - This class is used to implement most local optimizations.
Definition: Pass.h:330
bool runOnModule(Module &M) override
runOnModule - Virtual method overriden by subclasses to process the module being operated on...
void getAnalysisUsage(AnalysisUsage &Info) const override
Pass Manager itself does not invalidate any analysis info.
static cl::opt< enum PassDebugLevel > PassDebugging("debug-pass", cl::Hidden, cl::desc("Print 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"), clEnumValEnd))
void setLastUser(ArrayRef< Pass * > AnalysisPasses, Pass *P)
Set pass P as the last user of the given analysis passes.
static bool ShouldPrintBeforePass(const PassInfo *PI)
This is a utility to check whether a pass should have IR dumped before it.
void addImmutablePass(ImmutablePass *P)
Add immutable pass and initialize it.
bool empty() const
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements...
Definition: SmallPtrSet.h:299
static bool ShouldPrintAfterPass(const PassInfo *PI)
This is a utility to check whether a pass should have IR dumped after it.
ImmutablePass class - This class is used to provide information that does not need to be run...
Definition: Pass.h:262
void recordAvailableAnalysis(Pass *P)
Augment AvailableAnalysis by adding analysis made available by pass P.
FPPassManager.
Definition: Pass.h:59
bool getPreservesAll() const
Determine whether a pass said it does not transform its input at all.
void removeNotPreservedAnalysis(Pass *P)
Remove Analysis that is not preserved by the pass.
Module.h This file contains the declarations for the Module class.
void dump() const
PMDataManager * getAsPMDataManager() override
void addAnalysisImplsPair(AnalysisID PI, Pass *P)
bool runOnFunction(Function &F)
run - Execute all of the passes scheduled for execution.
bool doFinalization()
doFinalization - Run all of the finalizers for the function passes.
void removeDeadPasses(Pass *P, StringRef Msg, enum PassDebuggingString)
Remove dead passes used by P.
virtual Pass * getOnTheFlyPass(Pass *P, AnalysisID PI, Function &F)
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:123
const char * getPassArgument() const
getPassArgument - Return the command line option that may be passed to 'opt' that will cause this pas...
Definition: PassInfo.h:74
SmallVector< Pass *, 16 > PassVector
PMDataManager * top() const
void clearAnalysisImpls()
Clear cache that is used to connect a pass to the the analysis (PassInfo).
Pass * findImplPass(AnalysisID PI)
Find pass that is implementing PI.
void setPreservesAll()
Set by analyses that do not transform their input at all.
PassManager< Function > FunctionPassManager
Convenience typedef for a pass manager over functions.
Definition: PassManager.h:258
AnalysisUsage * findAnalysisUsage(Pass *P)
Find analysis usage information for the pass P.
void add(Pass *P)
Add a pass to the queue of passes to run.
const PassInfo * findAnalysisPassInfo(AnalysisID AID) const
Retrieve the PassInfo for an analysis.
void setTopLevelManager(PMTopLevelManager *T)
SmallVector< PMDataManager *, 8 > PassManagers
Collection of pass managers.
const VectorType & getRequiredSet() const
Manages a sequence of passes over units of IR.
Definition: PassManager.h:180
bool isDeclaration() const
Return true if the primary definition of this global value is outside of the current translation unit...
Definition: Globals.cpp:128
PMDataManager & getPMDataManager()
FunctionPass * getContainedPass(unsigned N)
void cleanup()
cleanup - After running all passes, clean up pass manager cache.
static cl::opt< bool > PrintAfterAll("print-after-all", llvm::cl::desc("Print IR after each pass"), cl::init(false))
#define I(x, y, z)
Definition: MD5.cpp:54
#define N
The TimerGroup class is used to group together related timers into a single report that is printed wh...
Definition: Timer.h:160
PassDebugLevel
ModulePass class - This class is used to implement unstructured interprocedural optimizations and ana...
Definition: Pass.h:236
iterator find(const KeyT &Val)
Definition: DenseMap.h:124
const void * AnalysisID
Definition: Pass.h:47
void push(PMDataManager *PM)
PMDataManager provides the common place to manage the analysis data used by pass managers.
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.
const PassInfo * getPassInfo(const void *TI) const
getPassInfo - Look up a pass' corresponding PassInfo, indexed by the pass' type identifier (&MyPass::...
This file defines passes to print out IR in various granularities.
Pass * findAnalysisPass(AnalysisID AID)
Find the pass that implements Analysis AID.
void add(Pass *P)
Add a pass to the queue of passes to run.
void dumpPassArguments() const
bool run(Function &F)
run - Execute all of the passes scheduled for execution.
MPPassManager * getContainedManager(unsigned N)
virtual bool runOnFunction(Function &F)=0
runOnFunction - Virtual method overriden by subclasses to do the per-function processing of the pass...
virtual bool runOnBasicBlock(BasicBlock &BB)=0
runOnBasicBlock - Virtual method overriden by subclasses to do the per-basicblock processing of the p...
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:38
bool doInitialization()
doInitialization - Run all of the initializers for the function passes.
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:40
Pass * createPrinterPass(raw_ostream &O, const std::string &Banner) const override
createPrinterPass - Get a module printer pass.
PassManager()
Create new pass manager.
ManagedStatic - This transparently changes the behavior of global statics to be lazily constructed on...
Definition: ManagedStatic.h:61
bool TimePassesIsEnabled
If the user specifies the -time-passes argument on an LLVM tool command line then the value of this b...
Definition: IRReader.cpp:26
std::error_code materialize()
Make sure this GlobalValue is fully read.
Definition: Globals.cpp:38
LocationClass< Ty > location(Ty &L)
Definition: CommandLine.h:340
Pass * createPrinterPass(raw_ostream &O, const std::string &Banner) const override
createPrinterPass - Get a function printer pass.
virtual PassManagerType getPotentialPassManagerType() const
Return what kind of Pass Manager can manage this pass.
Definition: Pass.cpp:73
virtual void assignPassManager(PMStack &, PassManagerType)
Each pass is responsible for assigning a pass manager to itself.
Definition: Pass.h:135
LLVMContext & getContext() const
Get the global data context.
Definition: Module.h:265