LLVM  16.0.0git
LegacyPassManagers.h
Go to the documentation of this file.
1 //===- LegacyPassManagers.h - Legacy Pass Infrastructure --------*- C++ -*-===//
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 declares the LLVM Pass Manager infrastructure.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #ifndef LLVM_IR_LEGACYPASSMANAGERS_H
14 #define LLVM_IR_LEGACYPASSMANAGERS_H
15 
16 #include "llvm/ADT/DenseMap.h"
17 #include "llvm/ADT/FoldingSet.h"
18 #include "llvm/ADT/SmallPtrSet.h"
19 #include "llvm/ADT/SmallVector.h"
20 #include "llvm/Pass.h"
21 #include <vector>
22 
23 //===----------------------------------------------------------------------===//
24 // Overview:
25 // The Pass Manager Infrastructure manages passes. It's responsibilities are:
26 //
27 // o Manage optimization pass execution order
28 // o Make required Analysis information available before pass P is run
29 // o Release memory occupied by dead passes
30 // o If Analysis information is dirtied by a pass then regenerate Analysis
31 // information before it is consumed by another pass.
32 //
33 // Pass Manager Infrastructure uses multiple pass managers. They are
34 // PassManager, FunctionPassManager, MPPassManager, FPPassManager, BBPassManager.
35 // This class hierarchy uses multiple inheritance but pass managers do not
36 // derive from another pass manager.
37 //
38 // PassManager and FunctionPassManager are two top-level pass manager that
39 // represents the external interface of this entire pass manager infrastucture.
40 //
41 // Important classes :
42 //
43 // [o] class PMTopLevelManager;
44 //
45 // Two top level managers, PassManager and FunctionPassManager, derive from
46 // PMTopLevelManager. PMTopLevelManager manages information used by top level
47 // managers such as last user info.
48 //
49 // [o] class PMDataManager;
50 //
51 // PMDataManager manages information, e.g. list of available analysis info,
52 // used by a pass manager to manage execution order of passes. It also provides
53 // a place to implement common pass manager APIs. All pass managers derive from
54 // PMDataManager.
55 //
56 // [o] class FunctionPassManager;
57 //
58 // This is a external interface used to manage FunctionPasses. This
59 // interface relies on FunctionPassManagerImpl to do all the tasks.
60 //
61 // [o] class FunctionPassManagerImpl : public ModulePass, PMDataManager,
62 // public PMTopLevelManager;
63 //
64 // FunctionPassManagerImpl is a top level manager. It manages FPPassManagers
65 //
66 // [o] class FPPassManager : public ModulePass, public PMDataManager;
67 //
68 // FPPassManager manages FunctionPasses and BBPassManagers
69 //
70 // [o] class MPPassManager : public Pass, public PMDataManager;
71 //
72 // MPPassManager manages ModulePasses and FPPassManagers
73 //
74 // [o] class PassManager;
75 //
76 // This is a external interface used by various tools to manages passes. It
77 // relies on PassManagerImpl to do all the tasks.
78 //
79 // [o] class PassManagerImpl : public Pass, public PMDataManager,
80 // public PMTopLevelManager
81 //
82 // PassManagerImpl is a top level pass manager responsible for managing
83 // MPPassManagers.
84 //===----------------------------------------------------------------------===//
85 
87 
88 namespace llvm {
89 template <typename T> class ArrayRef;
90 class Module;
91 class StringRef;
92 class Value;
93 class PMDataManager;
94 
95 // enums for debugging strings
97  EXECUTION_MSG, // "Executing Pass '" + PassName
98  MODIFICATION_MSG, // "Made Modification '" + PassName
99  FREEING_MSG, // " Freeing Pass '" + PassName
100  ON_FUNCTION_MSG, // "' on Function '" + FunctionName + "'...\n"
101  ON_MODULE_MSG, // "' on Module '" + ModuleName + "'...\n"
102  ON_REGION_MSG, // "' on Region '" + Msg + "'...\n'"
103  ON_LOOP_MSG, // "' on Loop '" + Msg + "'...\n'"
104  ON_CG_MSG // "' on Call Graph Nodes '" + Msg + "'...\n'"
105 };
106 
107 /// PassManagerPrettyStackEntry - This is used to print informative information
108 /// about what pass is running when/if a stack trace is generated.
110  Pass *P;
111  Value *V;
112  Module *M;
113 
114 public:
116  : P(p), V(nullptr), M(nullptr) {} // When P is releaseMemory'd.
118  : P(p), V(&v), M(nullptr) {} // When P is run on V
120  : P(p), V(nullptr), M(&m) {} // When P is run on M
121 
122  /// print - Emit information about this stack frame to OS.
123  void print(raw_ostream &OS) const override;
124 };
125 
126 //===----------------------------------------------------------------------===//
127 // PMStack
128 //
129 /// PMStack - This class implements a stack data structure of PMDataManager
130 /// pointers.
131 ///
132 /// Top level pass managers (see PassManager.cpp) maintain active Pass Managers
133 /// using PMStack. Each Pass implements assignPassManager() to connect itself
134 /// with appropriate manager. assignPassManager() walks PMStack to find
135 /// suitable manager.
136 class PMStack {
137 public:
138  typedef std::vector<PMDataManager *>::const_reverse_iterator iterator;
139  iterator begin() const { return S.rbegin(); }
140  iterator end() const { return S.rend(); }
141 
142  void pop();
143  PMDataManager *top() const { return S.back(); }
144  void push(PMDataManager *PM);
145  bool empty() const { return S.empty(); }
146 
147  void dump() const;
148 
149 private:
150  std::vector<PMDataManager *> S;
151 };
152 
153 //===----------------------------------------------------------------------===//
154 // PMTopLevelManager
155 //
156 /// PMTopLevelManager manages LastUser info and collects common APIs used by
157 /// top level pass managers.
159 protected:
160  explicit PMTopLevelManager(PMDataManager *PMDM);
161 
162  unsigned getNumContainedManagers() const {
163  return (unsigned)PassManagers.size();
164  }
165 
167 
168 private:
169  virtual PMDataManager *getAsPMDataManager() = 0;
170  virtual PassManagerType getTopLevelPassManagerType() = 0;
171 
172 public:
173  /// Schedule pass P for execution. Make sure that passes required by
174  /// P are run before P is run. Update analysis info maintained by
175  /// the manager. Remove dead passes. This is a recursive function.
176  void schedulePass(Pass *P);
177 
178  /// Set pass P as the last user of the given analysis passes.
179  void setLastUser(ArrayRef<Pass*> AnalysisPasses, Pass *P);
180 
181  /// Collect passes whose last user is P
182  void collectLastUses(SmallVectorImpl<Pass *> &LastUses, Pass *P);
183 
184  /// Find the pass that implements Analysis AID. Search immutable
185  /// passes and all pass managers. If desired pass is not found
186  /// then return NULL.
188 
189  /// Retrieve the PassInfo for an analysis.
190  const PassInfo *findAnalysisPassInfo(AnalysisID AID) const;
191 
192  /// Find analysis usage information for the pass P.
194 
195  virtual ~PMTopLevelManager();
196 
197  /// Add immutable pass and initialize it.
199 
201  return ImmutablePasses;
202  }
203 
204  void addPassManager(PMDataManager *Manager) {
205  PassManagers.push_back(Manager);
206  }
207 
208  // Add Manager into the list of managers that are not directly
209  // maintained by this top level pass manager
210  inline void addIndirectPassManager(PMDataManager *Manager) {
211  IndirectPassManagers.push_back(Manager);
212  }
213 
214  // Print passes managed by this top level manager.
215  void dumpPasses() const;
216  void dumpArguments() const;
217 
218  // Active Pass Managers
220 
221 protected:
222  /// Collection of pass managers
224 
225 private:
226  /// Collection of pass managers that are not directly maintained
227  /// by this pass manager
228  SmallVector<PMDataManager *, 8> IndirectPassManagers;
229 
230  // Map to keep track of last user of the analysis pass.
231  // LastUser->second is the last user of Lastuser->first.
232  // This is kept in sync with InversedLastUser.
233  DenseMap<Pass *, Pass *> LastUser;
234 
235  // Map to keep track of passes that are last used by a pass.
236  // This is kept in sync with LastUser.
237  DenseMap<Pass *, SmallPtrSet<Pass *, 8> > InversedLastUser;
238 
239  /// Immutable passes are managed by top level manager.
240  SmallVector<ImmutablePass *, 16> ImmutablePasses;
241 
242  /// Map from ID to immutable passes.
244 
245 
246  /// A wrapper around AnalysisUsage for the purpose of uniqueing. The wrapper
247  /// is used to avoid needing to make AnalysisUsage itself a folding set node.
248  struct AUFoldingSetNode : public FoldingSetNode {
249  AnalysisUsage AU;
250  AUFoldingSetNode(const AnalysisUsage &AU) : AU(AU) {}
251  void Profile(FoldingSetNodeID &ID) const {
252  Profile(ID, AU);
253  }
254  static void Profile(FoldingSetNodeID &ID, const AnalysisUsage &AU) {
255  // TODO: We could consider sorting the dependency arrays within the
256  // AnalysisUsage (since they are conceptually unordered).
257  ID.AddBoolean(AU.getPreservesAll());
258  auto ProfileVec = [&](const SmallVectorImpl<AnalysisID>& Vec) {
259  ID.AddInteger(Vec.size());
260  for(AnalysisID AID : Vec)
261  ID.AddPointer(AID);
262  };
263  ProfileVec(AU.getRequiredSet());
264  ProfileVec(AU.getRequiredTransitiveSet());
265  ProfileVec(AU.getPreservedSet());
266  ProfileVec(AU.getUsedSet());
267  }
268  };
269 
270  // Contains all of the unique combinations of AnalysisUsage. This is helpful
271  // when we have multiple instances of the same pass since they'll usually
272  // have the same analysis usage and can share storage.
273  FoldingSet<AUFoldingSetNode> UniqueAnalysisUsages;
274 
275  // Allocator used for allocating UAFoldingSetNodes. This handles deletion of
276  // all allocated nodes in one fell swoop.
277  SpecificBumpPtrAllocator<AUFoldingSetNode> AUFoldingSetNodeAllocator;
278 
279  // Maps from a pass to it's associated entry in UniqueAnalysisUsages. Does
280  // not own the storage associated with either key or value..
282 
283  /// Collection of PassInfo objects found via analysis IDs and in this top
284  /// level manager. This is used to memoize queries to the pass registry.
285  /// FIXME: This is an egregious hack because querying the pass registry is
286  /// either slow or racy.
287  mutable DenseMap<AnalysisID, const PassInfo *> AnalysisPassInfos;
288 };
289 
290 //===----------------------------------------------------------------------===//
291 // PMDataManager
292 
293 /// PMDataManager provides the common place to manage the analysis data
294 /// used by pass managers.
296 public:
298 
299  virtual ~PMDataManager();
300 
301  virtual Pass *getAsPass() = 0;
302 
303  /// Augment AvailableAnalysis by adding analysis made available by pass P.
305 
306  /// verifyPreservedAnalysis -- Verify analysis presreved by pass P.
308 
309  /// Remove Analysis that is not preserved by the pass
311 
312  /// Remove dead passes used by P.
314  enum PassDebuggingString);
315 
316  /// Remove P.
317  void freePass(Pass *P, StringRef Msg,
318  enum PassDebuggingString);
319 
320  /// Add pass P into the PassVector. Update
321  /// AvailableAnalysis appropriately if ProcessAnalysis is true.
322  void add(Pass *P, bool ProcessAnalysis = true);
323 
324  /// Add RequiredPass into list of lower level passes required by pass P.
325  /// RequiredPass is run on the fly by Pass Manager when P requests it
326  /// through getAnalysis interface.
327  virtual void addLowerLevelRequiredPass(Pass *P, Pass *RequiredPass);
328 
329  virtual std::tuple<Pass *, bool> getOnTheFlyPass(Pass *P, AnalysisID PI,
330  Function &F);
331 
332  /// Initialize available analysis information.
334  AvailableAnalysis.clear();
335  for (auto &IA : InheritedAnalysis)
336  IA = nullptr;
337  }
338 
339  // Return true if P preserves high level analysis used by other
340  // passes that are managed by this manager.
342 
343  /// Populate UsedPasses with analysis pass that are used or required by pass
344  /// P and are available. Populate ReqPassNotAvailable with analysis pass that
345  /// are required by pass P but are not available.
347  SmallVectorImpl<Pass *> &UsedPasses,
348  SmallVectorImpl<AnalysisID> &ReqPassNotAvailable, Pass *P);
349 
350  /// All Required analyses should be available to the pass as it runs! Here
351  /// we fill in the AnalysisImpls member of the pass so that it can
352  /// successfully use the getAnalysis() method to retrieve the
353  /// implementations it needs.
355 
356  /// Find the pass that implements Analysis AID. If desired pass is not found
357  /// then return NULL.
359 
360  // Access toplevel manager
363 
364  unsigned getDepth() const { return Depth; }
365  void setDepth(unsigned newDepth) { Depth = newDepth; }
366 
367  // Print routines used by debug-pass
368  void dumpLastUses(Pass *P, unsigned Offset) const;
369  void dumpPassArguments() const;
370  void dumpPassInfo(Pass *P, enum PassDebuggingString S1,
372  void dumpRequiredSet(const Pass *P) const;
373  void dumpPreservedSet(const Pass *P) const;
374  void dumpUsedSet(const Pass *P) const;
375 
376  unsigned getNumContainedPasses() const {
377  return (unsigned)PassVector.size();
378  }
379 
381  assert ( 0 && "Invalid use of getPassManagerType");
382  return PMT_Unknown;
383  }
384 
386  return &AvailableAnalysis;
387  }
388 
389  // Collect AvailableAnalysis from all the active Pass Managers.
391  unsigned Index = 0;
392  for (PMDataManager *PMDM : PMS)
393  InheritedAnalysis[Index++] = PMDM->getAvailableAnalysis();
394  }
395 
396  /// Set the initial size of the module if the user has specified that they
397  /// want remarks for size.
398  /// Returns 0 if the remark was not requested.
399  unsigned initSizeRemarkInfo(
400  Module &M,
401  StringMap<std::pair<unsigned, unsigned>> &FunctionToInstrCount);
402 
403  /// Emit a remark signifying that the number of IR instructions in the module
404  /// changed.
405  /// \p F is optionally passed by passes which run on Functions, and thus
406  /// always know whether or not a non-empty function is available.
407  ///
408  /// \p FunctionToInstrCount maps the name of a \p Function to a pair. The
409  /// first member of the pair is the IR count of the \p Function before running
410  /// \p P, and the second member is the IR count of the \p Function after
411  /// running \p P.
413  Pass *P, Module &M, int64_t Delta, unsigned CountBefore,
414  StringMap<std::pair<unsigned, unsigned>> &FunctionToInstrCount,
415  Function *F = nullptr);
416 
417 protected:
418  // Top level manager.
419  PMTopLevelManager *TPM = nullptr;
420 
421  // Collection of pass that are managed by this manager
423 
424  // Collection of Analysis provided by Parent pass manager and
425  // used by current pass manager. At at time there can not be more
426  // then PMT_Last active pass mangers.
428 
429  /// isPassDebuggingExecutionsOrMore - Return true if -debug-pass=Executions
430  /// or higher is specified.
431  bool isPassDebuggingExecutionsOrMore() const;
432 
433 private:
434  void dumpAnalysisUsage(StringRef Msg, const Pass *P,
435  const AnalysisUsage::VectorType &Set) const;
436 
437  // Set of available Analysis. This information is used while scheduling
438  // pass. If a pass requires an analysis which is not available then
439  // the required analysis pass is scheduled to run before the pass itself is
440  // scheduled to run.
441  DenseMap<AnalysisID, Pass*> AvailableAnalysis;
442 
443  // Collection of higher level analysis used by the pass managed by
444  // this manager.
445  SmallVector<Pass *, 16> HigherLevelAnalysis;
446 
447  unsigned Depth = 0;
448 };
449 
450 //===----------------------------------------------------------------------===//
451 // FPPassManager
452 //
453 /// FPPassManager manages BBPassManagers and FunctionPasses.
454 /// It batches all function passes and basic block pass managers together and
455 /// sequence them to process one function at a time before processing next
456 /// function.
457 class FPPassManager : public ModulePass, public PMDataManager {
458 public:
459  static char ID;
460  explicit FPPassManager() : ModulePass(ID) {}
461 
462  /// run - Execute all of the passes scheduled for execution. Keep track of
463  /// whether any of the passes modifies the module, and if so, return true.
464  bool runOnFunction(Function &F);
465  bool runOnModule(Module &M) override;
466 
467  /// cleanup - After running all passes, clean up pass manager cache.
468  void cleanup();
469 
470  /// doInitialization - Overrides ModulePass doInitialization for global
471  /// initialization tasks
472  ///
474 
475  /// doInitialization - Run all of the initializers for the function passes.
476  ///
477  bool doInitialization(Module &M) override;
478 
479  /// doFinalization - Overrides ModulePass doFinalization for global
480  /// finalization tasks
481  ///
483 
484  /// doFinalization - Run all of the finalizers for the function passes.
485  ///
486  bool doFinalization(Module &M) override;
487 
488  PMDataManager *getAsPMDataManager() override { return this; }
489  Pass *getAsPass() override { return this; }
490 
491  /// Pass Manager itself does not invalidate any analysis info.
492  void getAnalysisUsage(AnalysisUsage &Info) const override {
493  Info.setPreservesAll();
494  }
495 
496  // Print passes managed by this manager
497  void dumpPassStructure(unsigned Offset) override;
498 
499  StringRef getPassName() const override { return "Function Pass Manager"; }
500 
502  assert ( N < PassVector.size() && "Pass number out of range!");
503  FunctionPass *FP = static_cast<FunctionPass *>(PassVector[N]);
504  return FP;
505  }
506 
509  }
510 };
511 
512 }
513 
514 #endif
llvm::PMTopLevelManager::addImmutablePass
void addImmutablePass(ImmutablePass *P)
Add immutable pass and initialize it.
Definition: LegacyPassManager.cpp:795
llvm::PMDataManager::recordAvailableAnalysis
void recordAvailableAnalysis(Pass *P)
Augment AvailableAnalysis by adding analysis made available by pass P.
Definition: LegacyPassManager.cpp:871
CmpMode::FP
@ FP
llvm::AnalysisUsage::getRequiredTransitiveSet
const VectorType & getRequiredTransitiveSet() const
Definition: PassAnalysisSupport.h:145
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
llvm::FPPassManager::runOnFunction
bool runOnFunction(Function &F)
run - Execute all of the passes scheduled for execution.
Definition: LegacyPassManager.cpp:1393
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::ModulePass
ModulePass class - This class is used to implement unstructured interprocedural optimizations and ana...
Definition: Pass.h:248
llvm::PassManagerPrettyStackEntry::print
void print(raw_ostream &OS) const override
print - Emit information about this stack frame to OS.
Definition: LegacyPassManager.cpp:208
llvm::PMTopLevelManager::findAnalysisUsage
AnalysisUsage * findAnalysisUsage(Pass *P)
Find analysis usage information for the pass P.
Definition: LegacyPassManager.cpp:621
llvm::ImmutablePass
ImmutablePass class - This class is used to provide information that does not need to be run.
Definition: Pass.h:279
llvm::PMTopLevelManager::PassManagers
SmallVector< PMDataManager *, 8 > PassManagers
Collection of pass managers.
Definition: LegacyPassManagers.h:223
llvm::PassManagerPrettyStackEntry::PassManagerPrettyStackEntry
PassManagerPrettyStackEntry(Pass *p)
Definition: LegacyPassManagers.h:115
llvm::FPPassManager::getAsPass
Pass * getAsPass() override
Definition: LegacyPassManagers.h:489
llvm::Function
Definition: Function.h:60
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
Pass.h
llvm::PMTopLevelManager::schedulePass
void schedulePass(Pass *P)
Schedule pass P for execution.
Definition: LegacyPassManager.cpp:657
llvm::SmallVector
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1199
llvm::PMDataManager::dumpPassInfo
void dumpPassInfo(Pass *P, enum PassDebuggingString S1, enum PassDebuggingString S2, StringRef Msg)
Definition: LegacyPassManager.cpp:1178
llvm::SmallDenseMap
Definition: DenseMap.h:880
llvm::AnalysisID
const void * AnalysisID
Definition: Pass.h:47
llvm::FPPassManager::getPassName
StringRef getPassName() const override
getPassName - Return a nice clean name for a pass.
Definition: LegacyPassManagers.h:499
llvm::PMTopLevelManager::getNumContainedManagers
unsigned getNumContainedManagers() const
Definition: LegacyPassManagers.h:162
llvm::PassManagerType
PassManagerType
Different types of internal pass managers.
Definition: Pass.h:52
llvm::SpecificBumpPtrAllocator< AUFoldingSetNode >
DenseMap.h
llvm::PassInfo
PassInfo class - An instance of this class exists for every pass known by the system,...
Definition: PassInfo.h:30
llvm::PMT_Unknown
@ PMT_Unknown
Definition: Pass.h:53
llvm::PMTopLevelManager::findAnalysisPassInfo
const PassInfo * findAnalysisPassInfo(AnalysisID AID) const
Retrieve the PassInfo for an analysis.
Definition: LegacyPassManager.cpp:784
T
#define T
Definition: Mips16ISelLowering.cpp:341
llvm::PMStack::push
void push(PMDataManager *PM)
Definition: LegacyPassManager.cpp:1691
llvm::ON_REGION_MSG
@ ON_REGION_MSG
Definition: LegacyPassManagers.h:102
llvm::PMStack::end
iterator end() const
Definition: LegacyPassManagers.h:140
llvm::PassManagerPrettyStackEntry
PassManagerPrettyStackEntry - This is used to print informative information about what pass is runnin...
Definition: LegacyPassManagers.h:109
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:65
p
the resulting code requires compare and branches when and if * p
Definition: README.txt:396
llvm::FPPassManager::doInitialization
bool doInitialization(Module &M) override
doInitialization - Run all of the initializers for the function passes.
Definition: LegacyPassManager.cpp:1481
F
#define F(x, y, z)
Definition: MD5.cpp:55
llvm::PrettyStackTraceEntry
PrettyStackTraceEntry - This class is used to represent a frame of the "pretty" stack trace that is d...
Definition: PrettyStackTrace.h:52
llvm::PMDataManager
PMDataManager provides the common place to manage the analysis data used by pass managers.
Definition: LegacyPassManagers.h:295
llvm::PMDataManager::dumpLastUses
void dumpLastUses(Pass *P, unsigned Offset) const
Definition: LegacyPassManager.cpp:1148
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:814
llvm::PMDataManager::getNumContainedPasses
unsigned getNumContainedPasses() const
Definition: LegacyPassManagers.h:376
llvm::PMStack::iterator
std::vector< PMDataManager * >::const_reverse_iterator iterator
Definition: LegacyPassManagers.h:138
llvm::PMStack::begin
iterator begin() const
Definition: LegacyPassManagers.h:139
llvm::FPPassManager::getPassManagerType
PassManagerType getPassManagerType() const override
Definition: LegacyPassManagers.h:507
llvm::FPPassManager::getAsPMDataManager
PMDataManager * getAsPMDataManager() override
Definition: LegacyPassManagers.h:488
llvm::PMTopLevelManager::activeStack
PMStack activeStack
Definition: LegacyPassManagers.h:219
llvm::PMTopLevelManager::getImmutablePasses
SmallVectorImpl< ImmutablePass * > & getImmutablePasses()
Definition: LegacyPassManagers.h:200
llvm::PMTopLevelManager::collectLastUses
void collectLastUses(SmallVectorImpl< Pass * > &LastUses, Pass *P)
Collect passes whose last user is P.
Definition: LegacyPassManager.cpp:611
llvm::AnalysisUsage::getUsedSet
const VectorType & getUsedSet() const
Definition: PassAnalysisSupport.h:149
llvm::PMDataManager::dumpPreservedSet
void dumpPreservedSet(const Pass *P) const
Definition: LegacyPassManager.cpp:1228
llvm::AnalysisUsage
Represent the analysis usage information of a pass.
Definition: PassAnalysisSupport.h:47
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:1115
llvm::dwarf::Index
Index
Definition: Dwarf.h:472
llvm::PMDataManager::setDepth
void setDepth(unsigned newDepth)
Definition: LegacyPassManagers.h:365
llvm::raw_ostream
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:53
llvm::FPPassManager::cleanup
void cleanup()
cleanup - After running all passes, clean up pass manager cache.
Definition: LegacyPassManager.cpp:1366
llvm::MODIFICATION_MSG
@ MODIFICATION_MSG
Definition: LegacyPassManagers.h:98
llvm::PMTopLevelManager::dumpArguments
void dumpArguments() const
Definition: LegacyPassManager.cpp:832
llvm::AArch64PACKey::IA
@ IA
Definition: AArch64BaseInfo.h:819
llvm::PMDataManager::dumpPassArguments
void dumpPassArguments() const
Definition: LegacyPassManager.cpp:1166
SmallPtrSet.h
Info
Analysis containing CSE Info
Definition: CSEInfo.cpp:27
llvm::ON_CG_MSG
@ ON_CG_MSG
Definition: LegacyPassManagers.h:104
llvm::FPPassManager::getContainedPass
FunctionPass * getContainedPass(unsigned N)
Definition: LegacyPassManagers.h:501
llvm::PMStack::top
PMDataManager * top() const
Definition: LegacyPassManagers.h:143
llvm::CallingConv::ID
unsigned ID
LLVM IR allows to use arbitrary numbers as calling convention identifiers.
Definition: CallingConv.h:24
llvm::FPPassManager::doFinalization
bool doFinalization(Module &M) override
doFinalization - Run all of the finalizers for the function passes.
Definition: LegacyPassManager.cpp:1490
llvm::StringMap
StringMap - This is an unconventional map that is specialized for handling keys that are "strings",...
Definition: StringMap.h:110
llvm::AnalysisUsage::getRequiredSet
const VectorType & getRequiredSet() const
Definition: PassAnalysisSupport.h:144
llvm::PMStack::empty
bool empty() const
Definition: LegacyPassManagers.h:145
llvm::ON_MODULE_MSG
@ ON_MODULE_MSG
Definition: LegacyPassManagers.h:101
llvm::PassManagerPrettyStackEntry::PassManagerPrettyStackEntry
PassManagerPrettyStackEntry(Pass *p, Value &v)
Definition: LegacyPassManagers.h:117
llvm::ON_LOOP_MSG
@ ON_LOOP_MSG
Definition: LegacyPassManagers.h:103
llvm::FPPassManager::ID
static char ID
Definition: LegacyPassManagers.h:459
llvm::PMDataManager::initializeAnalysisInfo
void initializeAnalysisInfo()
Initialize available analysis information.
Definition: LegacyPassManagers.h:333
llvm::PMDataManager::getTopLevelManager
PMTopLevelManager * getTopLevelManager()
Definition: LegacyPassManagers.h:361
llvm::ON_FUNCTION_MSG
@ ON_FUNCTION_MSG
Definition: LegacyPassManagers.h:100
llvm::DenseMap
Definition: DenseMap.h:714
llvm::FPPassManager::FPPassManager
FPPassManager()
Definition: LegacyPassManagers.h:460
PrettyStackTrace.h
llvm::FPPassManager::getAnalysisUsage
void getAnalysisUsage(AnalysisUsage &Info) const override
Pass Manager itself does not invalidate any analysis info.
Definition: LegacyPassManagers.h:492
llvm::PMTopLevelManager::addPassManager
void addPassManager(PMDataManager *Manager)
Definition: LegacyPassManagers.h:204
llvm::PassDebuggingString
PassDebuggingString
Definition: LegacyPassManagers.h:96
llvm::PMDataManager::removeDeadPasses
void removeDeadPasses(Pass *P, StringRef Msg, enum PassDebuggingString)
Remove dead passes used by P.
Definition: LegacyPassManager.cpp:968
llvm::PMDataManager::preserveHigherLevelAnalysis
bool preserveHigherLevelAnalysis(Pass *P)
Definition: LegacyPassManager.cpp:888
llvm::PMDataManager::InheritedAnalysis
DenseMap< AnalysisID, Pass * > * InheritedAnalysis[PMT_Last]
Definition: LegacyPassManagers.h:427
llvm::PMTopLevelManager::PMTopLevelManager
PMTopLevelManager(PMDataManager *PMDM)
Initialize top level manager. Create first pass manager.
Definition: LegacyPassManager.cpp:551
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::PMDataManager::dumpRequiredSet
void dumpRequiredSet(const Pass *P) const
Definition: LegacyPassManager.cpp:1219
llvm::PMDataManager::~PMDataManager
virtual ~PMDataManager()
Definition: LegacyPassManager.cpp:1298
llvm::Module
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:66
llvm::FPPassManager::dumpPassStructure
void dumpPassStructure(unsigned Offset) override
Print passes managed by this manager.
Definition: LegacyPassManager.cpp:1381
llvm::PMDataManager::setTopLevelManager
void setTopLevelManager(PMTopLevelManager *T)
Definition: LegacyPassManagers.h:362
llvm::PMT_Last
@ PMT_Last
Definition: Pass.h:59
llvm::PMDataManager::dumpUsedSet
void dumpUsedSet(const Pass *P) const
Definition: LegacyPassManager.cpp:1237
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::FoldingSet< AUFoldingSetNode >
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:50
llvm::PMT_FunctionPassManager
@ PMT_FunctionPassManager
FPPassManager.
Definition: Pass.h:56
llvm::FoldingSetBase::Node
Node - This class is used to maintain the singly linked bucket list in a folding set.
Definition: FoldingSet.h:136
llvm::PassManagerPrettyStackEntry::PassManagerPrettyStackEntry
PassManagerPrettyStackEntry(Pass *p, Module &m)
Definition: LegacyPassManagers.h:119
llvm::FoldingSetNodeID
FoldingSetNodeID - This class is used to gather all the unique data bits of a node.
Definition: FoldingSet.h:318
Module
Machine Check Debug Module
Definition: MachineCheckDebugify.cpp:122
llvm::EXECUTION_MSG
@ EXECUTION_MSG
Definition: LegacyPassManagers.h:97
Profile
Load MIR Sample Profile
Definition: MIRSampleProfile.cpp:70
llvm::PMDataManager::getPassManagerType
virtual PassManagerType getPassManagerType() const
Definition: LegacyPassManagers.h:380
llvm::PMDataManager::PMDataManager
PMDataManager()
Definition: LegacyPassManagers.h:297
llvm::PMStack::pop
void pop()
Definition: LegacyPassManager.cpp:1682
FoldingSet.h
llvm::AMDGPU::SendMsg::Msg
const CustomOperand< const MCSubtargetInfo & > Msg[]
Definition: AMDGPUAsmUtils.cpp:39
llvm::PMDataManager::verifyPreservedAnalysis
void verifyPreservedAnalysis(Pass *P)
verifyPreservedAnalysis – Verify analysis presreved by pass P.
Definition: LegacyPassManager.cpp:904
llvm::PMDataManager::removeNotPreservedAnalysis
void removeNotPreservedAnalysis(Pass *P)
Remove Analysis that is not preserved by the pass.
Definition: LegacyPassManager.cpp:922
llvm::FPPassManager
FPPassManager manages BBPassManagers and FunctionPasses.
Definition: LegacyPassManagers.h:457
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:1270
llvm::PMStack
PMStack - This class implements a stack data structure of PMDataManager pointers.
Definition: LegacyPassManagers.h:136
llvm::PMDataManager::add
void add(Pass *P, bool ProcessAnalysis=true)
Add pass P into the PassVector.
Definition: LegacyPassManager.cpp:1019
llvm::PMDataManager::getOnTheFlyPass
virtual std::tuple< Pass *, bool > getOnTheFlyPass(Pass *P, AnalysisID PI, Function &F)
Definition: LegacyPassManager.cpp:1292
llvm::PMDataManager::PassVector
SmallVector< Pass *, 16 > PassVector
Definition: LegacyPassManagers.h:422
Direction
Loop::LoopBounds::Direction Direction
Definition: LoopInfo.cpp:230
llvm::PMDataManager::getAvailableAnalysis
DenseMap< AnalysisID, Pass * > * getAvailableAnalysis()
Definition: LegacyPassManagers.h:385
llvm::TargetStackID::Value
Value
Definition: TargetFrameLowering.h:27
llvm::PMDataManager::TPM
PMTopLevelManager * TPM
Definition: LegacyPassManagers.h:419
llvm::PMTopLevelManager::initializeAllAnalysisInfo
void initializeAllAnalysisInfo()
Definition: LegacyPassManager.cpp:849
llvm::PMTopLevelManager::addIndirectPassManager
void addIndirectPassManager(PMDataManager *Manager)
Definition: LegacyPassManagers.h:210
llvm::FPPassManager::runOnModule
bool runOnModule(Module &M) override
runOnModule - Virtual method overriden by subclasses to process the module being operated on.
Definition: LegacyPassManager.cpp:1472
llvm::PMDataManager::getDepth
unsigned getDepth() const
Definition: LegacyPassManagers.h:364
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:559
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:1094
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:989
SmallVector.h
N
#define N
P
#define P(N)
llvm::AnalysisUsage::getPreservedSet
const VectorType & getPreservedSet() const
Definition: PassAnalysisSupport.h:148
llvm::PMTopLevelManager::~PMTopLevelManager
virtual ~PMTopLevelManager()
Destructor.
Definition: LegacyPassManager.cpp:859
llvm::SmallVectorImpl
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: APFloat.h:42
llvm::PMTopLevelManager
PMTopLevelManager manages LastUser info and collects common APIs used by top level pass managers.
Definition: LegacyPassManagers.h:158
llvm::PMStack::dump
void dump() const
Definition: LegacyPassManager.cpp:1715
llvm::FunctionPass
FunctionPass class - This class is used to implement most global optimizations.
Definition: Pass.h:308
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:87
llvm::PMTopLevelManager::findAnalysisPass
Pass * findAnalysisPass(AnalysisID AID)
Find the pass that implements Analysis AID.
Definition: LegacyPassManager.cpp:765
llvm::PMDataManager::isPassDebuggingExecutionsOrMore
bool isPassDebuggingExecutionsOrMore() const
isPassDebuggingExecutionsOrMore - Return true if -debug-pass=Executions or higher is specified.
Definition: LegacyPassManager.cpp:61
llvm::PMDataManager::populateInheritedAnalysis
void populateInheritedAnalysis(PMStack &PMS)
Definition: LegacyPassManagers.h:390
llvm::Value
LLVM Value Representation.
Definition: Value.h:74
llvm::FREEING_MSG
@ FREEING_MSG
Definition: LegacyPassManagers.h:99
llvm::PMDataManager::findAnalysisPass
Pass * findAnalysisPass(AnalysisID AID, bool Direction)
Find the pass that implements Analysis AID.
Definition: LegacyPassManager.cpp:1132