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/Module.h"
20#include "llvm/IR/OptBisect.h"
21#include "llvm/IR/PassTimingInfo.h"
22#include "llvm/IR/PrintPasses.h"
23#include "llvm/InitializePasses.h"
24#include "llvm/Support/Debug.h"
25#include "llvm/Support/TimeProfiler.h"
26#include "llvm/Support/Timer.h"
27#include "llvm/Support/raw_ostream.h"
28using namespace llvm;
29
30#define DEBUG_TYPE "loop-pass-manager"
31
32namespace {
33
34bool shouldPrintLoop(const Loop &L) {
35 Function *F = L.getHeader()->getParent();
36 bool SourceLocFilterEmpty = isSourceLocFilterEmpty();
37 if (!isFunctionInPrintList(FunctionName: F->getName()))
38 return false;
39
40 if (SourceLocFilterEmpty)
41 return true;
42
43 for (const BasicBlock *BB : L.blocks())
44 for (const Instruction &I : *BB)
45 if (isSourceLocInPrintList(Loc: I.getDebugLoc()))
46 return true;
47 return false;
48}
49
50/// PrintLoopPass - Print a Function corresponding to a Loop.
51///
52class PrintLoopPassWrapper : public LoopPass {
53 raw_ostream &OS;
54 std::string Banner;
55
56public:
57 static char ID;
58 PrintLoopPassWrapper() : LoopPass(ID), OS(dbgs()) {}
59 PrintLoopPassWrapper(raw_ostream &OS, const std::string &Banner)
60 : LoopPass(ID), OS(OS), Banner(Banner) {}
61
62 void getAnalysisUsage(AnalysisUsage &AU) const override {
63 AU.setPreservesAll();
64 }
65
66 bool runOnLoop(Loop *L, LPPassManager &) override {
67 if (shouldPrintLoop(L: *L))
68 printLoop(L: *L, OS, Banner);
69 return false;
70 }
71
72 StringRef getPassName() const override { return "Print Loop IR"; }
73};
74
75char PrintLoopPassWrapper::ID = 0;
76} // namespace
77
78//===----------------------------------------------------------------------===//
79// LPPassManager
80//
81
82char LPPassManager::ID = 0;
83
84LPPassManager::LPPassManager() : FunctionPass(ID) {
85 LI = nullptr;
86 CurrentLoop = nullptr;
87}
88
89// Insert loop into loop nest (LoopInfo) and loop queue (LQ).
90void LPPassManager::addLoop(Loop &L) {
91 if (L.isOutermost()) {
92 // This is the top level loop.
93 LQ.push_front(x: &L);
94 return;
95 }
96
97 // Insert L into the loop queue after the parent loop.
98 for (auto I = LQ.begin(), E = LQ.end(); I != E; ++I) {
99 if (*I == L.getParentLoop()) {
100 // deque does not support insert after.
101 ++I;
102 LQ.insert(position: I, n: 1, x: &L);
103 return;
104 }
105 }
106}
107
108// Recurse through all subloops and all loops into LQ.
109static void addLoopIntoQueue(Loop *L, std::deque<Loop *> &LQ) {
110 LQ.push_back(x: L);
111 for (Loop *I : reverse(C&: *L))
112 addLoopIntoQueue(L: I, LQ);
113}
114
115/// Pass Manager itself does not invalidate any analysis info.
116void LPPassManager::getAnalysisUsage(AnalysisUsage &Info) const {
117 // LPPassManager needs LoopInfo. In the long term LoopInfo class will
118 // become part of LPPassManager.
119 Info.addRequired<LoopInfoWrapperPass>();
120 Info.addRequired<DominatorTreeWrapperPass>();
121 Info.setPreservesAll();
122}
123
124void LPPassManager::markLoopAsDeleted(Loop &L) {
125 assert((&L == CurrentLoop || CurrentLoop->contains(&L)) &&
126 "Must not delete loop outside the current loop tree!");
127 // If this loop appears elsewhere within the queue, we also need to remove it
128 // there. However, we have to be careful to not remove the back of the queue
129 // as that is assumed to match the current loop.
130 assert(LQ.back() == CurrentLoop && "Loop queue back isn't the current loop!");
131 llvm::erase(C&: LQ, V: &L);
132
133 if (&L == CurrentLoop) {
134 CurrentLoopDeleted = true;
135 // Add this loop back onto the back of the queue to preserve our invariants.
136 LQ.push_back(x: &L);
137 }
138}
139
140/// run - Execute all of the passes scheduled for execution. Keep track of
141/// whether any of the passes modifies the function, and if so, return true.
142bool LPPassManager::runOnFunction(Function &F) {
143 auto &LIWP = getAnalysis<LoopInfoWrapperPass>();
144 LI = &LIWP.getLoopInfo();
145 Module &M = *F.getParent();
146#ifndef NDEBUG
147 DominatorTree *DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
148#endif
149 bool Changed = false;
150
151 // Collect inherited analysis from Module level pass manager.
152 populateInheritedAnalysis(PMS&: TPM->activeStack);
153
154 // Populate the loop queue in reverse program order. There is no clear need to
155 // process sibling loops in either forward or reverse order. There may be some
156 // advantage in deleting uses in a later loop before optimizing the
157 // definitions in an earlier loop. If we find a clear reason to process in
158 // forward order, then a forward variant of LoopPassManager should be created.
159 //
160 // Note that LoopInfo::iterator visits loops in reverse program
161 // order. Here, reverse_iterator gives us a forward order, and the LoopQueue
162 // reverses the order a third time by popping from the back.
163 for (Loop *L : reverse(C&: *LI))
164 addLoopIntoQueue(L, LQ);
165
166 if (LQ.empty()) // No loops, skip calling finalizers
167 return false;
168
169 // Initialization
170 for (Loop *L : LQ) {
171 for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) {
172 LoopPass *P = getContainedPass(N: Index);
173 Changed |= P->doInitialization(L, LPM&: *this);
174 }
175 }
176
177 // Walk Loops
178 unsigned InstrCount, FunctionSize = 0;
179 StringMap<std::pair<unsigned, unsigned>> FunctionToInstrCount;
180 bool EmitICRemark = M.shouldEmitInstrCountChangedRemark();
181 // Collect the initial size of the module and the function we're looking at.
182 if (EmitICRemark) {
183 InstrCount = initSizeRemarkInfo(M, FunctionToInstrCount);
184 FunctionSize = F.getInstructionCount();
185 }
186 while (!LQ.empty()) {
187 CurrentLoopDeleted = false;
188 CurrentLoop = LQ.back();
189
190 // Run all passes on the current Loop.
191 for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) {
192 LoopPass *P = getContainedPass(N: Index);
193
194 llvm::TimeTraceScope LoopPassScope("RunLoopPass", P->getPassName());
195
196 dumpPassInfo(P, S1: EXECUTION_MSG, S2: ON_LOOP_MSG,
197 Msg: CurrentLoop->getHeader()->getName());
198 dumpRequiredSet(P);
199
200 initializeAnalysisImpl(P);
201
202 bool LocalChanged = false;
203 {
204 PassManagerPrettyStackEntry X(P, *CurrentLoop->getHeader());
205 TimeRegion PassTimer(getPassTimer(P));
206#ifdef EXPENSIVE_CHECKS
207 uint64_t RefHash = P->structuralHash(F);
208#endif
209 LocalChanged = P->runOnLoop(L: CurrentLoop, LPM&: *this);
210
211#ifdef EXPENSIVE_CHECKS
212 if (!LocalChanged && (RefHash != P->structuralHash(F))) {
213 llvm::errs() << "Pass modifies its input and doesn't report it: "
214 << P->getPassName() << "\n";
215 llvm_unreachable("Pass modifies its input and doesn't report it");
216 }
217#endif
218
219 Changed |= LocalChanged;
220 if (EmitICRemark) {
221 unsigned NewSize = F.getInstructionCount();
222 // Update the size of the function, emit a remark, and update the
223 // size of the module.
224 if (NewSize != FunctionSize) {
225 int64_t Delta = static_cast<int64_t>(NewSize) -
226 static_cast<int64_t>(FunctionSize);
227 emitInstrCountChangedRemark(P, M, Delta, CountBefore: InstrCount,
228 FunctionToInstrCount, F: &F);
229 InstrCount = static_cast<int64_t>(InstrCount) + Delta;
230 FunctionSize = NewSize;
231 }
232 }
233 }
234
235 if (LocalChanged)
236 dumpPassInfo(P, S1: MODIFICATION_MSG, S2: ON_LOOP_MSG,
237 Msg: CurrentLoopDeleted ? "<deleted loop>"
238 : CurrentLoop->getName());
239 dumpPreservedSet(P);
240
241 if (!CurrentLoopDeleted) {
242 // Manually check that this loop is still healthy. This is done
243 // instead of relying on LoopInfo::verifyLoop since LoopInfo
244 // is a function pass and it's really expensive to verify every
245 // loop in the function every time. That level of checking can be
246 // enabled with the -verify-loop-info option.
247 {
248 TimeRegion PassTimer(getPassTimer(&LIWP));
249 CurrentLoop->verifyLoop();
250 }
251 // Here we apply same reasoning as in the above case. Only difference
252 // is that LPPassManager might run passes which do not require LCSSA
253 // form (LoopPassPrinter for example). We should skip verification for
254 // such passes.
255#ifndef NDEBUG
256 if (mustPreserveAnalysisID(LCSSAVerificationPass::ID))
257 assert(CurrentLoop->isRecursivelyLCSSAForm(*DT, *LI));
258#endif
259
260 // Then call the regular verifyAnalysis functions.
261 verifyPreservedAnalysis(P);
262
263 F.getContext().yield();
264 }
265
266 if (LocalChanged)
267 removeNotPreservedAnalysis(P);
268 recordAvailableAnalysis(P);
269 removeDeadPasses(P,
270 Msg: CurrentLoopDeleted ? "<deleted>"
271 : CurrentLoop->getHeader()->getName(),
272 ON_LOOP_MSG);
273
274 if (CurrentLoopDeleted)
275 // Do not run other passes on this loop.
276 break;
277 }
278
279 // If the loop was deleted, release all the loop passes. This frees up
280 // some memory, and avoids trouble with the pass manager trying to call
281 // verifyAnalysis on them.
282 if (CurrentLoopDeleted) {
283 for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) {
284 Pass *P = getContainedPass(N: Index);
285 freePass(P, Msg: "<deleted>", ON_LOOP_MSG);
286 }
287 }
288
289 // Pop the loop from queue after running all passes.
290 LQ.pop_back();
291 }
292
293 // Finalization
294 for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) {
295 LoopPass *P = getContainedPass(N: Index);
296 Changed |= P->doFinalization();
297 }
298
299 return Changed;
300}
301
302/// Print passes managed by this manager
303void LPPassManager::dumpPassStructure(unsigned Offset) {
304 errs().indent(NumSpaces: Offset*2) << "Loop Pass Manager\n";
305 for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) {
306 Pass *P = getContainedPass(N: Index);
307 P->dumpPassStructure(Offset: Offset + 1);
308 dumpLastUses(P, Offset: Offset+1);
309 }
310}
311
312
313//===----------------------------------------------------------------------===//
314// LoopPass
315
316Pass *LoopPass::createPrinterPass(raw_ostream &O,
317 const std::string &Banner) const {
318 return new PrintLoopPassWrapper(O, Banner);
319}
320
321// Check if this pass is suitable for the current LPPassManager, if
322// available. This pass P is not suitable for a LPPassManager if P
323// is not preserving higher level analysis info used by other
324// LPPassManager passes. In such case, pop LPPassManager from the
325// stack. This will force assignPassManager() to create new
326// LPPassManger as expected.
327void LoopPass::preparePassManager(PMStack &PMS) {
328
329 // Find LPPassManager
330 while (!PMS.empty() &&
331 PMS.top()->getPassManagerType() > PMT_LoopPassManager)
332 PMS.pop();
333
334 // If this pass is destroying high level information that is used
335 // by other passes that are managed by LPM then do not insert
336 // this pass in current LPM. Use new LPPassManager.
337 if (PMS.top()->getPassManagerType() == PMT_LoopPassManager &&
338 !PMS.top()->preserveHigherLevelAnalysis(P: this))
339 PMS.pop();
340}
341
342/// Assign pass manager to manage this pass.
343void LoopPass::assignPassManager(PMStack &PMS,
344 PassManagerType PreferredType) {
345 // Find LPPassManager
346 while (!PMS.empty() &&
347 PMS.top()->getPassManagerType() > PMT_LoopPassManager)
348 PMS.pop();
349
350 LPPassManager *LPPM;
351 if (PMS.top()->getPassManagerType() == PMT_LoopPassManager)
352 LPPM = (LPPassManager*)PMS.top();
353 else {
354 // Create new Loop Pass Manager if it does not exist.
355 assert (!PMS.empty() && "Unable to create Loop Pass Manager");
356 PMDataManager *PMD = PMS.top();
357
358 // [1] Create new Loop Pass Manager
359 LPPM = new LPPassManager();
360 LPPM->populateInheritedAnalysis(PMS);
361
362 // [2] Set up new manager's top level manager
363 PMTopLevelManager *TPM = PMD->getTopLevelManager();
364 TPM->addIndirectPassManager(Manager: LPPM);
365
366 // [3] Assign manager to manage this new manager. This may create
367 // and push new managers into PMS
368 Pass *P = LPPM->getAsPass();
369 TPM->schedulePass(P);
370
371 // [4] Push new manager into PMS
372 PMS.push(PM: LPPM);
373 }
374
375 LPPM->add(P: this);
376}
377
378static std::string getDescription(const Loop &L) {
379 return "loop";
380}
381
382bool LoopPass::skipLoop(const Loop *L) const {
383 const Function *F = L->getHeader()->getParent();
384 if (!F)
385 return false;
386 // Check the opt bisect limit.
387 const OptPassGate &Gate = F->getContext().getOptPassGate();
388 if (Gate.isEnabled() &&
389 !Gate.shouldRunPass(PassName: this->getPassName(), IRDescription: getDescription(L: *L)))
390 return true;
391 // Check for the OptimizeNone attribute.
392 if (F->hasOptNone()) {
393 // FIXME: Report this to dbgs() only once per function.
394 LLVM_DEBUG(dbgs() << "Skipping pass '" << getPassName() << "' in function "
395 << F->getName() << "\n");
396 // FIXME: Delete loop from pass manager's queue?
397 return true;
398 }
399 return false;
400}
401
402LCSSAVerificationPass::LCSSAVerificationPass() : FunctionPass(ID) {}
403
404char LCSSAVerificationPass::ID = 0;
405INITIALIZE_PASS(LCSSAVerificationPass, "lcssa-verification", "LCSSA Verifier",
406 false, false)
407