LLVM  15.0.0git
LoopPass.cpp
Go to the documentation of this file.
1 //===- LoopPass.cpp - Loop Pass and Loop Pass Manager ---------------------===//
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 LoopPass and LPPassManager. All loop optimization
10 // and transformation passes are derived from LoopPass. LPPassManager is
11 // responsible for managing LoopPasses.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #include "llvm/Analysis/LoopPass.h"
16 #include "llvm/Analysis/LoopInfo.h"
17 #include "llvm/IR/Dominators.h"
18 #include "llvm/IR/LLVMContext.h"
19 #include "llvm/IR/OptBisect.h"
20 #include "llvm/IR/PassTimingInfo.h"
21 #include "llvm/IR/PrintPasses.h"
22 #include "llvm/InitializePasses.h"
23 #include "llvm/Support/Debug.h"
25 #include "llvm/Support/Timer.h"
27 using namespace llvm;
28 
29 #define DEBUG_TYPE "loop-pass-manager"
30 
31 namespace {
32 
33 /// PrintLoopPass - Print a Function corresponding to a Loop.
34 ///
35 class PrintLoopPassWrapper : public LoopPass {
36  raw_ostream &OS;
37  std::string Banner;
38 
39 public:
40  static char ID;
41  PrintLoopPassWrapper() : LoopPass(ID), OS(dbgs()) {}
42  PrintLoopPassWrapper(raw_ostream &OS, const std::string &Banner)
43  : LoopPass(ID), OS(OS), Banner(Banner) {}
44 
45  void getAnalysisUsage(AnalysisUsage &AU) const override {
46  AU.setPreservesAll();
47  }
48 
49  bool runOnLoop(Loop *L, LPPassManager &) override {
50  auto BBI = llvm::find_if(L->blocks(), [](BasicBlock *BB) { return BB; });
51  if (BBI != L->blocks().end() &&
52  isFunctionInPrintList((*BBI)->getParent()->getName())) {
53  printLoop(*L, OS, Banner);
54  }
55  return false;
56  }
57 
58  StringRef getPassName() const override { return "Print Loop IR"; }
59 };
60 
62 }
63 
64 //===----------------------------------------------------------------------===//
65 // LPPassManager
66 //
67 
68 char LPPassManager::ID = 0;
69 
71  LI = nullptr;
72  CurrentLoop = nullptr;
73 }
74 
75 // Insert loop into loop nest (LoopInfo) and loop queue (LQ).
77  if (L.isOutermost()) {
78  // This is the top level loop.
79  LQ.push_front(&L);
80  return;
81  }
82 
83  // Insert L into the loop queue after the parent loop.
84  for (auto I = LQ.begin(), E = LQ.end(); I != E; ++I) {
85  if (*I == L.getParentLoop()) {
86  // deque does not support insert after.
87  ++I;
88  LQ.insert(I, 1, &L);
89  return;
90  }
91  }
92 }
93 
94 // Recurse through all subloops and all loops into LQ.
95 static void addLoopIntoQueue(Loop *L, std::deque<Loop *> &LQ) {
96  LQ.push_back(L);
97  for (Loop *I : reverse(*L))
98  addLoopIntoQueue(I, LQ);
99 }
100 
101 /// Pass Manager itself does not invalidate any analysis info.
103  // LPPassManager needs LoopInfo. In the long term LoopInfo class will
104  // become part of LPPassManager.
105  Info.addRequired<LoopInfoWrapperPass>();
106  Info.addRequired<DominatorTreeWrapperPass>();
107  Info.setPreservesAll();
108 }
109 
111  assert((&L == CurrentLoop || CurrentLoop->contains(&L)) &&
112  "Must not delete loop outside the current loop tree!");
113  // If this loop appears elsewhere within the queue, we also need to remove it
114  // there. However, we have to be careful to not remove the back of the queue
115  // as that is assumed to match the current loop.
116  assert(LQ.back() == CurrentLoop && "Loop queue back isn't the current loop!");
117  llvm::erase_value(LQ, &L);
118 
119  if (&L == CurrentLoop) {
120  CurrentLoopDeleted = true;
121  // Add this loop back onto the back of the queue to preserve our invariants.
122  LQ.push_back(&L);
123  }
124 }
125 
126 /// run - Execute all of the passes scheduled for execution. Keep track of
127 /// whether any of the passes modifies the function, and if so, return true.
129  auto &LIWP = getAnalysis<LoopInfoWrapperPass>();
130  LI = &LIWP.getLoopInfo();
131  Module &M = *F.getParent();
132 #if 0
133  DominatorTree *DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
134 #endif
135  bool Changed = false;
136 
137  // Collect inherited analysis from Module level pass manager.
139 
140  // Populate the loop queue in reverse program order. There is no clear need to
141  // process sibling loops in either forward or reverse order. There may be some
142  // advantage in deleting uses in a later loop before optimizing the
143  // definitions in an earlier loop. If we find a clear reason to process in
144  // forward order, then a forward variant of LoopPassManager should be created.
145  //
146  // Note that LoopInfo::iterator visits loops in reverse program
147  // order. Here, reverse_iterator gives us a forward order, and the LoopQueue
148  // reverses the order a third time by popping from the back.
149  for (Loop *L : reverse(*LI))
150  addLoopIntoQueue(L, LQ);
151 
152  if (LQ.empty()) // No loops, skip calling finalizers
153  return false;
154 
155  // Initialization
156  for (Loop *L : LQ) {
157  for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) {
158  LoopPass *P = getContainedPass(Index);
159  Changed |= P->doInitialization(L, *this);
160  }
161  }
162 
163  // Walk Loops
164  unsigned InstrCount, FunctionSize = 0;
165  StringMap<std::pair<unsigned, unsigned>> FunctionToInstrCount;
166  bool EmitICRemark = M.shouldEmitInstrCountChangedRemark();
167  // Collect the initial size of the module and the function we're looking at.
168  if (EmitICRemark) {
169  InstrCount = initSizeRemarkInfo(M, FunctionToInstrCount);
170  FunctionSize = F.getInstructionCount();
171  }
172  while (!LQ.empty()) {
173  CurrentLoopDeleted = false;
174  CurrentLoop = LQ.back();
175 
176  // Run all passes on the current Loop.
177  for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) {
178  LoopPass *P = getContainedPass(Index);
179 
180  llvm::TimeTraceScope LoopPassScope("RunLoopPass", P->getPassName());
181 
183  CurrentLoop->getHeader()->getName());
185 
187 
188  bool LocalChanged = false;
189  {
190  PassManagerPrettyStackEntry X(P, *CurrentLoop->getHeader());
191  TimeRegion PassTimer(getPassTimer(P));
192 #ifdef EXPENSIVE_CHECKS
193  uint64_t RefHash = P->structuralHash(F);
194 #endif
195  LocalChanged = P->runOnLoop(CurrentLoop, *this);
196 
197 #ifdef EXPENSIVE_CHECKS
198  if (!LocalChanged && (RefHash != P->structuralHash(F))) {
199  llvm::errs() << "Pass modifies its input and doesn't report it: "
200  << P->getPassName() << "\n";
201  llvm_unreachable("Pass modifies its input and doesn't report it");
202  }
203 #endif
204 
205  Changed |= LocalChanged;
206  if (EmitICRemark) {
207  unsigned NewSize = F.getInstructionCount();
208  // Update the size of the function, emit a remark, and update the
209  // size of the module.
210  if (NewSize != FunctionSize) {
211  int64_t Delta = static_cast<int64_t>(NewSize) -
212  static_cast<int64_t>(FunctionSize);
214  FunctionToInstrCount, &F);
215  InstrCount = static_cast<int64_t>(InstrCount) + Delta;
216  FunctionSize = NewSize;
217  }
218  }
219  }
220 
221  if (LocalChanged)
223  CurrentLoopDeleted ? "<deleted loop>"
224  : CurrentLoop->getName());
226 
227  if (!CurrentLoopDeleted) {
228  // Manually check that this loop is still healthy. This is done
229  // instead of relying on LoopInfo::verifyLoop since LoopInfo
230  // is a function pass and it's really expensive to verify every
231  // loop in the function every time. That level of checking can be
232  // enabled with the -verify-loop-info option.
233  {
234  TimeRegion PassTimer(getPassTimer(&LIWP));
235  CurrentLoop->verifyLoop();
236  }
237  // Here we apply same reasoning as in the above case. Only difference
238  // is that LPPassManager might run passes which do not require LCSSA
239  // form (LoopPassPrinter for example). We should skip verification for
240  // such passes.
241  // FIXME: Loop-sink currently break LCSSA. Fix it and reenable the
242  // verification!
243 #if 0
245  assert(CurrentLoop->isRecursivelyLCSSAForm(*DT, *LI));
246 #endif
247 
248  // Then call the regular verifyAnalysis functions.
250 
251  F.getContext().yield();
252  }
253 
254  if (LocalChanged)
258  CurrentLoopDeleted ? "<deleted>"
259  : CurrentLoop->getHeader()->getName(),
260  ON_LOOP_MSG);
261 
262  if (CurrentLoopDeleted)
263  // Do not run other passes on this loop.
264  break;
265  }
266 
267  // If the loop was deleted, release all the loop passes. This frees up
268  // some memory, and avoids trouble with the pass manager trying to call
269  // verifyAnalysis on them.
270  if (CurrentLoopDeleted) {
271  for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) {
272  Pass *P = getContainedPass(Index);
273  freePass(P, "<deleted>", ON_LOOP_MSG);
274  }
275  }
276 
277  // Pop the loop from queue after running all passes.
278  LQ.pop_back();
279  }
280 
281  // Finalization
282  for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) {
283  LoopPass *P = getContainedPass(Index);
284  Changed |= P->doFinalization();
285  }
286 
287  return Changed;
288 }
289 
290 /// Print passes managed by this manager
291 void LPPassManager::dumpPassStructure(unsigned Offset) {
292  errs().indent(Offset*2) << "Loop Pass Manager\n";
293  for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) {
294  Pass *P = getContainedPass(Index);
295  P->dumpPassStructure(Offset + 1);
296  dumpLastUses(P, Offset+1);
297  }
298 }
299 
300 
301 //===----------------------------------------------------------------------===//
302 // LoopPass
303 
305  const std::string &Banner) const {
306  return new PrintLoopPassWrapper(O, Banner);
307 }
308 
309 // Check if this pass is suitable for the current LPPassManager, if
310 // available. This pass P is not suitable for a LPPassManager if P
311 // is not preserving higher level analysis info used by other
312 // LPPassManager passes. In such case, pop LPPassManager from the
313 // stack. This will force assignPassManager() to create new
314 // LPPassManger as expected.
316 
317  // Find LPPassManager
318  while (!PMS.empty() &&
320  PMS.pop();
321 
322  // If this pass is destroying high level information that is used
323  // by other passes that are managed by LPM then do not insert
324  // this pass in current LPM. Use new LPPassManager.
325  if (PMS.top()->getPassManagerType() == PMT_LoopPassManager &&
326  !PMS.top()->preserveHigherLevelAnalysis(this))
327  PMS.pop();
328 }
329 
330 /// Assign pass manager to manage this pass.
332  PassManagerType PreferredType) {
333  // Find LPPassManager
334  while (!PMS.empty() &&
336  PMS.pop();
337 
338  LPPassManager *LPPM;
340  LPPM = (LPPassManager*)PMS.top();
341  else {
342  // Create new Loop Pass Manager if it does not exist.
343  assert (!PMS.empty() && "Unable to create Loop Pass Manager");
344  PMDataManager *PMD = PMS.top();
345 
346  // [1] Create new Loop Pass Manager
347  LPPM = new LPPassManager();
348  LPPM->populateInheritedAnalysis(PMS);
349 
350  // [2] Set up new manager's top level manager
352  TPM->addIndirectPassManager(LPPM);
353 
354  // [3] Assign manager to manage this new manager. This may create
355  // and push new managers into PMS
356  Pass *P = LPPM->getAsPass();
357  TPM->schedulePass(P);
358 
359  // [4] Push new manager into PMS
360  PMS.push(LPPM);
361  }
362 
363  LPPM->add(this);
364 }
365 
366 static std::string getDescription(const Loop &L) {
367  return "loop";
368 }
369 
370 bool LoopPass::skipLoop(const Loop *L) const {
371  const Function *F = L->getHeader()->getParent();
372  if (!F)
373  return false;
374  // Check the opt bisect limit.
375  OptPassGate &Gate = F->getContext().getOptPassGate();
376  if (Gate.isEnabled() && !Gate.shouldRunPass(this, getDescription(*L)))
377  return true;
378  // Check for the OptimizeNone attribute.
379  if (F->hasOptNone()) {
380  // FIXME: Report this to dbgs() only once per function.
381  LLVM_DEBUG(dbgs() << "Skipping pass '" << getPassName() << "' in function "
382  << F->getName() << "\n");
383  // FIXME: Delete loop from pass manager's queue?
384  return true;
385  }
386  return false;
387 }
388 
391 }
392 
394 INITIALIZE_PASS(LCSSAVerificationPass, "lcssa-verification", "LCSSA Verifier",
395  false, false)
llvm::PMDataManager::recordAvailableAnalysis
void recordAvailableAnalysis(Pass *P)
Augment AvailableAnalysis by adding analysis made available by pass P.
Definition: LegacyPassManager.cpp:871
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:17
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::TimeTraceScope
The TimeTraceScope is a helper class to call the begin and end functions of the time trace profiler.
Definition: TimeProfiler.h:67
llvm::LoopPass::createPrinterPass
Pass * createPrinterPass(raw_ostream &O, const std::string &Banner) const override
getPrinterPass - Get a pass to print the function corresponding to a Loop.
Definition: LoopPass.cpp:304
llvm::BasicBlock::getParent
const Function * getParent() const
Return the enclosing method, or null if none.
Definition: BasicBlock.h:104
llvm::Function
Definition: Function.h:60
llvm::Loop
Represents a single loop in the control flow graph.
Definition: LoopInfo.h:530
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::LoopBase::contains
bool contains(const LoopT *L) const
Return true if the specified loop is contained within in this loop.
Definition: LoopInfo.h:122
llvm::PMTopLevelManager::schedulePass
void schedulePass(Pass *P)
Schedule pass P for execution.
Definition: LegacyPassManager.cpp:657
llvm::PMDataManager::dumpPassInfo
void dumpPassInfo(Pass *P, enum PassDebuggingString S1, enum PassDebuggingString S2, StringRef Msg)
Definition: LegacyPassManager.cpp:1178
llvm::OptPassGate::isEnabled
virtual bool isEnabled() const
isEnabled() should return true before calling shouldRunPass().
Definition: OptBisect.h:38
llvm::LPPassManager::LPPassManager
LPPassManager()
Definition: LoopPass.cpp:70
llvm::DominatorTree
Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree.
Definition: Dominators.h:166
llvm::PassManagerType
PassManagerType
Different types of internal pass managers.
Definition: Pass.h:52
InstrCount
static unsigned InstrCount
Definition: DFAPacketizer.cpp:53
llvm::LPPassManager::getContainedPass
LoopPass * getContainedPass(unsigned N)
Definition: LoopPass.h:97
llvm::reverse
auto reverse(ContainerTy &&C, std::enable_if_t< has_rbegin< ContainerTy >::value > *=nullptr)
Definition: STLExtras.h:380
llvm::LoopInfoWrapperPass
The legacy pass manager's analysis pass to compute loop information.
Definition: LoopInfo.h:1271
OptBisect.h
llvm::LCSSAVerificationPass::LCSSAVerificationPass
LCSSAVerificationPass()
Definition: LoopPass.cpp:389
llvm::LCSSAVerificationPass::ID
static char ID
Definition: LoopPass.h:125
llvm::LPPassManager::ID
static char ID
Definition: LoopPass.h:78
llvm::PMStack::push
void push(PMDataManager *PM)
Definition: LegacyPassManager.cpp:1691
llvm::errs
raw_fd_ostream & errs()
This returns a reference to a raw_ostream for standard error.
Definition: raw_ostream.cpp:893
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
LLVM_DEBUG
#define LLVM_DEBUG(X)
Definition: Debug.h:101
llvm::LPPassManager::addLoop
void addLoop(Loop &L)
Definition: LoopPass.cpp:76
F
#define F(x, y, z)
Definition: MD5.cpp:55
llvm::BasicBlock
LLVM Basic Block Representation.
Definition: BasicBlock.h:55
llvm::dbgs
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:163
PassTimingInfo.h
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::LoopBase::getParentLoop
LoopT * getParentLoop() const
Return the parent loop if it exists or nullptr for top level loops.
Definition: LoopInfo.h:113
llvm::PMDataManager::getNumContainedPasses
unsigned getNumContainedPasses() const
Definition: LegacyPassManagers.h:376
llvm::TimeRegion
The TimeRegion class is used as a helper class to call the startTimer() and stopTimer() methods of th...
Definition: Timer.h:145
llvm::PassRegistry::getPassRegistry
static PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
Definition: PassRegistry.cpp:31
E
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
llvm::LPPassManager::dumpPassStructure
void dumpPassStructure(unsigned Offset) override
Print passes managed by this manager.
Definition: LoopPass.cpp:291
llvm::PMTopLevelManager::activeStack
PMStack activeStack
Definition: LegacyPassManagers.h:219
INITIALIZE_PASS
#define INITIALIZE_PASS(passName, arg, name, cfg, analysis)
Definition: PassSupport.h:37
llvm::OptPassGate
Extensions to this class implement mechanisms to disable passes and individual optimizations at compi...
Definition: OptBisect.h:27
addLoopIntoQueue
static void addLoopIntoQueue(Loop *L, std::deque< Loop * > &LQ)
Definition: LoopPass.cpp:95
llvm::LoopPass::skipLoop
bool skipLoop(const Loop *L) const
Optional passes call this function to check whether the pass should be skipped.
Definition: LoopPass.cpp:370
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::LoopBase::blocks
iterator_range< block_iterator > blocks() const
Definition: LoopInfo.h:178
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::printLoop
void printLoop(Loop &L, raw_ostream &OS, const std::string &Banner="")
Function to print a loop's contents as LLVM's text IR assembly.
Definition: LoopInfo.cpp:976
llvm::LoopBase::verifyLoop
void verifyLoop() const
Verify loop structure.
Definition: LoopInfoImpl.h:285
llvm::DominatorTreeWrapperPass
Legacy analysis pass which computes a DominatorTree.
Definition: Dominators.h:302
llvm::raw_ostream
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:54
llvm::MODIFICATION_MSG
@ MODIFICATION_MSG
Definition: LegacyPassManagers.h:98
llvm::LPPassManager
Definition: LoopPass.h:76
Info
Analysis containing CSE Info
Definition: CSEInfo.cpp:27
llvm::LPPassManager::getAnalysisUsage
void getAnalysisUsage(AnalysisUsage &Info) const override
Pass Manager itself does not invalidate any analysis info.
Definition: LoopPass.cpp:102
llvm::LoopPass::preparePassManager
void preparePassManager(PMStack &PMS) override
Check if available pass managers are suitable for this pass or not.
Definition: LoopPass.cpp:315
PrintPasses.h
llvm::Loop::getName
StringRef getName() const
Definition: LoopInfo.h:869
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::erase_value
void erase_value(Container &C, ValueType V)
Wrapper function to remove a value from a container:
Definition: STLExtras.h:1803
X
static GCMetadataPrinterRegistry::Add< ErlangGCPrinter > X("erlang", "erlang-compatible garbage collector")
llvm::StringMap
StringMap - This is an unconventional map that is specialized for handling keys that are "strings",...
Definition: StringMap.h:110
LoopInfo.h
llvm::PMStack::empty
bool empty() const
Definition: LegacyPassManagers.h:145
llvm::LPPassManager::getAsPass
Pass * getAsPass() override
Definition: LoopPass.h:92
Timer.h
llvm::ON_LOOP_MSG
@ ON_LOOP_MSG
Definition: LegacyPassManagers.h:103
llvm::RISCVFenceField::O
@ O
Definition: RISCVBaseInfo.h:239
llvm::PMDataManager::getTopLevelManager
PMTopLevelManager * getTopLevelManager()
Definition: LegacyPassManagers.h:361
uint64_t
llvm::LoopPass
Definition: LoopPass.h:28
llvm::LoopPass::assignPassManager
void assignPassManager(PMStack &PMS, PassManagerType PMT) override
Assign pass manager to manage this pass.
Definition: LoopPass.cpp:331
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:58
llvm::PMDataManager::removeDeadPasses
void removeDeadPasses(Pass *P, StringRef Msg, enum PassDebuggingString)
Remove dead passes used by P.
Definition: LegacyPassManager.cpp:968
llvm::LCSSAVerificationPass
Definition: LoopPass.h:124
llvm::isFunctionInPrintList
bool isFunctionInPrintList(StringRef FunctionName)
Definition: PrintPasses.cpp:83
llvm::PMDataManager::preserveHigherLevelAnalysis
bool preserveHigherLevelAnalysis(Pass *P)
Definition: LegacyPassManager.cpp:888
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::PMDataManager::dumpRequiredSet
void dumpRequiredSet(const Pass *P) const
Definition: LegacyPassManager.cpp:1219
llvm::Module
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:65
llvm::initializeLCSSAVerificationPassPass
void initializeLCSSAVerificationPassPass(PassRegistry &)
llvm::Pass::mustPreserveAnalysisID
bool mustPreserveAnalysisID(char &AID) const
mustPreserveAnalysisID - This method serves the same function as getAnalysisIfAvailable,...
Definition: Pass.cpp:68
llvm::PMT_LoopPassManager
@ PMT_LoopPassManager
LPPassManager.
Definition: Pass.h:57
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:58
llvm::Pass::getPassName
virtual StringRef getPassName() const
getPassName - Return a nice clean name for a pass.
Definition: Pass.cpp:80
LoopPass.h
llvm_unreachable
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition: ErrorHandling.h:143
llvm::LoopBase::isOutermost
bool isOutermost() const
Return true if the loop does not have a parent (natural) loop.
Definition: LoopInfo.h:168
llvm::EXECUTION_MSG
@ EXECUTION_MSG
Definition: LegacyPassManagers.h:97
llvm::PMDataManager::getPassManagerType
virtual PassManagerType getPassManagerType() const
Definition: LegacyPassManagers.h:380
llvm::Value::getName
StringRef getName() const
Return a constant reference to the value's name.
Definition: Value.cpp:305
llvm::PMStack::pop
void pop()
Definition: LegacyPassManager.cpp:1682
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:1632
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::PMStack
PMStack - This class implements a stack data structure of PMDataManager pointers.
Definition: LegacyPassManagers.h:136
llvm::AnalysisUsage::setPreservesAll
void setPreservesAll()
Set by analyses that do not transform their input at all.
Definition: PassAnalysisSupport.h:130
llvm::PMDataManager::add
void add(Pass *P, bool ProcessAnalysis=true)
Add pass P into the PassVector.
Definition: LegacyPassManager.cpp:1019
llvm::LPPassManager::markLoopAsDeleted
void markLoopAsDeleted(Loop &L)
Definition: LoopPass.cpp:110
llvm::LoopBase::getHeader
BlockT * getHeader() const
Definition: LoopInfo.h:104
llvm::PMDataManager::TPM
PMTopLevelManager * TPM
Definition: LegacyPassManagers.h:419
llvm::Loop::isRecursivelyLCSSAForm
bool isRecursivelyLCSSAForm(const DominatorTree &DT, const LoopInfo &LI) const
Return true if this Loop and all inner subloops are in LCSSA form.
Definition: LoopInfo.cpp:465
llvm::PMTopLevelManager::addIndirectPassManager
void addIndirectPassManager(PMDataManager *Manager)
Definition: LegacyPassManagers.h:210
llvm::LPPassManager::runOnFunction
bool runOnFunction(Function &F) override
run - Execute all of the passes scheduled for execution.
Definition: LoopPass.cpp:128
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
llvm::raw_ostream::indent
raw_ostream & indent(unsigned NumSpaces)
indent - Insert 'NumSpaces' spaces.
Definition: raw_ostream.cpp:496
Dominators.h
getDescription
static std::string getDescription(const Loop &L)
Definition: LoopPass.cpp:366
llvm::PMTopLevelManager
PMTopLevelManager manages LastUser info and collects common APIs used by top level pass managers.
Definition: LegacyPassManagers.h:158
llvm::FunctionPass
FunctionPass class - This class is used to implement most global optimizations.
Definition: Pass.h:308
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:87
LLVMContext.h
raw_ostream.h
llvm::PMDataManager::populateInheritedAnalysis
void populateInheritedAnalysis(PMStack &PMS)
Definition: LegacyPassManagers.h:390
llvm::OptPassGate::shouldRunPass
virtual bool shouldRunPass(const Pass *P, StringRef IRDescription)
IRDescription is a textual description of the IR unit the pass is running over.
Definition: OptBisect.h:33
InitializePasses.h
TimeProfiler.h
Debug.h
llvm::Intrinsic::ID
unsigned ID
Definition: TargetTransformInfo.h:37