llvm/lib/Transforms/Scalar/LoopUnrollAndJamPass.cpp

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