LLVM  9.0.0svn
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"
17 #include "llvm/IR/Dominators.h"
19 #include "llvm/IR/LLVMContext.h"
20 #include "llvm/IR/OptBisect.h"
21 #include "llvm/IR/PassManager.h"
22 #include "llvm/IR/PassTimingInfo.h"
23 #include "llvm/Support/Debug.h"
24 #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 
72  LI = nullptr;
73  CurrentLoop = nullptr;
74 }
75 
76 // Insert loop into loop nest (LoopInfo) and loop queue (LQ).
78  if (!L.getParentLoop()) {
79  // This is the top level loop.
80  LQ.push_front(&L);
81  return;
82  }
83 
84  // Insert L into the loop queue after the parent loop.
85  for (auto I = LQ.begin(), E = LQ.end(); I != E; ++I) {
86  if (*I == L.getParentLoop()) {
87  // deque does not support insert after.
88  ++I;
89  LQ.insert(I, 1, &L);
90  return;
91  }
92  }
93 }
94 
95 /// cloneBasicBlockSimpleAnalysis - Invoke cloneBasicBlockAnalysis hook for
96 /// all loop passes.
98  BasicBlock *To, Loop *L) {
99  for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) {
101  LP->cloneBasicBlockAnalysis(From, To, L);
102  }
103 }
104 
105 /// deleteSimpleAnalysisValue - Invoke deleteAnalysisValue hook for all passes.
107  if (BasicBlock *BB = dyn_cast<BasicBlock>(V)) {
108  for (Instruction &I : *BB) {
110  }
111  }
112  for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) {
114  LP->deleteAnalysisValue(V, L);
115  }
116 }
117 
118 /// Invoke deleteAnalysisLoop hook for all passes.
120  for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) {
122  LP->deleteAnalysisLoop(L);
123  }
124 }
125 
126 
127 // Recurse through all subloops and all loops into LQ.
128 static void addLoopIntoQueue(Loop *L, std::deque<Loop *> &LQ) {
129  LQ.push_back(L);
130  for (Loop *I : reverse(*L))
131  addLoopIntoQueue(I, LQ);
132 }
133 
134 /// Pass Manager itself does not invalidate any analysis info.
136  // LPPassManager needs LoopInfo. In the long term LoopInfo class will
137  // become part of LPPassManager.
140  Info.setPreservesAll();
141 }
142 
144  assert((&L == CurrentLoop || CurrentLoop->contains(&L)) &&
145  "Must not delete loop outside the current loop tree!");
146  // If this loop appears elsewhere within the queue, we also need to remove it
147  // there. However, we have to be careful to not remove the back of the queue
148  // as that is assumed to match the current loop.
149  assert(LQ.back() == CurrentLoop && "Loop queue back isn't the current loop!");
150  LQ.erase(std::remove(LQ.begin(), LQ.end(), &L), LQ.end());
151 
152  if (&L == CurrentLoop) {
153  CurrentLoopDeleted = true;
154  // Add this loop back onto the back of the queue to preserve our invariants.
155  LQ.push_back(&L);
156  }
157 }
158 
159 /// run - Execute all of the passes scheduled for execution. Keep track of
160 /// whether any of the passes modifies the function, and if so, return true.
162  auto &LIWP = getAnalysis<LoopInfoWrapperPass>();
163  LI = &LIWP.getLoopInfo();
164  Module &M = *F.getParent();
165 #if 0
166  DominatorTree *DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
167 #endif
168  bool Changed = false;
169 
170  // Collect inherited analysis from Module level pass manager.
172 
173  // Populate the loop queue in reverse program order. There is no clear need to
174  // process sibling loops in either forward or reverse order. There may be some
175  // advantage in deleting uses in a later loop before optimizing the
176  // definitions in an earlier loop. If we find a clear reason to process in
177  // forward order, then a forward variant of LoopPassManager should be created.
178  //
179  // Note that LoopInfo::iterator visits loops in reverse program
180  // order. Here, reverse_iterator gives us a forward order, and the LoopQueue
181  // reverses the order a third time by popping from the back.
182  for (Loop *L : reverse(*LI))
183  addLoopIntoQueue(L, LQ);
184 
185  if (LQ.empty()) // No loops, skip calling finalizers
186  return false;
187 
188  // Initialization
189  for (Loop *L : LQ) {
190  for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) {
192  Changed |= P->doInitialization(L, *this);
193  }
194  }
195 
196  // Walk Loops
197  unsigned InstrCount, FunctionSize = 0;
198  StringMap<std::pair<unsigned, unsigned>> FunctionToInstrCount;
199  bool EmitICRemark = M.shouldEmitInstrCountChangedRemark();
200  // Collect the initial size of the module and the function we're looking at.
201  if (EmitICRemark) {
202  InstrCount = initSizeRemarkInfo(M, FunctionToInstrCount);
203  FunctionSize = F.getInstructionCount();
204  }
205  while (!LQ.empty()) {
206  CurrentLoopDeleted = false;
207  CurrentLoop = LQ.back();
208 
209  // Run all passes on the current Loop.
210  for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) {
212 
213  llvm::TimeTraceScope LoopPassScope("RunLoopPass", P->getPassName());
214 
216  CurrentLoop->getHeader()->getName());
217  dumpRequiredSet(P);
218 
220 
221  bool LocalChanged = false;
222  {
223  PassManagerPrettyStackEntry X(P, *CurrentLoop->getHeader());
224  TimeRegion PassTimer(getPassTimer(P));
225  LocalChanged = P->runOnLoop(CurrentLoop, *this);
226  Changed |= LocalChanged;
227  if (EmitICRemark) {
228  unsigned NewSize = F.getInstructionCount();
229  // Update the size of the function, emit a remark, and update the
230  // size of the module.
231  if (NewSize != FunctionSize) {
232  int64_t Delta = static_cast<int64_t>(NewSize) -
233  static_cast<int64_t>(FunctionSize);
234  emitInstrCountChangedRemark(P, M, Delta, InstrCount,
235  FunctionToInstrCount, &F);
236  InstrCount = static_cast<int64_t>(InstrCount) + Delta;
237  FunctionSize = NewSize;
238  }
239  }
240  }
241 
242  if (LocalChanged)
244  CurrentLoopDeleted ? "<deleted loop>"
245  : CurrentLoop->getName());
246  dumpPreservedSet(P);
247 
248  if (CurrentLoopDeleted) {
249  // Notify passes that the loop is being deleted.
250  deleteSimpleAnalysisLoop(CurrentLoop);
251  } else {
252  // Manually check that this loop is still healthy. This is done
253  // instead of relying on LoopInfo::verifyLoop since LoopInfo
254  // is a function pass and it's really expensive to verify every
255  // loop in the function every time. That level of checking can be
256  // enabled with the -verify-loop-info option.
257  {
258  TimeRegion PassTimer(getPassTimer(&LIWP));
259  CurrentLoop->verifyLoop();
260  }
261  // Here we apply same reasoning as in the above case. Only difference
262  // is that LPPassManager might run passes which do not require LCSSA
263  // form (LoopPassPrinter for example). We should skip verification for
264  // such passes.
265  // FIXME: Loop-sink currently break LCSSA. Fix it and reenable the
266  // verification!
267 #if 0
269  assert(CurrentLoop->isRecursivelyLCSSAForm(*DT, *LI));
270 #endif
271 
272  // Then call the regular verifyAnalysis functions.
274 
275  F.getContext().yield();
276  }
277 
281  CurrentLoopDeleted ? "<deleted>"
282  : CurrentLoop->getHeader()->getName(),
283  ON_LOOP_MSG);
284 
285  if (CurrentLoopDeleted)
286  // Do not run other passes on this loop.
287  break;
288  }
289 
290  // If the loop was deleted, release all the loop passes. This frees up
291  // some memory, and avoids trouble with the pass manager trying to call
292  // verifyAnalysis on them.
293  if (CurrentLoopDeleted) {
294  for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) {
296  freePass(P, "<deleted>", ON_LOOP_MSG);
297  }
298  }
299 
300  // Pop the loop from queue after running all passes.
301  LQ.pop_back();
302  }
303 
304  // Finalization
305  for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) {
307  Changed |= P->doFinalization();
308  }
309 
310  return Changed;
311 }
312 
313 /// Print passes managed by this manager
315  errs().indent(Offset*2) << "Loop Pass Manager\n";
316  for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) {
318  P->dumpPassStructure(Offset + 1);
319  dumpLastUses(P, Offset+1);
320  }
321 }
322 
323 
324 //===----------------------------------------------------------------------===//
325 // LoopPass
326 
328  const std::string &Banner) const {
329  return new PrintLoopPassWrapper(O, Banner);
330 }
331 
332 // Check if this pass is suitable for the current LPPassManager, if
333 // available. This pass P is not suitable for a LPPassManager if P
334 // is not preserving higher level analysis info used by other
335 // LPPassManager passes. In such case, pop LPPassManager from the
336 // stack. This will force assignPassManager() to create new
337 // LPPassManger as expected.
339 
340  // Find LPPassManager
341  while (!PMS.empty() &&
343  PMS.pop();
344 
345  // If this pass is destroying high level information that is used
346  // by other passes that are managed by LPM then do not insert
347  // this pass in current LPM. Use new LPPassManager.
348  if (PMS.top()->getPassManagerType() == PMT_LoopPassManager &&
349  !PMS.top()->preserveHigherLevelAnalysis(this))
350  PMS.pop();
351 }
352 
353 /// Assign pass manager to manage this pass.
355  PassManagerType PreferredType) {
356  // Find LPPassManager
357  while (!PMS.empty() &&
359  PMS.pop();
360 
361  LPPassManager *LPPM;
363  LPPM = (LPPassManager*)PMS.top();
364  else {
365  // Create new Loop Pass Manager if it does not exist.
366  assert (!PMS.empty() && "Unable to create Loop Pass Manager");
367  PMDataManager *PMD = PMS.top();
368 
369  // [1] Create new Loop Pass Manager
370  LPPM = new LPPassManager();
371  LPPM->populateInheritedAnalysis(PMS);
372 
373  // [2] Set up new manager's top level manager
374  PMTopLevelManager *TPM = PMD->getTopLevelManager();
375  TPM->addIndirectPassManager(LPPM);
376 
377  // [3] Assign manager to manage this new manager. This may create
378  // and push new managers into PMS
379  Pass *P = LPPM->getAsPass();
380  TPM->schedulePass(P);
381 
382  // [4] Push new manager into PMS
383  PMS.push(LPPM);
384  }
385 
386  LPPM->add(this);
387 }
388 
389 static std::string getDescription(const Loop &L) {
390  return "loop";
391 }
392 
393 bool LoopPass::skipLoop(const Loop *L) const {
394  const Function *F = L->getHeader()->getParent();
395  if (!F)
396  return false;
397  // Check the opt bisect limit.
398  OptPassGate &Gate = F->getContext().getOptPassGate();
399  if (Gate.isEnabled() && !Gate.shouldRunPass(this, getDescription(*L)))
400  return true;
401  // Check for the OptimizeNone attribute.
402  if (F->hasOptNone()) {
403  // FIXME: Report this to dbgs() only once per function.
404  LLVM_DEBUG(dbgs() << "Skipping pass '" << getPassName() << "' in function "
405  << F->getName() << "\n");
406  // FIXME: Delete loop from pass manager's queue?
407  return true;
408  }
409  return false;
410 }
411 
413 INITIALIZE_PASS(LCSSAVerificationPass, "lcssa-verification", "LCSSA Verifier",
414  false, false)
PMTopLevelManager * TPM
Pass interface - Implemented by all &#39;passes&#39;.
Definition: Pass.h:80
bool preserveHigherLevelAnalysis(Pass *P)
PassManagerType
Different types of internal pass managers.
Definition: Pass.h:53
static GCMetadataPrinterRegistry::Add< ErlangGCPrinter > X("erlang", "erlang-compatible garbage collector")
raw_ostream & errs()
This returns a reference to a raw_ostream for standard error.
This class represents lattice values for constants.
Definition: AllocatorList.h:23
bool hasOptNone() const
Do not optimize this function (-O0).
Definition: Function.h:608
virtual void dumpPassStructure(unsigned Offset=0)
Definition: Pass.cpp:72
void dumpLastUses(Pass *P, unsigned Offset) const
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:65
Extensions to this class implement mechanisms to disable passes and individual optimizations at compi...
Definition: OptBisect.h:25
std::error_code remove(const Twine &path, bool IgnoreNonExisting=true)
Remove path.
unsigned getInstructionCount() const
Returns the number of non-debug IR instructions in this function.
Definition: Function.cpp:209
bool isRecursivelyLCSSAForm(DominatorTree &DT, const LoopInfo &LI) const
Return true if this Loop and all inner subloops are in LCSSA form.
Definition: LoopInfo.cpp:416
virtual void deleteAnalysisLoop(Loop *L)
Delete analysis info associated with Loop L.
Definition: LoopPass.h:87
The TimeTraceScope is a helper class to call the begin and end functions of the time trace profiler...
Definition: TimeProfiler.h:52
raw_ostream & indent(unsigned NumSpaces)
indent - Insert &#39;NumSpaces&#39; spaces.
StringRef getPassName() const override
getPassName - Return a nice clean name for a pass.
Definition: LoopPass.h:109
void assignPassManager(PMStack &PMS, PassManagerType PMT) override
Assign pass manager to manage this pass.
Definition: LoopPass.cpp:354
F(f)
void yield()
Calls the yield callback (if applicable).
static unsigned InstrCount
void dumpPassInfo(Pass *P, enum PassDebuggingString S1, enum PassDebuggingString S2, StringRef Msg)
virtual StringRef getPassName() const
getPassName - Return a nice clean name for a pass.
Definition: Pass.cpp:79
bool mustPreserveAnalysisID(char &AID) const
mustPreserveAnalysisID - This method serves the same function as getAnalysisIfAvailable, but works if you just have an AnalysisID.
Definition: Pass.cpp:67
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:31
PMTopLevelManager manages LastUser info and collects common APIs used by top level pass managers...
Timer * getPassTimer(Pass *)
Request the timer for this legacy-pass-manager&#39;s pass instance.
static void addLoopIntoQueue(Loop *L, std::deque< Loop *> &LQ)
Definition: LoopPass.cpp:128
The TimeRegion class is used as a helper class to call the startTimer() and stopTimer() methods of th...
Definition: Timer.h:140
void schedulePass(Pass *P)
Schedule pass P for execution.
AnalysisUsage & addRequired()
void freePass(Pass *P, StringRef Msg, enum PassDebuggingString)
Remove P.
void deleteSimpleAnalysisLoop(Loop *L)
Invoke deleteAnalysisLoop hook for all passes that implement simple analysis interface.
Definition: LoopPass.cpp:119
void verifyPreservedAnalysis(Pass *P)
verifyPreservedAnalysis – Verify analysis presreved by pass P.
void populateInheritedAnalysis(PMStack &PMS)
This header defines classes/functions to handle pass execution timing information with interfaces for...
PMStack - This class implements a stack data structure of PMDataManager pointers. ...
void initializeAnalysisImpl(Pass *P)
All Required analyses should be available to the pass as it runs! Here we fill in the AnalysisImpls m...
virtual bool isEnabled() const
isEnabled should return true before calling shouldRunPass
Definition: OptBisect.h:36
PassManagerPrettyStackEntry - This is used to print informative information about what pass is runnin...
BlockT * getHeader() const
Definition: LoopInfo.h:102
auto reverse(ContainerTy &&C, typename std::enable_if< has_rbegin< ContainerTy >::value >::type *=nullptr) -> decltype(make_range(C.rbegin(), C.rend()))
Definition: STLExtras.h:273
OptPassGate & getOptPassGate() const
Access the object which can disable optional passes and individual optimizations at compile time...
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:327
void add(Pass *P, bool ProcessAnalysis=true)
Add pass P into the PassVector.
This header provides classes for managing per-loop analyses.
Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree...
Definition: Dominators.h:144
Analysis containing CSE Info
Definition: CSEInfo.cpp:20
virtual bool doInitialization(Loop *L, LPPassManager &LPM)
Definition: LoopPass.h:45
#define P(N)
LLVM Basic Block Representation.
Definition: BasicBlock.h:57
static std::string getDescription(const Loop &L)
Definition: LoopPass.cpp:389
virtual bool doFinalization()
Definition: LoopPass.h:51
bool shouldEmitInstrCountChangedRemark()
Return true if size-info optimization remark is enabled, false otherwise.
Definition: Module.h:263
void addIndirectPassManager(PMDataManager *Manager)
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
virtual PassManagerType getPassManagerType() const
void getAnalysisUsage(AnalysisUsage &Info) const override
Pass Manager itself does not invalidate any analysis info.
Definition: LoopPass.cpp:135
Represent the analysis usage information of a pass.
FunctionPass class - This class is used to implement most global optimizations.
Definition: Pass.h:284
auto find_if(R &&Range, UnaryPredicate P) -> decltype(adl_begin(Range))
Provide wrappers to std::find_if which take ranges instead of having to pass begin/end explicitly...
Definition: STLExtras.h:1220
LLVMContext & getContext() const
getContext - Return a reference to the LLVMContext associated with this function. ...
Definition: Function.cpp:205
static char ID
Definition: LoopPass.h:98
#define INITIALIZE_PASS(passName, arg, name, cfg, analysis)
Definition: PassSupport.h:33
bool skipLoop(const Loop *L) const
Optional passes call this function to check whether the pass should be skipped.
Definition: LoopPass.cpp:393
void deleteSimpleAnalysisValue(Value *V, Loop *L)
deleteSimpleAnalysisValue - Invoke deleteAnalysisValue hook for all passes that implement simple anal...
Definition: LoopPass.cpp:106
bool contains(const LoopT *L) const
Return true if the specified loop is contained within in this loop.
Definition: LoopInfo.h:112
LPPassManager.
Definition: Pass.h:58
BlockVerifier::State From
void recordAvailableAnalysis(Pass *P)
Augment AvailableAnalysis by adding analysis made available by pass P.
void dumpRequiredSet(const Pass *P) const
void removeNotPreservedAnalysis(Pass *P)
Remove Analysis that is not preserved by the pass.
unsigned initSizeRemarkInfo(Module &M, StringMap< std::pair< unsigned, unsigned >> &FunctionToInstrCount)
Set the initial size of the module if the user has specified that they want remarks for size...
void removeDeadPasses(Pass *P, StringRef Msg, enum PassDebuggingString)
Remove dead passes used by P.
This file declares the interface for bisecting optimizations.
void markLoopAsDeleted(Loop &L)
Definition: LoopPass.cpp:143
bool isFunctionInPrintList(StringRef FunctionName)
isFunctionInPrintList - returns true if a function should be printed via
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:132
StringMap - This is an unconventional map that is specialized for handling keys that are "strings"...
Definition: StringMap.h:219
void setPreservesAll()
Set by analyses that do not transform their input at all.
void dumpPassStructure(unsigned Offset) override
Print passes managed by this manager.
Definition: LoopPass.cpp:314
void preparePassManager(PMStack &PMS) override
Check if available pass managers are suitable for this pass or not.
Definition: LoopPass.cpp:338
virtual bool runOnLoop(Loop *L, LPPassManager &LPM)=0
LoopT * getParentLoop() const
Definition: LoopInfo.h:103
StringRef getName() const
Definition: LoopInfo.h:757
void cloneBasicBlockSimpleAnalysis(BasicBlock *From, BasicBlock *To, Loop *L)
SimpleAnalysis - Provides simple interface to update analysis info maintained by various passes...
Definition: LoopPass.cpp:97
Represents a single loop in the control flow graph.
Definition: LoopInfo.h:467
StringRef getName() const
Return a constant reference to the value&#39;s name.
Definition: Value.cpp:214
const Function * getParent() const
Return the enclosing method, or null if none.
Definition: BasicBlock.h:106
#define I(x, y, z)
Definition: MD5.cpp:58
void addLoop(Loop &L)
Definition: LoopPass.cpp:77
LoopPass * getContainedPass(unsigned N)
Definition: LoopPass.h:117
void push(PMDataManager *PM)
PMDataManager provides the common place to manage the analysis data used by pass managers.
This file defines passes to print out IR in various granularities.
virtual void cloneBasicBlockAnalysis(BasicBlock *F, BasicBlock *T, Loop *L)
SimpleAnalysis - Provides simple interface to update analysis info maintained by various passes...
Definition: LoopPass.h:79
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
PMDataManager * top() const
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:575
LLVM Value Representation.
Definition: Value.h:72
virtual void deleteAnalysisValue(Value *V, Loop *L)
deleteAnalysisValue - Delete analysis info associated with value V.
Definition: LoopPass.h:82
bool runOnFunction(Function &F) override
run - Execute all of the passes scheduled for execution.
Definition: LoopPass.cpp:161
unsigned getNumContainedPasses() const
bool empty() const
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:45
The legacy pass manager&#39;s analysis pass to compute loop information.
Definition: LoopInfo.h:1138
void verifyLoop() const
Verify loop structure.
Definition: LoopInfoImpl.h:294
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:48
Pass * getAsPass() override
Definition: LoopPass.h:112
Legacy analysis pass which computes a DominatorTree.
Definition: Dominators.h:259
This header defines various interfaces for pass management in LLVM.
#define LLVM_DEBUG(X)
Definition: Debug.h:122
iterator_range< block_iterator > blocks() const
Definition: LoopInfo.h:158
void printLoop(Loop &L, raw_ostream &OS, const std::string &Banner="")
Function to print a loop&#39;s contents as LLVM&#39;s text IR assembly.
Definition: LoopInfo.cpp:894
void dumpPreservedSet(const Pass *P) const
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.