LLVM  10.0.0svn
LoopPassManager.cpp
Go to the documentation of this file.
1 //===- LoopPassManager.cpp - Loop pass management -------------------------===//
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 
10 #include "llvm/Analysis/LoopInfo.h"
11 
12 using namespace llvm;
13 
14 // Explicit template instantiations and specialization defininitions for core
15 // template typedefs.
16 namespace llvm {
17 template class PassManager<Loop, LoopAnalysisManager,
19 
20 /// Explicitly specialize the pass manager's run method to handle loop nest
21 /// structure updates.
22 template <>
24 PassManager<Loop, LoopAnalysisManager, LoopStandardAnalysisResults &,
25  LPMUpdater &>::run(Loop &L, LoopAnalysisManager &AM,
26  LoopStandardAnalysisResults &AR, LPMUpdater &U) {
28 
29  if (DebugLogging)
30  dbgs() << "Starting Loop pass manager run.\n";
31 
32  // Request PassInstrumentation from analysis manager, will use it to run
33  // instrumenting callbacks for the passes later.
35  for (auto &Pass : Passes) {
36  if (DebugLogging)
37  dbgs() << "Running pass: " << Pass->name() << " on " << L;
38 
39  // Check the PassInstrumentation's BeforePass callbacks before running the
40  // pass, skip its execution completely if asked to (callback returns false).
41  if (!PI.runBeforePass<Loop>(*Pass, L))
42  continue;
43 
44  PreservedAnalyses PassPA = Pass->run(L, AM, AR, U);
45 
46  // do not pass deleted Loop into the instrumentation
47  if (U.skipCurrentLoop())
48  PI.runAfterPassInvalidated<Loop>(*Pass);
49  else
50  PI.runAfterPass<Loop>(*Pass, L);
51 
52  // If the loop was deleted, abort the run and return to the outer walk.
53  if (U.skipCurrentLoop()) {
54  PA.intersect(std::move(PassPA));
55  break;
56  }
57 
58 #ifndef NDEBUG
59  // Verify the loop structure and LCSSA form before visiting the loop.
60  L.verifyLoop();
61  assert(L.isRecursivelyLCSSAForm(AR.DT, AR.LI) &&
62  "Loops must remain in LCSSA form!");
63 #endif
64 
65  // Update the analysis manager as each pass runs and potentially
66  // invalidates analyses.
67  AM.invalidate(L, PassPA);
68 
69  // Finally, we intersect the final preserved analyses to compute the
70  // aggregate preserved set for this pass manager.
71  PA.intersect(std::move(PassPA));
72 
73  // FIXME: Historically, the pass managers all called the LLVM context's
74  // yield function here. We don't have a generic way to acquire the
75  // context and it isn't yet clear what the right pattern is for yielding
76  // in the new pass manager so it is currently omitted.
77  // ...getContext().yield();
78  }
79 
80  // Invalidation for the current loop should be handled above, and other loop
81  // analysis results shouldn't be impacted by runs over this loop. Therefore,
82  // the remaining analysis results in the AnalysisManager are preserved. We
83  // mark this with a set so that we don't need to inspect each one
84  // individually.
85  // FIXME: This isn't correct! This loop and all nested loops' analyses should
86  // be preserved, but unrolling should invalidate the parent loop's analyses.
88 
89  if (DebugLogging)
90  dbgs() << "Finished Loop pass manager run.\n";
91 
92  return PA;
93 }
94 }
95 
97 PrintLoopPass::PrintLoopPass(raw_ostream &OS, const std::string &Banner)
98  : OS(OS), Banner(Banner) {}
99 
102  LPMUpdater &) {
103  printLoop(L, OS, Banner);
104  return PreservedAnalyses::all();
105 }
Pass interface - Implemented by all &#39;passes&#39;.
Definition: Pass.h:80
PassT::Result & getResult(IRUnitT &IR, ExtraArgTs... ExtraArgs)
Get the result of an analysis pass for a given IR unit.
Definition: PassManager.h:776
This class represents lattice values for constants.
Definition: AllocatorList.h:23
This header provides classes for managing a pipeline of passes over loops in LLVM IR...
void intersect(const PreservedAnalyses &Arg)
Intersect this set with another in place.
Definition: PassManager.h:225
The adaptor from a function pass to a loop pass computes these analyses and makes them available to t...
bool skipCurrentLoop() const
This can be queried by loop passes which run other loop passes (like pass managers) to know whether t...
bool runBeforePass(const PassT &Pass, const IRUnitT &IR) const
BeforePass instrumentation point - takes Pass instance to be executed and constant reference to IR it...
AnalysisManager< Loop, LoopStandardAnalysisResults & > LoopAnalysisManager
The loop analysis manager.
A set of analyses that are preserved following a run of a transformation pass.
Definition: PassManager.h:153
static PreservedAnalyses all()
Construct a special preserved set that preserves all passes.
Definition: PassManager.h:159
Pseudo-analysis pass that exposes the PassInstrumentation to pass managers.
Definition: PassManager.h:581
This class provides an interface for updating the loop pass manager based on mutations to the loop ne...
print lazy value Lazy Value Info Printer Pass
void runAfterPass(const PassT &Pass, const IRUnitT &IR) const
AfterPass instrumentation point - takes Pass instance that has just been executed and constant refere...
void runAfterPassInvalidated(const PassT &Pass) const
AfterPassInvalidated instrumentation point - takes Pass instance that has just been executed...
void invalidate(IRUnitT &IR)
Invalidate a specific analysis pass for an IR module.
Definition: PassManager.h:848
PreservedAnalyses run(Loop &L, LoopAnalysisManager &, LoopStandardAnalysisResults &, LPMUpdater &)
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:132
Manages a sequence of passes over a particular unit of IR.
Definition: PassManager.h:464
Represents a single loop in the control flow graph.
Definition: LoopInfo.h:509
void preserveSet()
Mark an analysis set as preserved.
Definition: PassManager.h:189
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This templated class represents "all analyses that operate over <a particular IR unit>" (e...
Definition: PassManager.h:91
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:45
A container for analyses that lazily runs them and caches their results.
This class provides instrumentation entry points for the Pass Manager, doing calls to callbacks regis...
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:932