1 //===- LoopUnrollAndJam.cpp - Loop unroll and jam pass --------------------===//
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 pass implements an unroll and jam pass. Most of the work is done by
10 // Utils/UnrollLoopAndJam.cpp.
11 //===----------------------------------------------------------------------===//
12 
13 #include "llvm/Transforms/Scalar/LoopUnrollAndJamPass.h"
14 #include "llvm/ADT/ArrayRef.h"
15 #include "llvm/ADT/PriorityWorklist.h"
16 #include "llvm/ADT/SmallPtrSet.h"
17 #include "llvm/ADT/StringRef.h"
18 #include "llvm/Analysis/AssumptionCache.h"
19 #include "llvm/Analysis/CodeMetrics.h"
20 #include "llvm/Analysis/DependenceAnalysis.h"
21 #include "llvm/Analysis/LoopAnalysisManager.h"
22 #include "llvm/Analysis/LoopInfo.h"
23 #include "llvm/Analysis/LoopNestAnalysis.h"
24 #include "llvm/Analysis/LoopPass.h"
25 #include "llvm/Analysis/OptimizationRemarkEmitter.h"
26 #include "llvm/Analysis/ScalarEvolution.h"
27 #include "llvm/Analysis/TargetTransformInfo.h"
28 #include "llvm/IR/BasicBlock.h"
29 #include "llvm/IR/Constants.h"
30 #include "llvm/IR/Dominators.h"
31 #include "llvm/IR/Function.h"
32 #include "llvm/IR/Instructions.h"
33 #include "llvm/IR/Metadata.h"
34 #include "llvm/IR/PassManager.h"
35 #include "llvm/InitializePasses.h"
36 #include "llvm/Pass.h"
37 #include "llvm/PassRegistry.h"
38 #include "llvm/Support/Casting.h"
39 #include "llvm/Support/CommandLine.h"
40 #include "llvm/Support/Compiler.h"
41 #include "llvm/Support/Debug.h"
42 #include "llvm/Support/raw_ostream.h"
43 #include "llvm/Transforms/Scalar.h"
44 #include "llvm/Transforms/Scalar/LoopPassManager.h"
45 #include "llvm/Transforms/Utils/LoopPeel.h"
46 #include "llvm/Transforms/Utils/LoopUtils.h"
47 #include "llvm/Transforms/Utils/UnrollLoop.h"
48 #include <cassert>
49 #include <cstdint>
50 
51 namespace llvm {
52 class Instruction;
53 class Value;
54 } // namespace llvm
55 
56 using namespace llvm;
57 
58 #define DEBUG_TYPE "loop-unroll-and-jam"
59 
60 /// @{
61 /// Metadata attribute names
62 static const char *const LLVMLoopUnrollAndJamFollowupAll =
63     "llvm.loop.unroll_and_jam.followup_all";
64 static const char *const LLVMLoopUnrollAndJamFollowupInner =
65     "llvm.loop.unroll_and_jam.followup_inner";
66 static const char *const LLVMLoopUnrollAndJamFollowupOuter =
67     "llvm.loop.unroll_and_jam.followup_outer";
68 static const char *const LLVMLoopUnrollAndJamFollowupRemainderInner =
69     "llvm.loop.unroll_and_jam.followup_remainder_inner";
70 static const char *const LLVMLoopUnrollAndJamFollowupRemainderOuter =
71     "llvm.loop.unroll_and_jam.followup_remainder_outer";
72 /// @}
73 
74 static cl::opt<bool>
75     AllowUnrollAndJam("allow-unroll-and-jam", cl::Hidden,
76                       cl::desc("Allows loops to be unroll-and-jammed."));
77 
78 static cl::opt<unsigned> UnrollAndJamCount(
79     "unroll-and-jam-count", cl::Hidden,
80     cl::desc("Use this unroll count for all loops including those with "
81              "unroll_and_jam_count pragma values, for testing purposes"));
82 
83 static cl::opt<unsigned> UnrollAndJamThreshold(
84     "unroll-and-jam-threshold", cl::init(60), cl::Hidden,
85     cl::desc("Threshold to use for inner loop when doing unroll and jam."));
86 
87 static cl::opt<unsigned> PragmaUnrollAndJamThreshold(
88     "pragma-unroll-and-jam-threshold", cl::init(1024), cl::Hidden,
89     cl::desc("Unrolled size limit for loops with an unroll_and_jam(full) or "
90              "unroll_count pragma."));
91 
92 // Returns the loop hint metadata node with the given name (for example,
93 // "llvm.loop.unroll.count").  If no such metadata node exists, then nullptr is
94 // returned.
95 static MDNode *getUnrollMetadataForLoop(const Loop *L, StringRef Name) {
96   if (MDNode *LoopID = L->getLoopID())
97     return GetUnrollMetadata(LoopID, Name);
98   return nullptr;
99 }
100 
101 // Returns true if the loop has any metadata starting with Prefix. For example a
102 // Prefix of "llvm.loop.unroll." returns true if we have any unroll metadata.
103 static bool hasAnyUnrollPragma(const Loop *L, StringRef Prefix) {
104   if (MDNode *LoopID = L->getLoopID()) {
105     // First operand should refer to the loop id itself.
106     assert(LoopID->getNumOperands() > 0 && "requires at least one operand");
107     assert(LoopID->getOperand(0) == LoopID && "invalid loop id");
108 
109     for (unsigned I = 1, E = LoopID->getNumOperands(); I < E; ++I) {
110       MDNode *MD = dyn_cast<MDNode>(LoopID->getOperand(I));
111       if (!MD)
112         continue;
113 
114       MDString *S = dyn_cast<MDString>(MD->getOperand(0));
115       if (!S)
116         continue;
117 
118       if (S->getString().startswith(Prefix))
119         return true;
120     }
121   }
122   return false;
123 }
124 
125 // Returns true if the loop has an unroll_and_jam(enable) pragma.
126 static bool hasUnrollAndJamEnablePragma(const Loop *L) {
127   return getUnrollMetadataForLoop(L, "llvm.loop.unroll_and_jam.enable");
128 }
129 
130 // If loop has an unroll_and_jam_count pragma return the (necessarily
131 // positive) value from the pragma.  Otherwise return 0.
132 static unsigned unrollAndJamCountPragmaValue(const Loop *L) {
133   MDNode *MD = getUnrollMetadataForLoop(L, "llvm.loop.unroll_and_jam.count");
134   if (MD) {
135     assert(MD->getNumOperands() == 2 &&
136            "Unroll count hint metadata should have two operands.");
137     unsigned Count =
138         mdconst::extract<ConstantInt>(MD->getOperand(1))->getZExtValue();
139     assert(Count >= 1 && "Unroll count must be positive.");
140     return Count;
141   }
142   return 0;
143 }
144 
145 // Returns loop size estimation for unrolled loop.
146 static uint64_t
147 getUnrollAndJammedLoopSize(unsigned LoopSize,
148                            TargetTransformInfo::UnrollingPreferences &UP) {
149   assert(LoopSize >= UP.BEInsns && "LoopSize should not be less than BEInsns!");
150   return static_cast<uint64_t>(LoopSize - UP.BEInsns) * UP.Count + UP.BEInsns;
151 }
152 
153 // Calculates unroll and jam count and writes it to UP.Count. Returns true if
154 // unroll count was set explicitly.
155 static bool computeUnrollAndJamCount(
156     Loop *L, Loop *SubLoop, const TargetTransformInfo &TTI, DominatorTree &DT,
157     LoopInfo *LI, AssumptionCache *AC, ScalarEvolution &SE,
158     const SmallPtrSetImpl<const Value *> &EphValues,
159     OptimizationRemarkEmitter *ORE, unsigned OuterTripCount,
160     unsigned OuterTripMultiple, unsigned OuterLoopSize, unsigned InnerTripCount,
161     unsigned InnerLoopSize, TargetTransformInfo::UnrollingPreferences &UP,
162     TargetTransformInfo::PeelingPreferences &PP) {
163   // First up use computeUnrollCount from the loop unroller to get a count
164   // for unrolling the outer loop, plus any loops requiring explicit
165   // unrolling we leave to the unroller. This uses UP.Threshold /
166   // UP.PartialThreshold / UP.MaxCount to come up with sensible loop values.
167   // We have already checked that the loop has no unroll.* pragmas.
168   unsigned MaxTripCount = 0;
169   bool UseUpperBound = false;
170   bool ExplicitUnroll = computeUnrollCount(
171     L, TTI, DT, LI, AC, SE, EphValues, ORE, OuterTripCount, MaxTripCount,
172       /*MaxOrZero*/ false, OuterTripMultiple, OuterLoopSize, UP, PP,
173       UseUpperBound);
174   if (ExplicitUnroll || UseUpperBound) {
175     // If the user explicitly set the loop as unrolled, dont UnJ it. Leave it
176     // for the unroller instead.
177     LLVM_DEBUG(dbgs() << "Won't unroll-and-jam; explicit count set by "
178                          "computeUnrollCount\n");
179     UP.Count = 0;
180     return false;
181   }
182 
183   // Override with any explicit Count from the "unroll-and-jam-count" option.
184   bool UserUnrollCount = UnrollAndJamCount.getNumOccurrences() > 0;
185   if (UserUnrollCount) {
186     UP.Count = UnrollAndJamCount;
187     UP.Force = true;
188     if (UP.AllowRemainder &&
189         getUnrollAndJammedLoopSize(OuterLoopSize, UP) < UP.Threshold &&
190         getUnrollAndJammedLoopSize(InnerLoopSize, UP) <
191             UP.UnrollAndJamInnerLoopThreshold)
192       return true;
193   }
194 
195   // Check for unroll_and_jam pragmas
196   unsigned PragmaCount = unrollAndJamCountPragmaValue(L);
197   if (PragmaCount > 0) {
198     UP.Count = PragmaCount;
199     UP.Runtime = true;
200     UP.Force = true;
201     if ((UP.AllowRemainder || (OuterTripMultiple % PragmaCount == 0)) &&
202         getUnrollAndJammedLoopSize(OuterLoopSize, UP) < UP.Threshold &&
203         getUnrollAndJammedLoopSize(InnerLoopSize, UP) <
204             UP.UnrollAndJamInnerLoopThreshold)
205       return true;
206   }
207 
208   bool PragmaEnableUnroll = hasUnrollAndJamEnablePragma(L);
209   bool ExplicitUnrollAndJamCount = PragmaCount > 0 || UserUnrollCount;
210   bool ExplicitUnrollAndJam = PragmaEnableUnroll || ExplicitUnrollAndJamCount;
211 
212   // If the loop has an unrolling pragma, we want to be more aggressive with
213   // unrolling limits.
214   if (ExplicitUnrollAndJam)
215     UP.UnrollAndJamInnerLoopThreshold = PragmaUnrollAndJamThreshold;
216 
217   if (!UP.AllowRemainder && getUnrollAndJammedLoopSize(InnerLoopSize, UP) >=
218                                 UP.UnrollAndJamInnerLoopThreshold) {
219     LLVM_DEBUG(dbgs() << "Won't unroll-and-jam; can't create remainder and "
220                          "inner loop too large\n");
221     UP.Count = 0;
222     return false;
223   }
224 
225   // We have a sensible limit for the outer loop, now adjust it for the inner
226   // loop and UP.UnrollAndJamInnerLoopThreshold. If the outer limit was set
227   // explicitly, we want to stick to it.
228   if (!ExplicitUnrollAndJamCount && UP.AllowRemainder) {
229     while (UP.Count != 0 && getUnrollAndJammedLoopSize(InnerLoopSize, UP) >=
230                                 UP.UnrollAndJamInnerLoopThreshold)
231       UP.Count--;
232   }
233 
234   // If we are explicitly unroll and jamming, we are done. Otherwise there are a
235   // number of extra performance heuristics to check.
236   if (ExplicitUnrollAndJam)
237     return true;
238 
239   // If the inner loop count is known and small, leave the entire loop nest to
240   // be the unroller
241   if (InnerTripCount && InnerLoopSize * InnerTripCount < UP.Threshold) {
242     LLVM_DEBUG(dbgs() << "Won't unroll-and-jam; small inner loop count is "
243                          "being left for the unroller\n");
244     UP.Count = 0;
245     return false;
246   }
247 
248   // Check for situations where UnJ is likely to be unprofitable. Including
249   // subloops with more than 1 block.
250   if (SubLoop->getBlocks().size() != 1) {
251     LLVM_DEBUG(
252         dbgs() << "Won't unroll-and-jam; More than one inner loop block\n");
253     UP.Count = 0;
254     return false;
255   }
256 
257   // Limit to loops where there is something to gain from unrolling and
258   // jamming the loop. In this case, look for loads that are invariant in the
259   // outer loop and can become shared.
260   unsigned NumInvariant = 0;
261   for (BasicBlock *BB : SubLoop->getBlocks()) {
262     for (Instruction &I : *BB) {
263       if (auto *Ld = dyn_cast<LoadInst>(&I)) {
264         Value *V = Ld->getPointerOperand();
265         const SCEV *LSCEV = SE.getSCEVAtScope(V, L);
266         if (SE.isLoopInvariant(LSCEV, L))
267           NumInvariant++;
268       }
269     }
270   }
271   if (NumInvariant == 0) {
272     LLVM_DEBUG(dbgs() << "Won't unroll-and-jam; No loop invariant loads\n");
273     UP.Count = 0;
274     return false;
275   }
276 
277   return false;
278 }
279 
280 static LoopUnrollResult
281 tryToUnrollAndJamLoop(Loop *L, DominatorTree &DT, LoopInfo *LI,
282                       ScalarEvolution &SE, const TargetTransformInfo &TTI,
283                       AssumptionCache &AC, DependenceInfo &DI,
284                       OptimizationRemarkEmitter &ORE, int OptLevel) {
285   TargetTransformInfo::UnrollingPreferences UP = gatherUnrollingPreferences(
286       L, SE, TTI, nullptr, nullptr, ORE, OptLevel, std::nullopt, std::nullopt,
287       std::nullopt, std::nullopt, std::nullopt, std::nullopt);
288   TargetTransformInfo::PeelingPreferences PP =
289       gatherPeelingPreferences(L, SE, TTI, std::nullopt, std::nullopt);
290 
291   TransformationMode EnableMode = hasUnrollAndJamTransformation(L);
292   if (EnableMode & TM_Disable)
293     return LoopUnrollResult::Unmodified;
294   if (EnableMode & TM_ForcedByUser)
295     UP.UnrollAndJam = true;
296 
297   if (AllowUnrollAndJam.getNumOccurrences() > 0)
298     UP.UnrollAndJam = AllowUnrollAndJam;
299   if (UnrollAndJamThreshold.getNumOccurrences() > 0)
300     UP.UnrollAndJamInnerLoopThreshold = UnrollAndJamThreshold;
301   // Exit early if unrolling is disabled.
302   if (!UP.UnrollAndJam || UP.UnrollAndJamInnerLoopThreshold == 0)
303     return LoopUnrollResult::Unmodified;
304 
305   LLVM_DEBUG(dbgs() << "Loop Unroll and Jam: F["
306                     << L->getHeader()->getParent()->getName() << "] Loop %"
307                     << L->getHeader()->getName() << "\n");
308 
309   // A loop with any unroll pragma (enabling/disabling/count/etc) is left for
310   // the unroller, so long as it does not explicitly have unroll_and_jam
311   // metadata. This means #pragma nounroll will disable unroll and jam as well
312   // as unrolling
313   if (hasAnyUnrollPragma(L, "llvm.loop.unroll.") &&
314       !hasAnyUnrollPragma(L, "llvm.loop.unroll_and_jam.")) {
315     LLVM_DEBUG(dbgs() << "  Disabled due to pragma.\n");
316     return LoopUnrollResult::Unmodified;
317   }
318 
319   if (!isSafeToUnrollAndJam(L, SE, DT, DI, *LI)) {
320     LLVM_DEBUG(dbgs() << "  Disabled due to not being safe.\n");
321     return LoopUnrollResult::Unmodified;
322   }
323 
324   // Approximate the loop size and collect useful info
325   unsigned NumInlineCandidates;
326   bool NotDuplicatable;
327   bool Convergent;
328   SmallPtrSet<const Value *, 32> EphValues;
329   CodeMetrics::collectEphemeralValues(L, &AC, EphValues);
330   Loop *SubLoop = L->getSubLoops()[0];
331   InstructionCost InnerLoopSizeIC =
332       ApproximateLoopSize(SubLoop, NumInlineCandidates, NotDuplicatable,
333                           Convergent, TTI, EphValues, UP.BEInsns);
334   InstructionCost OuterLoopSizeIC =
335       ApproximateLoopSize(L, NumInlineCandidates, NotDuplicatable, Convergent,
336                           TTI, EphValues, UP.BEInsns);
337   LLVM_DEBUG(dbgs() << "  Outer Loop Size: " << OuterLoopSizeIC << "\n");
338   LLVM_DEBUG(dbgs() << "  Inner Loop Size: " << InnerLoopSizeIC << "\n");
339 
340   if (!InnerLoopSizeIC.isValid() || !OuterLoopSizeIC.isValid()) {
341     LLVM_DEBUG(dbgs() << "  Not unrolling loop which contains instructions"
342                       << " with invalid cost.\n");
343     return LoopUnrollResult::Unmodified;
344   }
345   unsigned InnerLoopSize = *InnerLoopSizeIC.getValue();
346   unsigned OuterLoopSize = *OuterLoopSizeIC.getValue();
347 
348   if (NotDuplicatable) {
349     LLVM_DEBUG(dbgs() << "  Not unrolling loop which contains non-duplicatable "
350                          "instructions.\n");
351     return LoopUnrollResult::Unmodified;
352   }
353   if (NumInlineCandidates != 0) {
354     LLVM_DEBUG(dbgs() << "  Not unrolling loop with inlinable calls.\n");
355     return LoopUnrollResult::Unmodified;
356   }
357   if (Convergent) {
358     LLVM_DEBUG(
359         dbgs() << "  Not unrolling loop with convergent instructions.\n");
360     return LoopUnrollResult::Unmodified;
361   }
362 
363   // Save original loop IDs for after the transformation.
364   MDNode *OrigOuterLoopID = L->getLoopID();
365   MDNode *OrigSubLoopID = SubLoop->getLoopID();
366 
367   // To assign the loop id of the epilogue, assign it before unrolling it so it
368   // is applied to every inner loop of the epilogue. We later apply the loop ID
369   // for the jammed inner loop.
370   std::optional<MDNode *> NewInnerEpilogueLoopID = makeFollowupLoopID(
371       OrigOuterLoopID, {LLVMLoopUnrollAndJamFollowupAll,
372                         LLVMLoopUnrollAndJamFollowupRemainderInner});
373   if (NewInnerEpilogueLoopID)
374     SubLoop->setLoopID(*NewInnerEpilogueLoopID);
375 
376   // Find trip count and trip multiple
377   BasicBlock *Latch = L->getLoopLatch();
378   BasicBlock *SubLoopLatch = SubLoop->getLoopLatch();
379   unsigned OuterTripCount = SE.getSmallConstantTripCount(L, Latch);
380   unsigned OuterTripMultiple = SE.getSmallConstantTripMultiple(L, Latch);
381   unsigned InnerTripCount = SE.getSmallConstantTripCount(SubLoop, SubLoopLatch);
382 
383   // Decide if, and by how much, to unroll
384   bool IsCountSetExplicitly = computeUnrollAndJamCount(
385     L, SubLoop, TTI, DT, LI, &AC, SE, EphValues, &ORE, OuterTripCount,
386       OuterTripMultiple, OuterLoopSize, InnerTripCount, InnerLoopSize, UP, PP);
387   if (UP.Count <= 1)
388     return LoopUnrollResult::Unmodified;
389   // Unroll factor (Count) must be less or equal to TripCount.
390   if (OuterTripCount && UP.Count > OuterTripCount)
391     UP.Count = OuterTripCount;
392 
393   Loop *EpilogueOuterLoop = nullptr;
394   LoopUnrollResult UnrollResult = UnrollAndJamLoop(
395       L, UP.Count, OuterTripCount, OuterTripMultiple, UP.UnrollRemainder, LI,
396       &SE, &DT, &AC, &TTI, &ORE, &EpilogueOuterLoop);
397 
398   // Assign new loop attributes.
399   if (EpilogueOuterLoop) {
400     std::optional<MDNode *> NewOuterEpilogueLoopID = makeFollowupLoopID(
401         OrigOuterLoopID, {LLVMLoopUnrollAndJamFollowupAll,
402                           LLVMLoopUnrollAndJamFollowupRemainderOuter});
403     if (NewOuterEpilogueLoopID)
404       EpilogueOuterLoop->setLoopID(*NewOuterEpilogueLoopID);
405   }
406 
407   std::optional<MDNode *> NewInnerLoopID =
408       makeFollowupLoopID(OrigOuterLoopID, {LLVMLoopUnrollAndJamFollowupAll,
409                                            LLVMLoopUnrollAndJamFollowupInner});
410   if (NewInnerLoopID)
411     SubLoop->setLoopID(*NewInnerLoopID);
412   else
413     SubLoop->setLoopID(OrigSubLoopID);
414 
415   if (UnrollResult == LoopUnrollResult::PartiallyUnrolled) {
416     std::optional<MDNode *> NewOuterLoopID = makeFollowupLoopID(
417         OrigOuterLoopID,
418         {LLVMLoopUnrollAndJamFollowupAll, LLVMLoopUnrollAndJamFollowupOuter});
419     if (NewOuterLoopID) {
420       L->setLoopID(*NewOuterLoopID);
421 
422       // Do not setLoopAlreadyUnrolled if a followup was given.
423       return UnrollResult;
424     }
425   }
426 
427   // If loop has an unroll count pragma or unrolled by explicitly set count
428   // mark loop as unrolled to prevent unrolling beyond that requested.
429   if (UnrollResult != LoopUnrollResult::FullyUnrolled && IsCountSetExplicitly)
430     L->setLoopAlreadyUnrolled();
431 
432   return UnrollResult;
433 }
434 
435 static bool tryToUnrollAndJamLoop(LoopNest &LN, DominatorTree &DT, LoopInfo &LI,
436                                   ScalarEvolution &SE,
437                                   const TargetTransformInfo &TTI,
438                                   AssumptionCache &AC, DependenceInfo &DI,
439                                   OptimizationRemarkEmitter &ORE, int OptLevel,
440                                   LPMUpdater &U) {
441   bool DidSomething = false;
442   ArrayRef<Loop *> Loops = LN.getLoops();
443   Loop *OutmostLoop = &LN.getOutermostLoop();
444 
445   // Add the loop nests in the reverse order of LN. See method
446   // declaration.
447   SmallPriorityWorklist<Loop *, 4> Worklist;
448   appendLoopsToWorklist(Loops, Worklist);
449   while (!Worklist.empty()) {
450     Loop *L = Worklist.pop_back_val();
451     std::string LoopName = std::string(L->getName());
452     LoopUnrollResult Result =
453         tryToUnrollAndJamLoop(L, DT, &LI, SE, TTI, AC, DI, ORE, OptLevel);
454     if (Result != LoopUnrollResult::Unmodified)
455       DidSomething = true;
456     if (L == OutmostLoop && Result == LoopUnrollResult::FullyUnrolled)
457       U.markLoopAsDeleted(*L, LoopName);
458   }
459 
460   return DidSomething;
461 }
462 
463 namespace {
464 
465 class LoopUnrollAndJam : public LoopPass {
466 public:
467   static char ID; // Pass ID, replacement for typeid
468   unsigned OptLevel;
469 
470   LoopUnrollAndJam(int OptLevel = 2) : LoopPass(ID), OptLevel(OptLevel) {
471     initializeLoopUnrollAndJamPass(*PassRegistry::getPassRegistry());
472   }
473 
474   bool runOnLoop(Loop *L, LPPassManager &LPM) override {
475     if (skipLoop(L))
476       return false;
477 
478     auto *F = L->getHeader()->getParent();
479     auto &SE = getAnalysis<ScalarEvolutionWrapperPass>().getSE();
480     auto *LI = &getAnalysis<LoopInfoWrapperPass>().getLoopInfo();
481     auto &DI = getAnalysis<DependenceAnalysisWrapperPass>().getDI();
482     auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
483     auto &TTI = getAnalysis<TargetTransformInfoWrapperPass>().getTTI(*F);
484     auto &ORE = getAnalysis<OptimizationRemarkEmitterWrapperPass>().getORE();
485     auto &AC = getAnalysis<AssumptionCacheTracker>().getAssumptionCache(*F);
486 
487     LoopUnrollResult Result =
488         tryToUnrollAndJamLoop(L, DT, LI, SE, TTI, AC, DI, ORE, OptLevel);
489 
490     if (Result == LoopUnrollResult::FullyUnrolled)
491       LPM.markLoopAsDeleted(*L);
492 
493     return Result != LoopUnrollResult::Unmodified;
494   }
495 
496   /// This transformation requires natural loop information & requires that
497   /// loop preheaders be inserted into the CFG...
498   void getAnalysisUsage(AnalysisUsage &AU) const override {
499     AU.addRequired<DominatorTreeWrapperPass>();
500     AU.addRequired<LoopInfoWrapperPass>();
501     AU.addRequired<ScalarEvolutionWrapperPass>();
502     AU.addRequired<TargetTransformInfoWrapperPass>();
503     AU.addRequired<AssumptionCacheTracker>();
504     AU.addRequired<DependenceAnalysisWrapperPass>();
505     AU.addRequired<OptimizationRemarkEmitterWrapperPass>();
506     getLoopAnalysisUsage(AU);
507   }
508 };
509 
510 } // end anonymous namespace
511 
512 char LoopUnrollAndJam::ID = 0;
513 
514 INITIALIZE_PASS_BEGIN(LoopUnrollAndJam, "loop-unroll-and-jam",
515                       "Unroll and Jam loops", false, false)
516 INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
517 INITIALIZE_PASS_DEPENDENCY(LoopPass)
518 INITIALIZE_PASS_DEPENDENCY(LoopInfoWrapperPass)
519 INITIALIZE_PASS_DEPENDENCY(LoopSimplify)
520 INITIALIZE_PASS_DEPENDENCY(LCSSAWrapperPass)
521 INITIALIZE_PASS_DEPENDENCY(ScalarEvolutionWrapperPass)
522 INITIALIZE_PASS_DEPENDENCY(TargetTransformInfoWrapperPass)
523 INITIALIZE_PASS_DEPENDENCY(AssumptionCacheTracker)
524 INITIALIZE_PASS_DEPENDENCY(DependenceAnalysisWrapperPass)
525 INITIALIZE_PASS_DEPENDENCY(OptimizationRemarkEmitterWrapperPass)
526 INITIALIZE_PASS_END(LoopUnrollAndJam, "loop-unroll-and-jam",
527                     "Unroll and Jam loops", false, false)
528 
529 Pass *llvm::createLoopUnrollAndJamPass(int OptLevel) {
530   return new LoopUnrollAndJam(OptLevel);
531 }
532 
533 PreservedAnalyses LoopUnrollAndJamPass::run(LoopNest &LN,
534                                             LoopAnalysisManager &AM,
535                                             LoopStandardAnalysisResults &AR,
536                                             LPMUpdater &U) {
537   Function &F = *LN.getParent();
538 
539   DependenceInfo DI(&F, &AR.AA, &AR.SE, &AR.LI);
540   OptimizationRemarkEmitter ORE(&F);
541 
542   if (!tryToUnrollAndJamLoop(LN, AR.DT, AR.LI, AR.SE, AR.TTI, AR.AC, DI, ORE,
543                              OptLevel, U))
544     return PreservedAnalyses::all();
545 
546   auto PA = getLoopPassPreservedAnalyses();
547   PA.preserve<LoopNestAnalysis>();
548   return PA;
549 }
550