Bug Summary

File:llvm/lib/Analysis/LoopNestAnalysis.cpp
Warning:line 62, column 50
Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name LoopNestAnalysis.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mframe-pointer=none -fmath-errno -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/build-llvm/lib/Analysis -resource-dir /usr/lib/llvm-14/lib/clang/14.0.0 -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/build-llvm/lib/Analysis -I /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/llvm/lib/Analysis -I /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/build-llvm/include -I /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/llvm/include -D NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/x86_64-linux-gnu/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/backward -internal-isystem /usr/lib/llvm-14/lib/clang/14.0.0/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-class-memaccess -Wno-redundant-move -Wno-pessimizing-move -Wno-noexcept-type -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/build-llvm/lib/Analysis -fdebug-prefix-map=/build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e=. -ferror-limit 19 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2021-09-04-040900-46481-1 -x c++ /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/llvm/lib/Analysis/LoopNestAnalysis.cpp
1//===- LoopNestAnalysis.cpp - Loop Nest Analysis --------------------------==//
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/// \file
10/// The implementation for the loop nest analysis.
11///
12//===----------------------------------------------------------------------===//
13
14#include "llvm/Analysis/LoopNestAnalysis.h"
15#include "llvm/ADT/BreadthFirstIterator.h"
16#include "llvm/ADT/Statistic.h"
17#include "llvm/Analysis/PostDominators.h"
18#include "llvm/Analysis/ValueTracking.h"
19
20using namespace llvm;
21
22#define DEBUG_TYPE"loopnest" "loopnest"
23#ifndef NDEBUG1
24static const char *VerboseDebug = DEBUG_TYPE"loopnest" "-verbose";
25#endif
26
27/// Determine whether the loops structure violates basic requirements for
28/// perfect nesting:
29/// - the inner loop should be the outer loop's only child
30/// - the outer loop header should 'flow' into the inner loop preheader
31/// or jump around the inner loop to the outer loop latch
32/// - if the inner loop latch exits the inner loop, it should 'flow' into
33/// the outer loop latch.
34/// Returns true if the loop structure satisfies the basic requirements and
35/// false otherwise.
36static bool checkLoopsStructure(const Loop &OuterLoop, const Loop &InnerLoop,
37 ScalarEvolution &SE);
38
39//===----------------------------------------------------------------------===//
40// LoopNest implementation
41//
42
43LoopNest::LoopNest(Loop &Root, ScalarEvolution &SE)
44 : MaxPerfectDepth(getMaxPerfectDepth(Root, SE)) {
45 append_range(Loops, breadth_first(&Root));
46}
47
48std::unique_ptr<LoopNest> LoopNest::getLoopNest(Loop &Root,
49 ScalarEvolution &SE) {
50 return std::make_unique<LoopNest>(Root, SE);
51}
52
53static CmpInst *getOuterLoopLatchCmp(const Loop &OuterLoop) {
54
55 const BasicBlock *Latch = OuterLoop.getLoopLatch();
56 assert(Latch && "Expecting a valid loop latch")(static_cast<void> (0));
57
58 const BranchInst *BI = dyn_cast<BranchInst>(Latch->getTerminator());
4
Assuming the object is not a 'BranchInst'
5
'BI' initialized to a null pointer value
59 assert(BI && BI->isConditional() &&(static_cast<void> (0))
60 "Expecting loop latch terminator to be a branch instruction")(static_cast<void> (0));
61
62 CmpInst *OuterLoopLatchCmp = dyn_cast<CmpInst>(BI->getCondition());
6
Called C++ object pointer is null
63 DEBUG_WITH_TYPE(do { } while (false)
64 VerboseDebug, if (OuterLoopLatchCmp) {do { } while (false)
65 dbgs() << "Outer loop latch compare instruction: " << *OuterLoopLatchCmpdo { } while (false)
66 << "\n";do { } while (false)
67 })do { } while (false);
68 return OuterLoopLatchCmp;
69}
70
71static CmpInst *getInnerLoopGuardCmp(const Loop &InnerLoop) {
72
73 BranchInst *InnerGuard = InnerLoop.getLoopGuardBranch();
74 CmpInst *InnerLoopGuardCmp =
75 (InnerGuard) ? dyn_cast<CmpInst>(InnerGuard->getCondition()) : nullptr;
76
77 DEBUG_WITH_TYPE(do { } while (false)
78 VerboseDebug, if (InnerLoopGuardCmp) {do { } while (false)
79 dbgs() << "Inner loop guard compare instruction: " << *InnerLoopGuardCmpdo { } while (false)
80 << "\n";do { } while (false)
81 })do { } while (false);
82 return InnerLoopGuardCmp;
83}
84
85static bool checkSafeInstruction(const Instruction &I,
86 const CmpInst *InnerLoopGuardCmp,
87 const CmpInst *OuterLoopLatchCmp,
88 Optional<Loop::LoopBounds> OuterLoopLB) {
89
90 bool IsAllowed =
91 isSafeToSpeculativelyExecute(&I) || isa<PHINode>(I) || isa<BranchInst>(I);
92 if (!IsAllowed)
93 return false;
94 // The only binary instruction allowed is the outer loop step instruction,
95 // the only comparison instructions allowed are the inner loop guard
96 // compare instruction and the outer loop latch compare instruction.
97 if ((isa<BinaryOperator>(I) && &I != &OuterLoopLB->getStepInst()) ||
98 (isa<CmpInst>(I) && &I != OuterLoopLatchCmp && &I != InnerLoopGuardCmp)) {
99 return false;
100 }
101 return true;
102}
103
104bool LoopNest::arePerfectlyNested(const Loop &OuterLoop, const Loop &InnerLoop,
105 ScalarEvolution &SE) {
106 return (analyzeLoopNestForPerfectNest(OuterLoop, InnerLoop, SE) ==
107 PerfectLoopNest);
108}
109
110LoopNest::LoopNestEnum LoopNest::analyzeLoopNestForPerfectNest(
111 const Loop &OuterLoop, const Loop &InnerLoop, ScalarEvolution &SE) {
112
113 assert(!OuterLoop.isInnermost() && "Outer loop should have subloops")(static_cast<void> (0));
114 assert(!InnerLoop.isOutermost() && "Inner loop should have a parent")(static_cast<void> (0));
115 LLVM_DEBUG(dbgs() << "Checking whether loop '" << OuterLoop.getName()do { } while (false)
116 << "' and '" << InnerLoop.getName()do { } while (false)
117 << "' are perfectly nested.\n")do { } while (false);
118
119 // Determine whether the loops structure satisfies the following requirements:
120 // - the inner loop should be the outer loop's only child
121 // - the outer loop header should 'flow' into the inner loop preheader
122 // or jump around the inner loop to the outer loop latch
123 // - if the inner loop latch exits the inner loop, it should 'flow' into
124 // the outer loop latch.
125 if (!checkLoopsStructure(OuterLoop, InnerLoop, SE)) {
126 LLVM_DEBUG(dbgs() << "Not perfectly nested: invalid loop structure.\n")do { } while (false);
127 return InvalidLoopStructure;
128 }
129
130 // Bail out if we cannot retrieve the outer loop bounds.
131 auto OuterLoopLB = OuterLoop.getBounds(SE);
132 if (OuterLoopLB == None) {
133 LLVM_DEBUG(dbgs() << "Cannot compute loop bounds of OuterLoop: "do { } while (false)
134 << OuterLoop << "\n";)do { } while (false);
135 return OuterLoopLowerBoundUnknown;
136 }
137
138 CmpInst *OuterLoopLatchCmp = getOuterLoopLatchCmp(OuterLoop);
139 CmpInst *InnerLoopGuardCmp = getInnerLoopGuardCmp(InnerLoop);
140
141 // Determine whether instructions in a basic block are one of:
142 // - the inner loop guard comparison
143 // - the outer loop latch comparison
144 // - the outer loop induction variable increment
145 // - a phi node, a cast or a branch
146 auto containsOnlySafeInstructions = [&](const BasicBlock &BB) {
147 return llvm::all_of(BB, [&](const Instruction &I) {
148 bool IsSafeInstr = checkSafeInstruction(I, InnerLoopGuardCmp,
149 OuterLoopLatchCmp, OuterLoopLB);
150 if (IsSafeInstr) {
151 DEBUG_WITH_TYPE(VerboseDebug, {do { } while (false)
152 dbgs() << "Instruction: " << I << "\nin basic block:" << BBdo { } while (false)
153 << "is unsafe.\n";do { } while (false)
154 })do { } while (false);
155 }
156 return IsSafeInstr;
157 });
158 };
159
160 // Check the code surrounding the inner loop for instructions that are deemed
161 // unsafe.
162 const BasicBlock *OuterLoopHeader = OuterLoop.getHeader();
163 const BasicBlock *OuterLoopLatch = OuterLoop.getLoopLatch();
164 const BasicBlock *InnerLoopPreHeader = InnerLoop.getLoopPreheader();
165
166 if (!containsOnlySafeInstructions(*OuterLoopHeader) ||
167 !containsOnlySafeInstructions(*OuterLoopLatch) ||
168 (InnerLoopPreHeader != OuterLoopHeader &&
169 !containsOnlySafeInstructions(*InnerLoopPreHeader)) ||
170 !containsOnlySafeInstructions(*InnerLoop.getExitBlock())) {
171 LLVM_DEBUG(dbgs() << "Not perfectly nested: code surrounding inner loop is "do { } while (false)
172 "unsafe\n";)do { } while (false);
173 return ImperfectLoopNest;
174 }
175
176 LLVM_DEBUG(dbgs() << "Loop '" << OuterLoop.getName() << "' and '"do { } while (false)
177 << InnerLoop.getName() << "' are perfectly nested.\n")do { } while (false);
178
179 return PerfectLoopNest;
180}
181
182LoopNest::InstrVectorTy LoopNest::getInterveningInstructions(
183 const Loop &OuterLoop, const Loop &InnerLoop, ScalarEvolution &SE) {
184 InstrVectorTy Instr;
185 switch (analyzeLoopNestForPerfectNest(OuterLoop, InnerLoop, SE)) {
1
Control jumps to 'case ImperfectLoopNest:' at line 201
186 case PerfectLoopNest:
187 LLVM_DEBUG(dbgs() << "The loop Nest is Perfect, returning empty "do { } while (false)
188 "instruction vector. \n";)do { } while (false);
189 return Instr;
190
191 case InvalidLoopStructure:
192 LLVM_DEBUG(dbgs() << "Not perfectly nested: invalid loop structure. "do { } while (false)
193 "Instruction vector is empty.\n";)do { } while (false);
194 return Instr;
195
196 case OuterLoopLowerBoundUnknown:
197 LLVM_DEBUG(dbgs() << "Cannot compute loop bounds of OuterLoop: "do { } while (false)
198 << OuterLoop << "\nInstruction vector is empty.\n";)do { } while (false);
199 return Instr;
200
201 case ImperfectLoopNest:
202 break;
2
Execution continues on line 206
203 }
204
205 // Identify the outer loop latch comparison instruction.
206 auto OuterLoopLB = OuterLoop.getBounds(SE);
207
208 CmpInst *OuterLoopLatchCmp = getOuterLoopLatchCmp(OuterLoop);
3
Calling 'getOuterLoopLatchCmp'
209 CmpInst *InnerLoopGuardCmp = getInnerLoopGuardCmp(InnerLoop);
210
211 auto GetUnsafeInstructions = [&](const BasicBlock &BB) {
212 for (const Instruction &I : BB) {
213 if (!checkSafeInstruction(I, InnerLoopGuardCmp, OuterLoopLatchCmp,
214 OuterLoopLB)) {
215 Instr.push_back(&I);
216 DEBUG_WITH_TYPE(VerboseDebug, {do { } while (false)
217 dbgs() << "Instruction: " << I << "\nin basic block:" << BBdo { } while (false)
218 << "is unsafe.\n";do { } while (false)
219 })do { } while (false);
220 }
221 }
222 };
223
224 // Check the code surrounding the inner loop for instructions that are deemed
225 // unsafe.
226 const BasicBlock *OuterLoopHeader = OuterLoop.getHeader();
227 const BasicBlock *OuterLoopLatch = OuterLoop.getLoopLatch();
228 const BasicBlock *InnerLoopPreHeader = InnerLoop.getLoopPreheader();
229 const BasicBlock *InnerLoopExitBlock = InnerLoop.getExitBlock();
230
231 GetUnsafeInstructions(*OuterLoopHeader);
232 GetUnsafeInstructions(*OuterLoopLatch);
233 GetUnsafeInstructions(*InnerLoopExitBlock);
234
235 if (InnerLoopPreHeader != OuterLoopHeader) {
236 GetUnsafeInstructions(*InnerLoopPreHeader);
237 }
238 return Instr;
239}
240
241SmallVector<LoopVectorTy, 4>
242LoopNest::getPerfectLoops(ScalarEvolution &SE) const {
243 SmallVector<LoopVectorTy, 4> LV;
244 LoopVectorTy PerfectNest;
245
246 for (Loop *L : depth_first(const_cast<Loop *>(Loops.front()))) {
247 if (PerfectNest.empty())
248 PerfectNest.push_back(L);
249
250 auto &SubLoops = L->getSubLoops();
251 if (SubLoops.size() == 1 && arePerfectlyNested(*L, *SubLoops.front(), SE)) {
252 PerfectNest.push_back(SubLoops.front());
253 } else {
254 LV.push_back(PerfectNest);
255 PerfectNest.clear();
256 }
257 }
258
259 return LV;
260}
261
262unsigned LoopNest::getMaxPerfectDepth(const Loop &Root, ScalarEvolution &SE) {
263 LLVM_DEBUG(dbgs() << "Get maximum perfect depth of loop nest rooted by loop '"do { } while (false)
264 << Root.getName() << "'\n")do { } while (false);
265
266 const Loop *CurrentLoop = &Root;
267 const auto *SubLoops = &CurrentLoop->getSubLoops();
268 unsigned CurrentDepth = 1;
269
270 while (SubLoops->size() == 1) {
271 const Loop *InnerLoop = SubLoops->front();
272 if (!arePerfectlyNested(*CurrentLoop, *InnerLoop, SE)) {
273 LLVM_DEBUG({do { } while (false)
274 dbgs() << "Not a perfect nest: loop '" << CurrentLoop->getName()do { } while (false)
275 << "' is not perfectly nested with loop '"do { } while (false)
276 << InnerLoop->getName() << "'\n";do { } while (false)
277 })do { } while (false);
278 break;
279 }
280
281 CurrentLoop = InnerLoop;
282 SubLoops = &CurrentLoop->getSubLoops();
283 ++CurrentDepth;
284 }
285
286 return CurrentDepth;
287}
288
289const BasicBlock &LoopNest::skipEmptyBlockUntil(const BasicBlock *From,
290 const BasicBlock *End,
291 bool CheckUniquePred) {
292 assert(From && "Expecting valid From")(static_cast<void> (0));
293 assert(End && "Expecting valid End")(static_cast<void> (0));
294
295 if (From == End || !From->getUniqueSuccessor())
296 return *From;
297
298 auto IsEmpty = [](const BasicBlock *BB) {
299 return (BB->getInstList().size() == 1);
300 };
301
302 // Visited is used to avoid running into an infinite loop.
303 SmallPtrSet<const BasicBlock *, 4> Visited;
304 const BasicBlock *BB = From->getUniqueSuccessor();
305 const BasicBlock *PredBB = From;
306 while (BB && BB != End && IsEmpty(BB) && !Visited.count(BB) &&
307 (!CheckUniquePred || BB->getUniquePredecessor())) {
308 Visited.insert(BB);
309 PredBB = BB;
310 BB = BB->getUniqueSuccessor();
311 }
312
313 return (BB == End) ? *End : *PredBB;
314}
315
316static bool checkLoopsStructure(const Loop &OuterLoop, const Loop &InnerLoop,
317 ScalarEvolution &SE) {
318 // The inner loop must be the only outer loop's child.
319 if ((OuterLoop.getSubLoops().size() != 1) ||
320 (InnerLoop.getParentLoop() != &OuterLoop))
321 return false;
322
323 // We expect loops in normal form which have a preheader, header, latch...
324 if (!OuterLoop.isLoopSimplifyForm() || !InnerLoop.isLoopSimplifyForm())
325 return false;
326
327 const BasicBlock *OuterLoopHeader = OuterLoop.getHeader();
328 const BasicBlock *OuterLoopLatch = OuterLoop.getLoopLatch();
329 const BasicBlock *InnerLoopPreHeader = InnerLoop.getLoopPreheader();
330 const BasicBlock *InnerLoopLatch = InnerLoop.getLoopLatch();
331 const BasicBlock *InnerLoopExit = InnerLoop.getExitBlock();
332
333 // We expect rotated loops. The inner loop should have a single exit block.
334 if (OuterLoop.getExitingBlock() != OuterLoopLatch ||
335 InnerLoop.getExitingBlock() != InnerLoopLatch || !InnerLoopExit)
336 return false;
337
338 // Returns whether the block `ExitBlock` contains at least one LCSSA Phi node.
339 auto ContainsLCSSAPhi = [](const BasicBlock &ExitBlock) {
340 return any_of(ExitBlock.phis(), [](const PHINode &PN) {
341 return PN.getNumIncomingValues() == 1;
342 });
343 };
344
345 // Returns whether the block `BB` qualifies for being an extra Phi block. The
346 // extra Phi block is the additional block inserted after the exit block of an
347 // "guarded" inner loop which contains "only" Phi nodes corresponding to the
348 // LCSSA Phi nodes in the exit block.
349 auto IsExtraPhiBlock = [&](const BasicBlock &BB) {
350 return BB.getFirstNonPHI() == BB.getTerminator() &&
351 all_of(BB.phis(), [&](const PHINode &PN) {
352 return all_of(PN.blocks(), [&](const BasicBlock *IncomingBlock) {
353 return IncomingBlock == InnerLoopExit ||
354 IncomingBlock == OuterLoopHeader;
355 });
356 });
357 };
358
359 const BasicBlock *ExtraPhiBlock = nullptr;
360 // Ensure the only branch that may exist between the loops is the inner loop
361 // guard.
362 if (OuterLoopHeader != InnerLoopPreHeader) {
363 const BasicBlock &SingleSucc =
364 LoopNest::skipEmptyBlockUntil(OuterLoopHeader, InnerLoopPreHeader);
365
366 // no conditional branch present
367 if (&SingleSucc != InnerLoopPreHeader) {
368 const BranchInst *BI = dyn_cast<BranchInst>(SingleSucc.getTerminator());
369
370 if (!BI || BI != InnerLoop.getLoopGuardBranch())
371 return false;
372
373 bool InnerLoopExitContainsLCSSA = ContainsLCSSAPhi(*InnerLoopExit);
374
375 // The successors of the inner loop guard should be the inner loop
376 // preheader or the outer loop latch possibly through empty blocks.
377 for (const BasicBlock *Succ : BI->successors()) {
378 const BasicBlock *PotentialInnerPreHeader = Succ;
379 const BasicBlock *PotentialOuterLatch = Succ;
380
381 // Ensure the inner loop guard successor is empty before skipping
382 // blocks.
383 if (Succ->getInstList().size() == 1) {
384 PotentialInnerPreHeader =
385 &LoopNest::skipEmptyBlockUntil(Succ, InnerLoopPreHeader);
386 PotentialOuterLatch =
387 &LoopNest::skipEmptyBlockUntil(Succ, OuterLoopLatch);
388 }
389
390 if (PotentialInnerPreHeader == InnerLoopPreHeader)
391 continue;
392 if (PotentialOuterLatch == OuterLoopLatch)
393 continue;
394
395 // If `InnerLoopExit` contains LCSSA Phi instructions, additional block
396 // may be inserted before the `OuterLoopLatch` to which `BI` jumps. The
397 // loops are still considered perfectly nested if the extra block only
398 // contains Phi instructions from InnerLoopExit and OuterLoopHeader.
399 if (InnerLoopExitContainsLCSSA && IsExtraPhiBlock(*Succ) &&
400 Succ->getSingleSuccessor() == OuterLoopLatch) {
401 // Points to the extra block so that we can reference it later in the
402 // final check. We can also conclude that the inner loop is
403 // guarded and there exists LCSSA Phi node in the exit block later if
404 // we see a non-null `ExtraPhiBlock`.
405 ExtraPhiBlock = Succ;
406 continue;
407 }
408
409 DEBUG_WITH_TYPE(VerboseDebug, {do { } while (false)
410 dbgs() << "Inner loop guard successor " << Succ->getName()do { } while (false)
411 << " doesn't lead to inner loop preheader or "do { } while (false)
412 "outer loop latch.\n";do { } while (false)
413 })do { } while (false);
414 return false;
415 }
416 }
417 }
418
419 // Ensure the inner loop exit block lead to the outer loop latch possibly
420 // through empty blocks.
421 if ((!ExtraPhiBlock ||
422 &LoopNest::skipEmptyBlockUntil(InnerLoop.getExitBlock(),
423 ExtraPhiBlock) != ExtraPhiBlock) &&
424 (&LoopNest::skipEmptyBlockUntil(InnerLoop.getExitBlock(),
425 OuterLoopLatch) != OuterLoopLatch)) {
426 DEBUG_WITH_TYPE(do { } while (false)
427 VerboseDebug,do { } while (false)
428 dbgs() << "Inner loop exit block " << *InnerLoopExitdo { } while (false)
429 << " does not directly lead to the outer loop latch.\n";)do { } while (false);
430 return false;
431 }
432
433 return true;
434}
435
436AnalysisKey LoopNestAnalysis::Key;
437
438raw_ostream &llvm::operator<<(raw_ostream &OS, const LoopNest &LN) {
439 OS << "IsPerfect=";
440 if (LN.getMaxPerfectDepth() == LN.getNestDepth())
441 OS << "true";
442 else
443 OS << "false";
444 OS << ", Depth=" << LN.getNestDepth();
445 OS << ", OutermostLoop: " << LN.getOutermostLoop().getName();
446 OS << ", Loops: ( ";
447 for (const Loop *L : LN.getLoops())
448 OS << L->getName() << " ";
449 OS << ")";
450
451 return OS;
452}
453
454//===----------------------------------------------------------------------===//
455// LoopNestPrinterPass implementation
456//
457
458PreservedAnalyses LoopNestPrinterPass::run(Loop &L, LoopAnalysisManager &AM,
459 LoopStandardAnalysisResults &AR,
460 LPMUpdater &U) {
461 if (auto LN = LoopNest::getLoopNest(L, AR.SE))
462 OS << *LN << "\n";
463
464 return PreservedAnalyses::all();
465}