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