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