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
51namespace llvm {
52class Instruction;
53class Value;
54} // namespace llvm
55
56using namespace llvm;
57
58#define DEBUG_TYPE "loop-unroll-and-jam"
59
60/// @{
61/// Metadata attribute names
62static const char *const LLVMLoopUnrollAndJamFollowupAll =
63    "llvm.loop.unroll_and_jam.followup_all";
64static const char *const LLVMLoopUnrollAndJamFollowupInner =
65    "llvm.loop.unroll_and_jam.followup_inner";
66static const char *const LLVMLoopUnrollAndJamFollowupOuter =
67    "llvm.loop.unroll_and_jam.followup_outer";
68static const char *const LLVMLoopUnrollAndJamFollowupRemainderInner =
69    "llvm.loop.unroll_and_jam.followup_remainder_inner";
70static const char *const LLVMLoopUnrollAndJamFollowupRemainderOuter =
71    "llvm.loop.unroll_and_jam.followup_remainder_outer";
72/// @}
73
74static cl::opt<bool>
75    AllowUnrollAndJam("allow-unroll-and-jam", cl::Hidden,
76                      cl::desc("Allows loops to be unroll-and-jammed."));
77
78static 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
83static 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
87static 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.
95static 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.
103static 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.
126static 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.
132static 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.
146static uint64_t
147getUnrollAndJammedLoopSize(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.
155static 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
280static LoopUnrollResult
281tryToUnrollAndJamLoop(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
435static 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
463namespace {
464
465class LoopUnrollAndJam : public LoopPass {
466public:
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
512char LoopUnrollAndJam::ID = 0;
513
514INITIALIZE_PASS_BEGIN(LoopUnrollAndJam, "loop-unroll-and-jam",
515                      "Unroll and Jam loops", false, false)
516INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
517INITIALIZE_PASS_DEPENDENCY(LoopPass)
518INITIALIZE_PASS_DEPENDENCY(LoopInfoWrapperPass)
519INITIALIZE_PASS_DEPENDENCY(LoopSimplify)
520INITIALIZE_PASS_DEPENDENCY(LCSSAWrapperPass)
521INITIALIZE_PASS_DEPENDENCY(ScalarEvolutionWrapperPass)
522INITIALIZE_PASS_DEPENDENCY(TargetTransformInfoWrapperPass)
523INITIALIZE_PASS_DEPENDENCY(AssumptionCacheTracker)
524INITIALIZE_PASS_DEPENDENCY(DependenceAnalysisWrapperPass)
525INITIALIZE_PASS_DEPENDENCY(OptimizationRemarkEmitterWrapperPass)
526INITIALIZE_PASS_END(LoopUnrollAndJam, "loop-unroll-and-jam",
527                    "Unroll and Jam loops", false, false)
528
529Pass *llvm::createLoopUnrollAndJamPass(int OptLevel) {
530  return new LoopUnrollAndJam(OptLevel);
531}
532
533PreservedAnalyses 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