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