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/Pass.h" 39 #include "llvm/Support/Casting.h" 40 #include "llvm/Support/CommandLine.h" 41 #include "llvm/Support/Debug.h" 42 #include "llvm/Support/ErrorHandling.h" 43 #include "llvm/Support/raw_ostream.h" 44 #include "llvm/Transforms/Scalar.h" 45 #include "llvm/Transforms/Scalar/LoopPassManager.h" 46 #include "llvm/Transforms/Utils.h" 47 #include "llvm/Transforms/Utils/LoopUtils.h" 48 #include "llvm/Transforms/Utils/UnrollLoop.h" 49 #include <algorithm> 50 #include <cassert> 51 #include <cstdint> 52 #include <string> 53 54 using namespace llvm; 55 56 #define DEBUG_TYPE "loop-unroll-and-jam" 57 58 /// @{ 59 /// Metadata attribute names 60 static const char *const LLVMLoopUnrollAndJamFollowupAll = 61 "llvm.loop.unroll_and_jam.followup_all"; 62 static const char *const LLVMLoopUnrollAndJamFollowupInner = 63 "llvm.loop.unroll_and_jam.followup_inner"; 64 static const char *const LLVMLoopUnrollAndJamFollowupOuter = 65 "llvm.loop.unroll_and_jam.followup_outer"; 66 static const char *const LLVMLoopUnrollAndJamFollowupRemainderInner = 67 "llvm.loop.unroll_and_jam.followup_remainder_inner"; 68 static const char *const LLVMLoopUnrollAndJamFollowupRemainderOuter = 69 "llvm.loop.unroll_and_jam.followup_remainder_outer"; 70 /// @} 71 72 static cl::opt<bool> 73 AllowUnrollAndJam("allow-unroll-and-jam", cl::Hidden, 74 cl::desc("Allows loops to be unroll-and-jammed.")); 75 76 static cl::opt<unsigned> UnrollAndJamCount( 77 "unroll-and-jam-count", cl::Hidden, 78 cl::desc("Use this unroll count for all loops including those with " 79 "unroll_and_jam_count pragma values, for testing purposes")); 80 81 static cl::opt<unsigned> UnrollAndJamThreshold( 82 "unroll-and-jam-threshold", cl::init(60), cl::Hidden, 83 cl::desc("Threshold to use for inner loop when doing unroll and jam.")); 84 85 static cl::opt<unsigned> PragmaUnrollAndJamThreshold( 86 "pragma-unroll-and-jam-threshold", cl::init(1024), cl::Hidden, 87 cl::desc("Unrolled size limit for loops with an unroll_and_jam(full) or " 88 "unroll_count pragma.")); 89 90 // Returns the loop hint metadata node with the given name (for example, 91 // "llvm.loop.unroll.count"). If no such metadata node exists, then nullptr is 92 // returned. 93 static MDNode *GetUnrollMetadataForLoop(const Loop *L, StringRef Name) { 94 if (MDNode *LoopID = L->getLoopID()) 95 return GetUnrollMetadata(LoopID, Name); 96 return nullptr; 97 } 98 99 // Returns true if the loop has any metadata starting with Prefix. For example a 100 // Prefix of "llvm.loop.unroll." returns true if we have any unroll metadata. 101 static bool HasAnyUnrollPragma(const Loop *L, StringRef Prefix) { 102 if (MDNode *LoopID = L->getLoopID()) { 103 // First operand should refer to the loop id itself. 104 assert(LoopID->getNumOperands() > 0 && "requires at least one operand"); 105 assert(LoopID->getOperand(0) == LoopID && "invalid loop id"); 106 107 for (unsigned i = 1, e = LoopID->getNumOperands(); i < e; ++i) { 108 MDNode *MD = dyn_cast<MDNode>(LoopID->getOperand(i)); 109 if (!MD) 110 continue; 111 112 MDString *S = dyn_cast<MDString>(MD->getOperand(0)); 113 if (!S) 114 continue; 115 116 if (S->getString().startswith(Prefix)) 117 return true; 118 } 119 } 120 return false; 121 } 122 123 // Returns true if the loop has an unroll_and_jam(enable) pragma. 124 static bool HasUnrollAndJamEnablePragma(const Loop *L) { 125 return GetUnrollMetadataForLoop(L, "llvm.loop.unroll_and_jam.enable"); 126 } 127 128 // If loop has an unroll_and_jam_count pragma return the (necessarily 129 // positive) value from the pragma. Otherwise return 0. 130 static unsigned UnrollAndJamCountPragmaValue(const Loop *L) { 131 MDNode *MD = GetUnrollMetadataForLoop(L, "llvm.loop.unroll_and_jam.count"); 132 if (MD) { 133 assert(MD->getNumOperands() == 2 && 134 "Unroll count hint metadata should have two operands."); 135 unsigned Count = 136 mdconst::extract<ConstantInt>(MD->getOperand(1))->getZExtValue(); 137 assert(Count >= 1 && "Unroll count must be positive."); 138 return Count; 139 } 140 return 0; 141 } 142 143 // Returns loop size estimation for unrolled loop. 144 static uint64_t 145 getUnrollAndJammedLoopSize(unsigned LoopSize, 146 TargetTransformInfo::UnrollingPreferences &UP) { 147 assert(LoopSize >= UP.BEInsns && "LoopSize should not be less than BEInsns!"); 148 return static_cast<uint64_t>(LoopSize - UP.BEInsns) * UP.Count + UP.BEInsns; 149 } 150 151 // Calculates unroll and jam count and writes it to UP.Count. Returns true if 152 // unroll count was set explicitly. 153 static bool computeUnrollAndJamCount( 154 Loop *L, Loop *SubLoop, const TargetTransformInfo &TTI, DominatorTree &DT, 155 LoopInfo *LI, ScalarEvolution &SE, 156 const SmallPtrSetImpl<const Value *> &EphValues, 157 OptimizationRemarkEmitter *ORE, unsigned OuterTripCount, 158 unsigned OuterTripMultiple, unsigned OuterLoopSize, unsigned InnerTripCount, 159 unsigned InnerLoopSize, TargetTransformInfo::UnrollingPreferences &UP) { 160 // First up use computeUnrollCount from the loop unroller to get a count 161 // for unrolling the outer loop, plus any loops requiring explicit 162 // unrolling we leave to the unroller. This uses UP.Threshold / 163 // UP.PartialThreshold / UP.MaxCount to come up with sensible loop values. 164 // We have already checked that the loop has no unroll.* pragmas. 165 unsigned MaxTripCount = 0; 166 bool UseUpperBound = false; 167 bool ExplicitUnroll = computeUnrollCount( 168 L, TTI, DT, LI, SE, EphValues, ORE, OuterTripCount, MaxTripCount, 169 /*MaxOrZero*/ false, OuterTripMultiple, OuterLoopSize, UP, UseUpperBound); 170 if (ExplicitUnroll || UseUpperBound) { 171 // If the user explicitly set the loop as unrolled, dont UnJ it. Leave it 172 // for the unroller instead. 173 LLVM_DEBUG(dbgs() << "Won't unroll-and-jam; explicit count set by " 174 "computeUnrollCount\n"); 175 UP.Count = 0; 176 return false; 177 } 178 179 // Override with any explicit Count from the "unroll-and-jam-count" option. 180 bool UserUnrollCount = UnrollAndJamCount.getNumOccurrences() > 0; 181 if (UserUnrollCount) { 182 UP.Count = UnrollAndJamCount; 183 UP.Force = true; 184 if (UP.AllowRemainder && 185 getUnrollAndJammedLoopSize(OuterLoopSize, UP) < UP.Threshold && 186 getUnrollAndJammedLoopSize(InnerLoopSize, UP) < 187 UP.UnrollAndJamInnerLoopThreshold) 188 return true; 189 } 190 191 // Check for unroll_and_jam pragmas 192 unsigned PragmaCount = UnrollAndJamCountPragmaValue(L); 193 if (PragmaCount > 0) { 194 UP.Count = PragmaCount; 195 UP.Runtime = true; 196 UP.Force = true; 197 if ((UP.AllowRemainder || (OuterTripMultiple % PragmaCount == 0)) && 198 getUnrollAndJammedLoopSize(OuterLoopSize, UP) < UP.Threshold && 199 getUnrollAndJammedLoopSize(InnerLoopSize, UP) < 200 UP.UnrollAndJamInnerLoopThreshold) 201 return true; 202 } 203 204 bool PragmaEnableUnroll = HasUnrollAndJamEnablePragma(L); 205 bool ExplicitUnrollAndJamCount = PragmaCount > 0 || UserUnrollCount; 206 bool ExplicitUnrollAndJam = PragmaEnableUnroll || ExplicitUnrollAndJamCount; 207 208 // If the loop has an unrolling pragma, we want to be more aggressive with 209 // unrolling limits. 210 if (ExplicitUnrollAndJam) 211 UP.UnrollAndJamInnerLoopThreshold = PragmaUnrollAndJamThreshold; 212 213 if (!UP.AllowRemainder && getUnrollAndJammedLoopSize(InnerLoopSize, UP) >= 214 UP.UnrollAndJamInnerLoopThreshold) { 215 LLVM_DEBUG(dbgs() << "Won't unroll-and-jam; can't create remainder and " 216 "inner loop too large\n"); 217 UP.Count = 0; 218 return false; 219 } 220 221 // We have a sensible limit for the outer loop, now adjust it for the inner 222 // loop and UP.UnrollAndJamInnerLoopThreshold. If the outer limit was set 223 // explicitly, we want to stick to it. 224 if (!ExplicitUnrollAndJamCount && UP.AllowRemainder) { 225 while (UP.Count != 0 && getUnrollAndJammedLoopSize(InnerLoopSize, UP) >= 226 UP.UnrollAndJamInnerLoopThreshold) 227 UP.Count--; 228 } 229 230 // If we are explicitly unroll and jamming, we are done. Otherwise there are a 231 // number of extra performance heuristics to check. 232 if (ExplicitUnrollAndJam) 233 return true; 234 235 // If the inner loop count is known and small, leave the entire loop nest to 236 // be the unroller 237 if (InnerTripCount && InnerLoopSize * InnerTripCount < UP.Threshold) { 238 LLVM_DEBUG(dbgs() << "Won't unroll-and-jam; small inner loop count is " 239 "being left for the unroller\n"); 240 UP.Count = 0; 241 return false; 242 } 243 244 // Check for situations where UnJ is likely to be unprofitable. Including 245 // subloops with more than 1 block. 246 if (SubLoop->getBlocks().size() != 1) { 247 LLVM_DEBUG( 248 dbgs() << "Won't unroll-and-jam; More than one inner loop block\n"); 249 UP.Count = 0; 250 return false; 251 } 252 253 // Limit to loops where there is something to gain from unrolling and 254 // jamming the loop. In this case, look for loads that are invariant in the 255 // outer loop and can become shared. 256 unsigned NumInvariant = 0; 257 for (BasicBlock *BB : SubLoop->getBlocks()) { 258 for (Instruction &I : *BB) { 259 if (auto *Ld = dyn_cast<LoadInst>(&I)) { 260 Value *V = Ld->getPointerOperand(); 261 const SCEV *LSCEV = SE.getSCEVAtScope(V, L); 262 if (SE.isLoopInvariant(LSCEV, L)) 263 NumInvariant++; 264 } 265 } 266 } 267 if (NumInvariant == 0) { 268 LLVM_DEBUG(dbgs() << "Won't unroll-and-jam; No loop invariant loads\n"); 269 UP.Count = 0; 270 return false; 271 } 272 273 return false; 274 } 275 276 static LoopUnrollResult 277 tryToUnrollAndJamLoop(Loop *L, DominatorTree &DT, LoopInfo *LI, 278 ScalarEvolution &SE, const TargetTransformInfo &TTI, 279 AssumptionCache &AC, DependenceInfo &DI, 280 OptimizationRemarkEmitter &ORE, int OptLevel) { 281 // Quick checks of the correct loop form 282 if (!L->isLoopSimplifyForm() || L->getSubLoops().size() != 1) 283 return LoopUnrollResult::Unmodified; 284 Loop *SubLoop = L->getSubLoops()[0]; 285 if (!SubLoop->isLoopSimplifyForm()) 286 return LoopUnrollResult::Unmodified; 287 288 BasicBlock *Latch = L->getLoopLatch(); 289 BasicBlock *Exit = L->getExitingBlock(); 290 BasicBlock *SubLoopLatch = SubLoop->getLoopLatch(); 291 BasicBlock *SubLoopExit = SubLoop->getExitingBlock(); 292 293 if (Latch != Exit || SubLoopLatch != SubLoopExit) 294 return LoopUnrollResult::Unmodified; 295 296 TargetTransformInfo::UnrollingPreferences UP = 297 gatherUnrollingPreferences(L, SE, TTI, nullptr, nullptr, OptLevel, None, 298 None, None, None, None, None, None, None); 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 TransformationMode EnableMode = hasUnrollAndJamTransformation(L); 312 if (EnableMode & TM_Disable) 313 return LoopUnrollResult::Unmodified; 314 315 // A loop with any unroll pragma (enabling/disabling/count/etc) is left for 316 // the unroller, so long as it does not explicitly have unroll_and_jam 317 // metadata. This means #pragma nounroll will disable unroll and jam as well 318 // as unrolling 319 if (HasAnyUnrollPragma(L, "llvm.loop.unroll.") && 320 !HasAnyUnrollPragma(L, "llvm.loop.unroll_and_jam.")) { 321 LLVM_DEBUG(dbgs() << " Disabled due to pragma.\n"); 322 return LoopUnrollResult::Unmodified; 323 } 324 325 if (!isSafeToUnrollAndJam(L, SE, DT, DI)) { 326 LLVM_DEBUG(dbgs() << " Disabled due to not being safe.\n"); 327 return LoopUnrollResult::Unmodified; 328 } 329 330 // Approximate the loop size and collect useful info 331 unsigned NumInlineCandidates; 332 bool NotDuplicatable; 333 bool Convergent; 334 SmallPtrSet<const Value *, 32> EphValues; 335 CodeMetrics::collectEphemeralValues(L, &AC, EphValues); 336 unsigned InnerLoopSize = 337 ApproximateLoopSize(SubLoop, NumInlineCandidates, NotDuplicatable, 338 Convergent, TTI, EphValues, UP.BEInsns); 339 unsigned OuterLoopSize = 340 ApproximateLoopSize(L, NumInlineCandidates, NotDuplicatable, Convergent, 341 TTI, EphValues, UP.BEInsns); 342 LLVM_DEBUG(dbgs() << " Outer Loop Size: " << OuterLoopSize << "\n"); 343 LLVM_DEBUG(dbgs() << " Inner Loop Size: " << InnerLoopSize << "\n"); 344 if (NotDuplicatable) { 345 LLVM_DEBUG(dbgs() << " Not unrolling loop which contains non-duplicatable " 346 "instructions.\n"); 347 return LoopUnrollResult::Unmodified; 348 } 349 if (NumInlineCandidates != 0) { 350 LLVM_DEBUG(dbgs() << " Not unrolling loop with inlinable calls.\n"); 351 return LoopUnrollResult::Unmodified; 352 } 353 if (Convergent) { 354 LLVM_DEBUG( 355 dbgs() << " Not unrolling loop with convergent instructions.\n"); 356 return LoopUnrollResult::Unmodified; 357 } 358 359 // Save original loop IDs for after the transformation. 360 MDNode *OrigOuterLoopID = L->getLoopID(); 361 MDNode *OrigSubLoopID = SubLoop->getLoopID(); 362 363 // To assign the loop id of the epilogue, assign it before unrolling it so it 364 // is applied to every inner loop of the epilogue. We later apply the loop ID 365 // for the jammed inner loop. 366 Optional<MDNode *> NewInnerEpilogueLoopID = makeFollowupLoopID( 367 OrigOuterLoopID, {LLVMLoopUnrollAndJamFollowupAll, 368 LLVMLoopUnrollAndJamFollowupRemainderInner}); 369 if (NewInnerEpilogueLoopID.hasValue()) 370 SubLoop->setLoopID(NewInnerEpilogueLoopID.getValue()); 371 372 // Find trip count and trip multiple 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); 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, &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 namespace { 430 431 class LoopUnrollAndJam : public LoopPass { 432 public: 433 static char ID; // Pass ID, replacement for typeid 434 unsigned OptLevel; 435 436 LoopUnrollAndJam(int OptLevel = 2) : LoopPass(ID), OptLevel(OptLevel) { 437 initializeLoopUnrollAndJamPass(*PassRegistry::getPassRegistry()); 438 } 439 440 bool runOnLoop(Loop *L, LPPassManager &LPM) override { 441 if (skipLoop(L)) 442 return false; 443 444 Function &F = *L->getHeader()->getParent(); 445 446 auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree(); 447 LoopInfo *LI = &getAnalysis<LoopInfoWrapperPass>().getLoopInfo(); 448 ScalarEvolution &SE = getAnalysis<ScalarEvolutionWrapperPass>().getSE(); 449 const TargetTransformInfo &TTI = 450 getAnalysis<TargetTransformInfoWrapperPass>().getTTI(F); 451 auto &AC = getAnalysis<AssumptionCacheTracker>().getAssumptionCache(F); 452 auto &DI = getAnalysis<DependenceAnalysisWrapperPass>().getDI(); 453 // For the old PM, we can't use OptimizationRemarkEmitter as an analysis 454 // pass. Function analyses need to be preserved across loop transformations 455 // but ORE cannot be preserved (see comment before the pass definition). 456 OptimizationRemarkEmitter ORE(&F); 457 458 LoopUnrollResult Result = 459 tryToUnrollAndJamLoop(L, DT, LI, SE, TTI, AC, DI, ORE, OptLevel); 460 461 if (Result == LoopUnrollResult::FullyUnrolled) 462 LPM.markLoopAsDeleted(*L); 463 464 return Result != LoopUnrollResult::Unmodified; 465 } 466 467 /// This transformation requires natural loop information & requires that 468 /// loop preheaders be inserted into the CFG... 469 void getAnalysisUsage(AnalysisUsage &AU) const override { 470 AU.addRequired<AssumptionCacheTracker>(); 471 AU.addRequired<TargetTransformInfoWrapperPass>(); 472 AU.addRequired<DependenceAnalysisWrapperPass>(); 473 getLoopAnalysisUsage(AU); 474 } 475 }; 476 477 } // end anonymous namespace 478 479 char LoopUnrollAndJam::ID = 0; 480 481 INITIALIZE_PASS_BEGIN(LoopUnrollAndJam, "loop-unroll-and-jam", 482 "Unroll and Jam loops", false, false) 483 INITIALIZE_PASS_DEPENDENCY(AssumptionCacheTracker) 484 INITIALIZE_PASS_DEPENDENCY(LoopPass) 485 INITIALIZE_PASS_DEPENDENCY(TargetTransformInfoWrapperPass) 486 INITIALIZE_PASS_DEPENDENCY(DependenceAnalysisWrapperPass) 487 INITIALIZE_PASS_END(LoopUnrollAndJam, "loop-unroll-and-jam", 488 "Unroll and Jam loops", false, false) 489 490 Pass *llvm::createLoopUnrollAndJamPass(int OptLevel) { 491 return new LoopUnrollAndJam(OptLevel); 492 } 493 494 PreservedAnalyses LoopUnrollAndJamPass::run(Loop &L, LoopAnalysisManager &AM, 495 LoopStandardAnalysisResults &AR, 496 LPMUpdater &) { 497 const auto &FAM = 498 AM.getResult<FunctionAnalysisManagerLoopProxy>(L, AR).getManager(); 499 Function *F = L.getHeader()->getParent(); 500 501 auto *ORE = FAM.getCachedResult<OptimizationRemarkEmitterAnalysis>(*F); 502 // FIXME: This should probably be optional rather than required. 503 if (!ORE) 504 report_fatal_error( 505 "LoopUnrollAndJamPass: OptimizationRemarkEmitterAnalysis not cached at " 506 "a higher level"); 507 508 DependenceInfo DI(F, &AR.AA, &AR.SE, &AR.LI); 509 510 LoopUnrollResult Result = tryToUnrollAndJamLoop( 511 &L, AR.DT, &AR.LI, AR.SE, AR.TTI, AR.AC, DI, *ORE, OptLevel); 512 513 if (Result == LoopUnrollResult::Unmodified) 514 return PreservedAnalyses::all(); 515 516 return getLoopPassPreservedAnalyses(); 517 } 518