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