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