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 55 using namespace llvm; 56 57 #define DEBUG_TYPE "loop-unroll-and-jam" 58 59 /// @{ 60 /// Metadata attribute names 61 static const char *const LLVMLoopUnrollAndJamFollowupAll = 62 "llvm.loop.unroll_and_jam.followup_all"; 63 static const char *const LLVMLoopUnrollAndJamFollowupInner = 64 "llvm.loop.unroll_and_jam.followup_inner"; 65 static const char *const LLVMLoopUnrollAndJamFollowupOuter = 66 "llvm.loop.unroll_and_jam.followup_outer"; 67 static const char *const LLVMLoopUnrollAndJamFollowupRemainderInner = 68 "llvm.loop.unroll_and_jam.followup_remainder_inner"; 69 static const char *const LLVMLoopUnrollAndJamFollowupRemainderOuter = 70 "llvm.loop.unroll_and_jam.followup_remainder_outer"; 71 /// @} 72 73 static cl::opt<bool> 74 AllowUnrollAndJam("allow-unroll-and-jam", cl::Hidden, 75 cl::desc("Allows loops to be unroll-and-jammed.")); 76 77 static 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 82 static 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 86 static 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. 94 static 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. 102 static 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. 125 static 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. 131 static 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. 145 static uint64_t 146 getUnrollAndJammedLoopSize(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. 154 static 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 277 static LoopUnrollResult 278 tryToUnrollAndJamLoop(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 430 static 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 463 namespace { 464 465 class LoopUnrollAndJam : public FunctionPass { 466 public: 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 505 char LoopUnrollAndJam::ID = 0; 506 507 INITIALIZE_PASS_BEGIN(LoopUnrollAndJam, "loop-unroll-and-jam", 508 "Unroll and Jam loops", false, false) 509 INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass) 510 INITIALIZE_PASS_DEPENDENCY(LoopInfoWrapperPass) 511 INITIALIZE_PASS_DEPENDENCY(ScalarEvolutionWrapperPass) 512 INITIALIZE_PASS_DEPENDENCY(TargetTransformInfoWrapperPass) 513 INITIALIZE_PASS_DEPENDENCY(AssumptionCacheTracker) 514 INITIALIZE_PASS_DEPENDENCY(DependenceAnalysisWrapperPass) 515 INITIALIZE_PASS_DEPENDENCY(OptimizationRemarkEmitterWrapperPass) 516 INITIALIZE_PASS_END(LoopUnrollAndJam, "loop-unroll-and-jam", 517 "Unroll and Jam loops", false, false) 518 519 Pass *llvm::createLoopUnrollAndJamPass(int OptLevel) { 520 return new LoopUnrollAndJam(OptLevel); 521 } 522 523 PreservedAnalyses 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