1 //===- LoopUnroll.cpp - Loop unroller 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 a simple loop unroller. It works best when loops have 10 // been canonicalized by the -indvars pass, allowing it to determine the trip 11 // counts of loops easily. 12 //===----------------------------------------------------------------------===// 13 14 #include "llvm/Transforms/Scalar/LoopUnrollPass.h" 15 #include "llvm/ADT/DenseMap.h" 16 #include "llvm/ADT/DenseMapInfo.h" 17 #include "llvm/ADT/DenseSet.h" 18 #include "llvm/ADT/None.h" 19 #include "llvm/ADT/Optional.h" 20 #include "llvm/ADT/STLExtras.h" 21 #include "llvm/ADT/SetVector.h" 22 #include "llvm/ADT/SmallPtrSet.h" 23 #include "llvm/ADT/SmallVector.h" 24 #include "llvm/ADT/StringRef.h" 25 #include "llvm/Analysis/AssumptionCache.h" 26 #include "llvm/Analysis/CodeMetrics.h" 27 #include "llvm/Analysis/LoopAnalysisManager.h" 28 #include "llvm/Analysis/LoopInfo.h" 29 #include "llvm/Analysis/LoopPass.h" 30 #include "llvm/Analysis/LoopUnrollAnalyzer.h" 31 #include "llvm/Analysis/OptimizationRemarkEmitter.h" 32 #include "llvm/Analysis/ProfileSummaryInfo.h" 33 #include "llvm/Analysis/ScalarEvolution.h" 34 #include "llvm/Analysis/TargetTransformInfo.h" 35 #include "llvm/IR/BasicBlock.h" 36 #include "llvm/IR/CFG.h" 37 #include "llvm/IR/Constant.h" 38 #include "llvm/IR/Constants.h" 39 #include "llvm/IR/DiagnosticInfo.h" 40 #include "llvm/IR/Dominators.h" 41 #include "llvm/IR/Function.h" 42 #include "llvm/IR/Instruction.h" 43 #include "llvm/IR/Instructions.h" 44 #include "llvm/IR/IntrinsicInst.h" 45 #include "llvm/IR/Metadata.h" 46 #include "llvm/IR/PassManager.h" 47 #include "llvm/Pass.h" 48 #include "llvm/Support/Casting.h" 49 #include "llvm/Support/CommandLine.h" 50 #include "llvm/Support/Debug.h" 51 #include "llvm/Support/ErrorHandling.h" 52 #include "llvm/Support/raw_ostream.h" 53 #include "llvm/Transforms/Scalar.h" 54 #include "llvm/Transforms/Scalar/LoopPassManager.h" 55 #include "llvm/Transforms/Utils.h" 56 #include "llvm/Transforms/Utils/LoopSimplify.h" 57 #include "llvm/Transforms/Utils/LoopUtils.h" 58 #include "llvm/Transforms/Utils/UnrollLoop.h" 59 #include <algorithm> 60 #include <cassert> 61 #include <cstdint> 62 #include <limits> 63 #include <string> 64 #include <tuple> 65 #include <utility> 66 67 using namespace llvm; 68 69 #define DEBUG_TYPE "loop-unroll" 70 71 static cl::opt<unsigned> 72 UnrollThreshold("unroll-threshold", cl::Hidden, 73 cl::desc("The cost threshold for loop unrolling")); 74 75 static cl::opt<unsigned> UnrollPartialThreshold( 76 "unroll-partial-threshold", cl::Hidden, 77 cl::desc("The cost threshold for partial loop unrolling")); 78 79 static cl::opt<unsigned> UnrollMaxPercentThresholdBoost( 80 "unroll-max-percent-threshold-boost", cl::init(400), cl::Hidden, 81 cl::desc("The maximum 'boost' (represented as a percentage >= 100) applied " 82 "to the threshold when aggressively unrolling a loop due to the " 83 "dynamic cost savings. If completely unrolling a loop will reduce " 84 "the total runtime from X to Y, we boost the loop unroll " 85 "threshold to DefaultThreshold*std::min(MaxPercentThresholdBoost, " 86 "X/Y). This limit avoids excessive code bloat.")); 87 88 static cl::opt<unsigned> UnrollMaxIterationsCountToAnalyze( 89 "unroll-max-iteration-count-to-analyze", cl::init(10), cl::Hidden, 90 cl::desc("Don't allow loop unrolling to simulate more than this number of" 91 "iterations when checking full unroll profitability")); 92 93 static cl::opt<unsigned> UnrollCount( 94 "unroll-count", cl::Hidden, 95 cl::desc("Use this unroll count for all loops including those with " 96 "unroll_count pragma values, for testing purposes")); 97 98 static cl::opt<unsigned> UnrollMaxCount( 99 "unroll-max-count", cl::Hidden, 100 cl::desc("Set the max unroll count for partial and runtime unrolling, for" 101 "testing purposes")); 102 103 static cl::opt<unsigned> UnrollFullMaxCount( 104 "unroll-full-max-count", cl::Hidden, 105 cl::desc( 106 "Set the max unroll count for full unrolling, for testing purposes")); 107 108 static cl::opt<unsigned> UnrollPeelCount( 109 "unroll-peel-count", cl::Hidden, 110 cl::desc("Set the unroll peeling count, for testing purposes")); 111 112 static cl::opt<bool> 113 UnrollAllowPartial("unroll-allow-partial", cl::Hidden, 114 cl::desc("Allows loops to be partially unrolled until " 115 "-unroll-threshold loop size is reached.")); 116 117 static cl::opt<bool> UnrollAllowRemainder( 118 "unroll-allow-remainder", cl::Hidden, 119 cl::desc("Allow generation of a loop remainder (extra iterations) " 120 "when unrolling a loop.")); 121 122 static cl::opt<bool> 123 UnrollRuntime("unroll-runtime", cl::ZeroOrMore, cl::Hidden, 124 cl::desc("Unroll loops with run-time trip counts")); 125 126 static cl::opt<unsigned> UnrollMaxUpperBound( 127 "unroll-max-upperbound", cl::init(8), cl::Hidden, 128 cl::desc( 129 "The max of trip count upper bound that is considered in unrolling")); 130 131 static cl::opt<unsigned> PragmaUnrollThreshold( 132 "pragma-unroll-threshold", cl::init(16 * 1024), cl::Hidden, 133 cl::desc("Unrolled size limit for loops with an unroll(full) or " 134 "unroll_count pragma.")); 135 136 static cl::opt<unsigned> FlatLoopTripCountThreshold( 137 "flat-loop-tripcount-threshold", cl::init(5), cl::Hidden, 138 cl::desc("If the runtime tripcount for the loop is lower than the " 139 "threshold, the loop is considered as flat and will be less " 140 "aggressively unrolled.")); 141 142 static cl::opt<bool> 143 UnrollAllowPeeling("unroll-allow-peeling", cl::init(true), cl::Hidden, 144 cl::desc("Allows loops to be peeled when the dynamic " 145 "trip count is known to be low.")); 146 147 static cl::opt<bool> UnrollUnrollRemainder( 148 "unroll-remainder", cl::Hidden, 149 cl::desc("Allow the loop remainder to be unrolled.")); 150 151 // This option isn't ever intended to be enabled, it serves to allow 152 // experiments to check the assumptions about when this kind of revisit is 153 // necessary. 154 static cl::opt<bool> UnrollRevisitChildLoops( 155 "unroll-revisit-child-loops", cl::Hidden, 156 cl::desc("Enqueue and re-visit child loops in the loop PM after unrolling. " 157 "This shouldn't typically be needed as child loops (or their " 158 "clones) were already visited.")); 159 160 /// A magic value for use with the Threshold parameter to indicate 161 /// that the loop unroll should be performed regardless of how much 162 /// code expansion would result. 163 static const unsigned NoThreshold = std::numeric_limits<unsigned>::max(); 164 165 /// Gather the various unrolling parameters based on the defaults, compiler 166 /// flags, TTI overrides and user specified parameters. 167 TargetTransformInfo::UnrollingPreferences llvm::gatherUnrollingPreferences( 168 Loop *L, ScalarEvolution &SE, const TargetTransformInfo &TTI, int OptLevel, 169 Optional<unsigned> UserThreshold, Optional<unsigned> UserCount, 170 Optional<bool> UserAllowPartial, Optional<bool> UserRuntime, 171 Optional<bool> UserUpperBound, Optional<bool> UserAllowPeeling) { 172 TargetTransformInfo::UnrollingPreferences UP; 173 174 // Set up the defaults 175 UP.Threshold = OptLevel > 2 ? 300 : 150; 176 UP.MaxPercentThresholdBoost = 400; 177 UP.OptSizeThreshold = 0; 178 UP.PartialThreshold = 150; 179 UP.PartialOptSizeThreshold = 0; 180 UP.Count = 0; 181 UP.PeelCount = 0; 182 UP.DefaultUnrollRuntimeCount = 8; 183 UP.MaxCount = std::numeric_limits<unsigned>::max(); 184 UP.FullUnrollMaxCount = std::numeric_limits<unsigned>::max(); 185 UP.BEInsns = 2; 186 UP.Partial = false; 187 UP.Runtime = false; 188 UP.AllowRemainder = true; 189 UP.UnrollRemainder = false; 190 UP.AllowExpensiveTripCount = false; 191 UP.Force = false; 192 UP.UpperBound = false; 193 UP.AllowPeeling = true; 194 UP.UnrollAndJam = false; 195 UP.UnrollAndJamInnerLoopThreshold = 60; 196 197 // Override with any target specific settings 198 TTI.getUnrollingPreferences(L, SE, UP); 199 200 // Apply size attributes 201 if (L->getHeader()->getParent()->optForSize()) { 202 UP.Threshold = UP.OptSizeThreshold; 203 UP.PartialThreshold = UP.PartialOptSizeThreshold; 204 } 205 206 // Apply any user values specified by cl::opt 207 if (UnrollThreshold.getNumOccurrences() > 0) 208 UP.Threshold = UnrollThreshold; 209 if (UnrollPartialThreshold.getNumOccurrences() > 0) 210 UP.PartialThreshold = UnrollPartialThreshold; 211 if (UnrollMaxPercentThresholdBoost.getNumOccurrences() > 0) 212 UP.MaxPercentThresholdBoost = UnrollMaxPercentThresholdBoost; 213 if (UnrollMaxCount.getNumOccurrences() > 0) 214 UP.MaxCount = UnrollMaxCount; 215 if (UnrollFullMaxCount.getNumOccurrences() > 0) 216 UP.FullUnrollMaxCount = UnrollFullMaxCount; 217 if (UnrollPeelCount.getNumOccurrences() > 0) 218 UP.PeelCount = UnrollPeelCount; 219 if (UnrollAllowPartial.getNumOccurrences() > 0) 220 UP.Partial = UnrollAllowPartial; 221 if (UnrollAllowRemainder.getNumOccurrences() > 0) 222 UP.AllowRemainder = UnrollAllowRemainder; 223 if (UnrollRuntime.getNumOccurrences() > 0) 224 UP.Runtime = UnrollRuntime; 225 if (UnrollMaxUpperBound == 0) 226 UP.UpperBound = false; 227 if (UnrollAllowPeeling.getNumOccurrences() > 0) 228 UP.AllowPeeling = UnrollAllowPeeling; 229 if (UnrollUnrollRemainder.getNumOccurrences() > 0) 230 UP.UnrollRemainder = UnrollUnrollRemainder; 231 232 // Apply user values provided by argument 233 if (UserThreshold.hasValue()) { 234 UP.Threshold = *UserThreshold; 235 UP.PartialThreshold = *UserThreshold; 236 } 237 if (UserCount.hasValue()) 238 UP.Count = *UserCount; 239 if (UserAllowPartial.hasValue()) 240 UP.Partial = *UserAllowPartial; 241 if (UserRuntime.hasValue()) 242 UP.Runtime = *UserRuntime; 243 if (UserUpperBound.hasValue()) 244 UP.UpperBound = *UserUpperBound; 245 if (UserAllowPeeling.hasValue()) 246 UP.AllowPeeling = *UserAllowPeeling; 247 248 return UP; 249 } 250 251 namespace { 252 253 /// A struct to densely store the state of an instruction after unrolling at 254 /// each iteration. 255 /// 256 /// This is designed to work like a tuple of <Instruction *, int> for the 257 /// purposes of hashing and lookup, but to be able to associate two boolean 258 /// states with each key. 259 struct UnrolledInstState { 260 Instruction *I; 261 int Iteration : 30; 262 unsigned IsFree : 1; 263 unsigned IsCounted : 1; 264 }; 265 266 /// Hashing and equality testing for a set of the instruction states. 267 struct UnrolledInstStateKeyInfo { 268 using PtrInfo = DenseMapInfo<Instruction *>; 269 using PairInfo = DenseMapInfo<std::pair<Instruction *, int>>; 270 271 static inline UnrolledInstState getEmptyKey() { 272 return {PtrInfo::getEmptyKey(), 0, 0, 0}; 273 } 274 275 static inline UnrolledInstState getTombstoneKey() { 276 return {PtrInfo::getTombstoneKey(), 0, 0, 0}; 277 } 278 279 static inline unsigned getHashValue(const UnrolledInstState &S) { 280 return PairInfo::getHashValue({S.I, S.Iteration}); 281 } 282 283 static inline bool isEqual(const UnrolledInstState &LHS, 284 const UnrolledInstState &RHS) { 285 return PairInfo::isEqual({LHS.I, LHS.Iteration}, {RHS.I, RHS.Iteration}); 286 } 287 }; 288 289 struct EstimatedUnrollCost { 290 /// The estimated cost after unrolling. 291 unsigned UnrolledCost; 292 293 /// The estimated dynamic cost of executing the instructions in the 294 /// rolled form. 295 unsigned RolledDynamicCost; 296 }; 297 298 } // end anonymous namespace 299 300 /// Figure out if the loop is worth full unrolling. 301 /// 302 /// Complete loop unrolling can make some loads constant, and we need to know 303 /// if that would expose any further optimization opportunities. This routine 304 /// estimates this optimization. It computes cost of unrolled loop 305 /// (UnrolledCost) and dynamic cost of the original loop (RolledDynamicCost). By 306 /// dynamic cost we mean that we won't count costs of blocks that are known not 307 /// to be executed (i.e. if we have a branch in the loop and we know that at the 308 /// given iteration its condition would be resolved to true, we won't add up the 309 /// cost of the 'false'-block). 310 /// \returns Optional value, holding the RolledDynamicCost and UnrolledCost. If 311 /// the analysis failed (no benefits expected from the unrolling, or the loop is 312 /// too big to analyze), the returned value is None. 313 static Optional<EstimatedUnrollCost> analyzeLoopUnrollCost( 314 const Loop *L, unsigned TripCount, DominatorTree &DT, ScalarEvolution &SE, 315 const SmallPtrSetImpl<const Value *> &EphValues, 316 const TargetTransformInfo &TTI, unsigned MaxUnrolledLoopSize) { 317 // We want to be able to scale offsets by the trip count and add more offsets 318 // to them without checking for overflows, and we already don't want to 319 // analyze *massive* trip counts, so we force the max to be reasonably small. 320 assert(UnrollMaxIterationsCountToAnalyze < 321 (unsigned)(std::numeric_limits<int>::max() / 2) && 322 "The unroll iterations max is too large!"); 323 324 // Only analyze inner loops. We can't properly estimate cost of nested loops 325 // and we won't visit inner loops again anyway. 326 if (!L->empty()) 327 return None; 328 329 // Don't simulate loops with a big or unknown tripcount 330 if (!UnrollMaxIterationsCountToAnalyze || !TripCount || 331 TripCount > UnrollMaxIterationsCountToAnalyze) 332 return None; 333 334 SmallSetVector<BasicBlock *, 16> BBWorklist; 335 SmallSetVector<std::pair<BasicBlock *, BasicBlock *>, 4> ExitWorklist; 336 DenseMap<Value *, Constant *> SimplifiedValues; 337 SmallVector<std::pair<Value *, Constant *>, 4> SimplifiedInputValues; 338 339 // The estimated cost of the unrolled form of the loop. We try to estimate 340 // this by simplifying as much as we can while computing the estimate. 341 unsigned UnrolledCost = 0; 342 343 // We also track the estimated dynamic (that is, actually executed) cost in 344 // the rolled form. This helps identify cases when the savings from unrolling 345 // aren't just exposing dead control flows, but actual reduced dynamic 346 // instructions due to the simplifications which we expect to occur after 347 // unrolling. 348 unsigned RolledDynamicCost = 0; 349 350 // We track the simplification of each instruction in each iteration. We use 351 // this to recursively merge costs into the unrolled cost on-demand so that 352 // we don't count the cost of any dead code. This is essentially a map from 353 // <instruction, int> to <bool, bool>, but stored as a densely packed struct. 354 DenseSet<UnrolledInstState, UnrolledInstStateKeyInfo> InstCostMap; 355 356 // A small worklist used to accumulate cost of instructions from each 357 // observable and reached root in the loop. 358 SmallVector<Instruction *, 16> CostWorklist; 359 360 // PHI-used worklist used between iterations while accumulating cost. 361 SmallVector<Instruction *, 4> PHIUsedList; 362 363 // Helper function to accumulate cost for instructions in the loop. 364 auto AddCostRecursively = [&](Instruction &RootI, int Iteration) { 365 assert(Iteration >= 0 && "Cannot have a negative iteration!"); 366 assert(CostWorklist.empty() && "Must start with an empty cost list"); 367 assert(PHIUsedList.empty() && "Must start with an empty phi used list"); 368 CostWorklist.push_back(&RootI); 369 for (;; --Iteration) { 370 do { 371 Instruction *I = CostWorklist.pop_back_val(); 372 373 // InstCostMap only uses I and Iteration as a key, the other two values 374 // don't matter here. 375 auto CostIter = InstCostMap.find({I, Iteration, 0, 0}); 376 if (CostIter == InstCostMap.end()) 377 // If an input to a PHI node comes from a dead path through the loop 378 // we may have no cost data for it here. What that actually means is 379 // that it is free. 380 continue; 381 auto &Cost = *CostIter; 382 if (Cost.IsCounted) 383 // Already counted this instruction. 384 continue; 385 386 // Mark that we are counting the cost of this instruction now. 387 Cost.IsCounted = true; 388 389 // If this is a PHI node in the loop header, just add it to the PHI set. 390 if (auto *PhiI = dyn_cast<PHINode>(I)) 391 if (PhiI->getParent() == L->getHeader()) { 392 assert(Cost.IsFree && "Loop PHIs shouldn't be evaluated as they " 393 "inherently simplify during unrolling."); 394 if (Iteration == 0) 395 continue; 396 397 // Push the incoming value from the backedge into the PHI used list 398 // if it is an in-loop instruction. We'll use this to populate the 399 // cost worklist for the next iteration (as we count backwards). 400 if (auto *OpI = dyn_cast<Instruction>( 401 PhiI->getIncomingValueForBlock(L->getLoopLatch()))) 402 if (L->contains(OpI)) 403 PHIUsedList.push_back(OpI); 404 continue; 405 } 406 407 // First accumulate the cost of this instruction. 408 if (!Cost.IsFree) { 409 UnrolledCost += TTI.getUserCost(I); 410 LLVM_DEBUG(dbgs() << "Adding cost of instruction (iteration " 411 << Iteration << "): "); 412 LLVM_DEBUG(I->dump()); 413 } 414 415 // We must count the cost of every operand which is not free, 416 // recursively. If we reach a loop PHI node, simply add it to the set 417 // to be considered on the next iteration (backwards!). 418 for (Value *Op : I->operands()) { 419 // Check whether this operand is free due to being a constant or 420 // outside the loop. 421 auto *OpI = dyn_cast<Instruction>(Op); 422 if (!OpI || !L->contains(OpI)) 423 continue; 424 425 // Otherwise accumulate its cost. 426 CostWorklist.push_back(OpI); 427 } 428 } while (!CostWorklist.empty()); 429 430 if (PHIUsedList.empty()) 431 // We've exhausted the search. 432 break; 433 434 assert(Iteration > 0 && 435 "Cannot track PHI-used values past the first iteration!"); 436 CostWorklist.append(PHIUsedList.begin(), PHIUsedList.end()); 437 PHIUsedList.clear(); 438 } 439 }; 440 441 // Ensure that we don't violate the loop structure invariants relied on by 442 // this analysis. 443 assert(L->isLoopSimplifyForm() && "Must put loop into normal form first."); 444 assert(L->isLCSSAForm(DT) && 445 "Must have loops in LCSSA form to track live-out values."); 446 447 LLVM_DEBUG(dbgs() << "Starting LoopUnroll profitability analysis...\n"); 448 449 // Simulate execution of each iteration of the loop counting instructions, 450 // which would be simplified. 451 // Since the same load will take different values on different iterations, 452 // we literally have to go through all loop's iterations. 453 for (unsigned Iteration = 0; Iteration < TripCount; ++Iteration) { 454 LLVM_DEBUG(dbgs() << " Analyzing iteration " << Iteration << "\n"); 455 456 // Prepare for the iteration by collecting any simplified entry or backedge 457 // inputs. 458 for (Instruction &I : *L->getHeader()) { 459 auto *PHI = dyn_cast<PHINode>(&I); 460 if (!PHI) 461 break; 462 463 // The loop header PHI nodes must have exactly two input: one from the 464 // loop preheader and one from the loop latch. 465 assert( 466 PHI->getNumIncomingValues() == 2 && 467 "Must have an incoming value only for the preheader and the latch."); 468 469 Value *V = PHI->getIncomingValueForBlock( 470 Iteration == 0 ? L->getLoopPreheader() : L->getLoopLatch()); 471 Constant *C = dyn_cast<Constant>(V); 472 if (Iteration != 0 && !C) 473 C = SimplifiedValues.lookup(V); 474 if (C) 475 SimplifiedInputValues.push_back({PHI, C}); 476 } 477 478 // Now clear and re-populate the map for the next iteration. 479 SimplifiedValues.clear(); 480 while (!SimplifiedInputValues.empty()) 481 SimplifiedValues.insert(SimplifiedInputValues.pop_back_val()); 482 483 UnrolledInstAnalyzer Analyzer(Iteration, SimplifiedValues, SE, L); 484 485 BBWorklist.clear(); 486 BBWorklist.insert(L->getHeader()); 487 // Note that we *must not* cache the size, this loop grows the worklist. 488 for (unsigned Idx = 0; Idx != BBWorklist.size(); ++Idx) { 489 BasicBlock *BB = BBWorklist[Idx]; 490 491 // Visit all instructions in the given basic block and try to simplify 492 // it. We don't change the actual IR, just count optimization 493 // opportunities. 494 for (Instruction &I : *BB) { 495 // These won't get into the final code - don't even try calculating the 496 // cost for them. 497 if (isa<DbgInfoIntrinsic>(I) || EphValues.count(&I)) 498 continue; 499 500 // Track this instruction's expected baseline cost when executing the 501 // rolled loop form. 502 RolledDynamicCost += TTI.getUserCost(&I); 503 504 // Visit the instruction to analyze its loop cost after unrolling, 505 // and if the visitor returns true, mark the instruction as free after 506 // unrolling and continue. 507 bool IsFree = Analyzer.visit(I); 508 bool Inserted = InstCostMap.insert({&I, (int)Iteration, 509 (unsigned)IsFree, 510 /*IsCounted*/ false}).second; 511 (void)Inserted; 512 assert(Inserted && "Cannot have a state for an unvisited instruction!"); 513 514 if (IsFree) 515 continue; 516 517 // Can't properly model a cost of a call. 518 // FIXME: With a proper cost model we should be able to do it. 519 if (auto *CI = dyn_cast<CallInst>(&I)) { 520 const Function *Callee = CI->getCalledFunction(); 521 if (!Callee || TTI.isLoweredToCall(Callee)) { 522 LLVM_DEBUG(dbgs() << "Can't analyze cost of loop with call\n"); 523 return None; 524 } 525 } 526 527 // If the instruction might have a side-effect recursively account for 528 // the cost of it and all the instructions leading up to it. 529 if (I.mayHaveSideEffects()) 530 AddCostRecursively(I, Iteration); 531 532 // If unrolled body turns out to be too big, bail out. 533 if (UnrolledCost > MaxUnrolledLoopSize) { 534 LLVM_DEBUG(dbgs() << " Exceeded threshold.. exiting.\n" 535 << " UnrolledCost: " << UnrolledCost 536 << ", MaxUnrolledLoopSize: " << MaxUnrolledLoopSize 537 << "\n"); 538 return None; 539 } 540 } 541 542 Instruction *TI = BB->getTerminator(); 543 544 // Add in the live successors by first checking whether we have terminator 545 // that may be simplified based on the values simplified by this call. 546 BasicBlock *KnownSucc = nullptr; 547 if (BranchInst *BI = dyn_cast<BranchInst>(TI)) { 548 if (BI->isConditional()) { 549 if (Constant *SimpleCond = 550 SimplifiedValues.lookup(BI->getCondition())) { 551 // Just take the first successor if condition is undef 552 if (isa<UndefValue>(SimpleCond)) 553 KnownSucc = BI->getSuccessor(0); 554 else if (ConstantInt *SimpleCondVal = 555 dyn_cast<ConstantInt>(SimpleCond)) 556 KnownSucc = BI->getSuccessor(SimpleCondVal->isZero() ? 1 : 0); 557 } 558 } 559 } else if (SwitchInst *SI = dyn_cast<SwitchInst>(TI)) { 560 if (Constant *SimpleCond = 561 SimplifiedValues.lookup(SI->getCondition())) { 562 // Just take the first successor if condition is undef 563 if (isa<UndefValue>(SimpleCond)) 564 KnownSucc = SI->getSuccessor(0); 565 else if (ConstantInt *SimpleCondVal = 566 dyn_cast<ConstantInt>(SimpleCond)) 567 KnownSucc = SI->findCaseValue(SimpleCondVal)->getCaseSuccessor(); 568 } 569 } 570 if (KnownSucc) { 571 if (L->contains(KnownSucc)) 572 BBWorklist.insert(KnownSucc); 573 else 574 ExitWorklist.insert({BB, KnownSucc}); 575 continue; 576 } 577 578 // Add BB's successors to the worklist. 579 for (BasicBlock *Succ : successors(BB)) 580 if (L->contains(Succ)) 581 BBWorklist.insert(Succ); 582 else 583 ExitWorklist.insert({BB, Succ}); 584 AddCostRecursively(*TI, Iteration); 585 } 586 587 // If we found no optimization opportunities on the first iteration, we 588 // won't find them on later ones too. 589 if (UnrolledCost == RolledDynamicCost) { 590 LLVM_DEBUG(dbgs() << " No opportunities found.. exiting.\n" 591 << " UnrolledCost: " << UnrolledCost << "\n"); 592 return None; 593 } 594 } 595 596 while (!ExitWorklist.empty()) { 597 BasicBlock *ExitingBB, *ExitBB; 598 std::tie(ExitingBB, ExitBB) = ExitWorklist.pop_back_val(); 599 600 for (Instruction &I : *ExitBB) { 601 auto *PN = dyn_cast<PHINode>(&I); 602 if (!PN) 603 break; 604 605 Value *Op = PN->getIncomingValueForBlock(ExitingBB); 606 if (auto *OpI = dyn_cast<Instruction>(Op)) 607 if (L->contains(OpI)) 608 AddCostRecursively(*OpI, TripCount - 1); 609 } 610 } 611 612 LLVM_DEBUG(dbgs() << "Analysis finished:\n" 613 << "UnrolledCost: " << UnrolledCost << ", " 614 << "RolledDynamicCost: " << RolledDynamicCost << "\n"); 615 return {{UnrolledCost, RolledDynamicCost}}; 616 } 617 618 /// ApproximateLoopSize - Approximate the size of the loop. 619 unsigned llvm::ApproximateLoopSize( 620 const Loop *L, unsigned &NumCalls, bool &NotDuplicatable, bool &Convergent, 621 const TargetTransformInfo &TTI, 622 const SmallPtrSetImpl<const Value *> &EphValues, unsigned BEInsns) { 623 CodeMetrics Metrics; 624 for (BasicBlock *BB : L->blocks()) 625 Metrics.analyzeBasicBlock(BB, TTI, EphValues); 626 NumCalls = Metrics.NumInlineCandidates; 627 NotDuplicatable = Metrics.notDuplicatable; 628 Convergent = Metrics.convergent; 629 630 unsigned LoopSize = Metrics.NumInsts; 631 632 // Don't allow an estimate of size zero. This would allows unrolling of loops 633 // with huge iteration counts, which is a compile time problem even if it's 634 // not a problem for code quality. Also, the code using this size may assume 635 // that each loop has at least three instructions (likely a conditional 636 // branch, a comparison feeding that branch, and some kind of loop increment 637 // feeding that comparison instruction). 638 LoopSize = std::max(LoopSize, BEInsns + 1); 639 640 return LoopSize; 641 } 642 643 // Returns the loop hint metadata node with the given name (for example, 644 // "llvm.loop.unroll.count"). If no such metadata node exists, then nullptr is 645 // returned. 646 static MDNode *GetUnrollMetadataForLoop(const Loop *L, StringRef Name) { 647 if (MDNode *LoopID = L->getLoopID()) 648 return GetUnrollMetadata(LoopID, Name); 649 return nullptr; 650 } 651 652 // Returns true if the loop has an unroll(full) pragma. 653 static bool HasUnrollFullPragma(const Loop *L) { 654 return GetUnrollMetadataForLoop(L, "llvm.loop.unroll.full"); 655 } 656 657 // Returns true if the loop has an unroll(enable) pragma. This metadata is used 658 // for both "#pragma unroll" and "#pragma clang loop unroll(enable)" directives. 659 static bool HasUnrollEnablePragma(const Loop *L) { 660 return GetUnrollMetadataForLoop(L, "llvm.loop.unroll.enable"); 661 } 662 663 // Returns true if the loop has an runtime unroll(disable) pragma. 664 static bool HasRuntimeUnrollDisablePragma(const Loop *L) { 665 return GetUnrollMetadataForLoop(L, "llvm.loop.unroll.runtime.disable"); 666 } 667 668 // If loop has an unroll_count pragma return the (necessarily 669 // positive) value from the pragma. Otherwise return 0. 670 static unsigned UnrollCountPragmaValue(const Loop *L) { 671 MDNode *MD = GetUnrollMetadataForLoop(L, "llvm.loop.unroll.count"); 672 if (MD) { 673 assert(MD->getNumOperands() == 2 && 674 "Unroll count hint metadata should have two operands."); 675 unsigned Count = 676 mdconst::extract<ConstantInt>(MD->getOperand(1))->getZExtValue(); 677 assert(Count >= 1 && "Unroll count must be positive."); 678 return Count; 679 } 680 return 0; 681 } 682 683 // Computes the boosting factor for complete unrolling. 684 // If fully unrolling the loop would save a lot of RolledDynamicCost, it would 685 // be beneficial to fully unroll the loop even if unrolledcost is large. We 686 // use (RolledDynamicCost / UnrolledCost) to model the unroll benefits to adjust 687 // the unroll threshold. 688 static unsigned getFullUnrollBoostingFactor(const EstimatedUnrollCost &Cost, 689 unsigned MaxPercentThresholdBoost) { 690 if (Cost.RolledDynamicCost >= std::numeric_limits<unsigned>::max() / 100) 691 return 100; 692 else if (Cost.UnrolledCost != 0) 693 // The boosting factor is RolledDynamicCost / UnrolledCost 694 return std::min(100 * Cost.RolledDynamicCost / Cost.UnrolledCost, 695 MaxPercentThresholdBoost); 696 else 697 return MaxPercentThresholdBoost; 698 } 699 700 // Returns loop size estimation for unrolled loop. 701 static uint64_t getUnrolledLoopSize( 702 unsigned LoopSize, 703 TargetTransformInfo::UnrollingPreferences &UP) { 704 assert(LoopSize >= UP.BEInsns && "LoopSize should not be less than BEInsns!"); 705 return (uint64_t)(LoopSize - UP.BEInsns) * UP.Count + UP.BEInsns; 706 } 707 708 // Returns true if unroll count was set explicitly. 709 // Calculates unroll count and writes it to UP.Count. 710 // Unless IgnoreUser is true, will also use metadata and command-line options 711 // that are specific to to the LoopUnroll pass (which, for instance, are 712 // irrelevant for the LoopUnrollAndJam pass). 713 // FIXME: This function is used by LoopUnroll and LoopUnrollAndJam, but consumes 714 // many LoopUnroll-specific options. The shared functionality should be 715 // refactored into it own function. 716 bool llvm::computeUnrollCount( 717 Loop *L, const TargetTransformInfo &TTI, DominatorTree &DT, LoopInfo *LI, 718 ScalarEvolution &SE, const SmallPtrSetImpl<const Value *> &EphValues, 719 OptimizationRemarkEmitter *ORE, unsigned &TripCount, unsigned MaxTripCount, 720 unsigned &TripMultiple, unsigned LoopSize, 721 TargetTransformInfo::UnrollingPreferences &UP, bool &UseUpperBound) { 722 723 // Check for explicit Count. 724 // 1st priority is unroll count set by "unroll-count" option. 725 bool UserUnrollCount = UnrollCount.getNumOccurrences() > 0; 726 if (UserUnrollCount) { 727 UP.Count = UnrollCount; 728 UP.AllowExpensiveTripCount = true; 729 UP.Force = true; 730 if (UP.AllowRemainder && getUnrolledLoopSize(LoopSize, UP) < UP.Threshold) 731 return true; 732 } 733 734 // 2nd priority is unroll count set by pragma. 735 unsigned PragmaCount = UnrollCountPragmaValue(L); 736 if (PragmaCount > 0) { 737 UP.Count = PragmaCount; 738 UP.Runtime = true; 739 UP.AllowExpensiveTripCount = true; 740 UP.Force = true; 741 if ((UP.AllowRemainder || (TripMultiple % PragmaCount == 0)) && 742 getUnrolledLoopSize(LoopSize, UP) < PragmaUnrollThreshold) 743 return true; 744 } 745 bool PragmaFullUnroll = HasUnrollFullPragma(L); 746 if (PragmaFullUnroll && TripCount != 0) { 747 UP.Count = TripCount; 748 if (getUnrolledLoopSize(LoopSize, UP) < PragmaUnrollThreshold) 749 return false; 750 } 751 752 bool PragmaEnableUnroll = HasUnrollEnablePragma(L); 753 bool ExplicitUnroll = PragmaCount > 0 || PragmaFullUnroll || 754 PragmaEnableUnroll || UserUnrollCount; 755 756 if (ExplicitUnroll && TripCount != 0) { 757 // If the loop has an unrolling pragma, we want to be more aggressive with 758 // unrolling limits. Set thresholds to at least the PragmaUnrollThreshold 759 // value which is larger than the default limits. 760 UP.Threshold = std::max<unsigned>(UP.Threshold, PragmaUnrollThreshold); 761 UP.PartialThreshold = 762 std::max<unsigned>(UP.PartialThreshold, PragmaUnrollThreshold); 763 } 764 765 // 3rd priority is full unroll count. 766 // Full unroll makes sense only when TripCount or its upper bound could be 767 // statically calculated. 768 // Also we need to check if we exceed FullUnrollMaxCount. 769 // If using the upper bound to unroll, TripMultiple should be set to 1 because 770 // we do not know when loop may exit. 771 // MaxTripCount and ExactTripCount cannot both be non zero since we only 772 // compute the former when the latter is zero. 773 unsigned ExactTripCount = TripCount; 774 assert((ExactTripCount == 0 || MaxTripCount == 0) && 775 "ExtractTripCount and MaxTripCount cannot both be non zero."); 776 unsigned FullUnrollTripCount = ExactTripCount ? ExactTripCount : MaxTripCount; 777 UP.Count = FullUnrollTripCount; 778 if (FullUnrollTripCount && FullUnrollTripCount <= UP.FullUnrollMaxCount) { 779 // When computing the unrolled size, note that BEInsns are not replicated 780 // like the rest of the loop body. 781 if (getUnrolledLoopSize(LoopSize, UP) < UP.Threshold) { 782 UseUpperBound = (MaxTripCount == FullUnrollTripCount); 783 TripCount = FullUnrollTripCount; 784 TripMultiple = UP.UpperBound ? 1 : TripMultiple; 785 return ExplicitUnroll; 786 } else { 787 // The loop isn't that small, but we still can fully unroll it if that 788 // helps to remove a significant number of instructions. 789 // To check that, run additional analysis on the loop. 790 if (Optional<EstimatedUnrollCost> Cost = analyzeLoopUnrollCost( 791 L, FullUnrollTripCount, DT, SE, EphValues, TTI, 792 UP.Threshold * UP.MaxPercentThresholdBoost / 100)) { 793 unsigned Boost = 794 getFullUnrollBoostingFactor(*Cost, UP.MaxPercentThresholdBoost); 795 if (Cost->UnrolledCost < UP.Threshold * Boost / 100) { 796 UseUpperBound = (MaxTripCount == FullUnrollTripCount); 797 TripCount = FullUnrollTripCount; 798 TripMultiple = UP.UpperBound ? 1 : TripMultiple; 799 return ExplicitUnroll; 800 } 801 } 802 } 803 } 804 805 // 4th priority is loop peeling. 806 computePeelCount(L, LoopSize, UP, TripCount, SE); 807 if (UP.PeelCount) { 808 UP.Runtime = false; 809 UP.Count = 1; 810 return ExplicitUnroll; 811 } 812 813 // 5th priority is partial unrolling. 814 // Try partial unroll only when TripCount could be statically calculated. 815 if (TripCount) { 816 UP.Partial |= ExplicitUnroll; 817 if (!UP.Partial) { 818 LLVM_DEBUG(dbgs() << " will not try to unroll partially because " 819 << "-unroll-allow-partial not given\n"); 820 UP.Count = 0; 821 return false; 822 } 823 if (UP.Count == 0) 824 UP.Count = TripCount; 825 if (UP.PartialThreshold != NoThreshold) { 826 // Reduce unroll count to be modulo of TripCount for partial unrolling. 827 if (getUnrolledLoopSize(LoopSize, UP) > UP.PartialThreshold) 828 UP.Count = 829 (std::max(UP.PartialThreshold, UP.BEInsns + 1) - UP.BEInsns) / 830 (LoopSize - UP.BEInsns); 831 if (UP.Count > UP.MaxCount) 832 UP.Count = UP.MaxCount; 833 while (UP.Count != 0 && TripCount % UP.Count != 0) 834 UP.Count--; 835 if (UP.AllowRemainder && UP.Count <= 1) { 836 // If there is no Count that is modulo of TripCount, set Count to 837 // largest power-of-two factor that satisfies the threshold limit. 838 // As we'll create fixup loop, do the type of unrolling only if 839 // remainder loop is allowed. 840 UP.Count = UP.DefaultUnrollRuntimeCount; 841 while (UP.Count != 0 && 842 getUnrolledLoopSize(LoopSize, UP) > UP.PartialThreshold) 843 UP.Count >>= 1; 844 } 845 if (UP.Count < 2) { 846 if (PragmaEnableUnroll) 847 ORE->emit([&]() { 848 return OptimizationRemarkMissed(DEBUG_TYPE, 849 "UnrollAsDirectedTooLarge", 850 L->getStartLoc(), L->getHeader()) 851 << "Unable to unroll loop as directed by unroll(enable) " 852 "pragma " 853 "because unrolled size is too large."; 854 }); 855 UP.Count = 0; 856 } 857 } else { 858 UP.Count = TripCount; 859 } 860 if (UP.Count > UP.MaxCount) 861 UP.Count = UP.MaxCount; 862 if ((PragmaFullUnroll || PragmaEnableUnroll) && TripCount && 863 UP.Count != TripCount) 864 ORE->emit([&]() { 865 return OptimizationRemarkMissed(DEBUG_TYPE, 866 "FullUnrollAsDirectedTooLarge", 867 L->getStartLoc(), L->getHeader()) 868 << "Unable to fully unroll loop as directed by unroll pragma " 869 "because " 870 "unrolled size is too large."; 871 }); 872 return ExplicitUnroll; 873 } 874 assert(TripCount == 0 && 875 "All cases when TripCount is constant should be covered here."); 876 if (PragmaFullUnroll) 877 ORE->emit([&]() { 878 return OptimizationRemarkMissed( 879 DEBUG_TYPE, "CantFullUnrollAsDirectedRuntimeTripCount", 880 L->getStartLoc(), L->getHeader()) 881 << "Unable to fully unroll loop as directed by unroll(full) " 882 "pragma " 883 "because loop has a runtime trip count."; 884 }); 885 886 // 6th priority is runtime unrolling. 887 // Don't unroll a runtime trip count loop when it is disabled. 888 if (HasRuntimeUnrollDisablePragma(L)) { 889 UP.Count = 0; 890 return false; 891 } 892 893 // Check if the runtime trip count is too small when profile is available. 894 if (L->getHeader()->getParent()->hasProfileData()) { 895 if (auto ProfileTripCount = getLoopEstimatedTripCount(L)) { 896 if (*ProfileTripCount < FlatLoopTripCountThreshold) 897 return false; 898 else 899 UP.AllowExpensiveTripCount = true; 900 } 901 } 902 903 // Reduce count based on the type of unrolling and the threshold values. 904 UP.Runtime |= PragmaEnableUnroll || PragmaCount > 0 || UserUnrollCount; 905 if (!UP.Runtime) { 906 LLVM_DEBUG( 907 dbgs() << " will not try to unroll loop with runtime trip count " 908 << "-unroll-runtime not given\n"); 909 UP.Count = 0; 910 return false; 911 } 912 if (UP.Count == 0) 913 UP.Count = UP.DefaultUnrollRuntimeCount; 914 915 // Reduce unroll count to be the largest power-of-two factor of 916 // the original count which satisfies the threshold limit. 917 while (UP.Count != 0 && 918 getUnrolledLoopSize(LoopSize, UP) > UP.PartialThreshold) 919 UP.Count >>= 1; 920 921 #ifndef NDEBUG 922 unsigned OrigCount = UP.Count; 923 #endif 924 925 if (!UP.AllowRemainder && UP.Count != 0 && (TripMultiple % UP.Count) != 0) { 926 while (UP.Count != 0 && TripMultiple % UP.Count != 0) 927 UP.Count >>= 1; 928 LLVM_DEBUG( 929 dbgs() << "Remainder loop is restricted (that could architecture " 930 "specific or because the loop contains a convergent " 931 "instruction), so unroll count must divide the trip " 932 "multiple, " 933 << TripMultiple << ". Reducing unroll count from " << OrigCount 934 << " to " << UP.Count << ".\n"); 935 936 using namespace ore; 937 938 if (PragmaCount > 0 && !UP.AllowRemainder) 939 ORE->emit([&]() { 940 return OptimizationRemarkMissed(DEBUG_TYPE, 941 "DifferentUnrollCountFromDirected", 942 L->getStartLoc(), L->getHeader()) 943 << "Unable to unroll loop the number of times directed by " 944 "unroll_count pragma because remainder loop is restricted " 945 "(that could architecture specific or because the loop " 946 "contains a convergent instruction) and so must have an " 947 "unroll " 948 "count that divides the loop trip multiple of " 949 << NV("TripMultiple", TripMultiple) << ". Unrolling instead " 950 << NV("UnrollCount", UP.Count) << " time(s)."; 951 }); 952 } 953 954 if (UP.Count > UP.MaxCount) 955 UP.Count = UP.MaxCount; 956 LLVM_DEBUG(dbgs() << " partially unrolling with count: " << UP.Count 957 << "\n"); 958 if (UP.Count < 2) 959 UP.Count = 0; 960 return ExplicitUnroll; 961 } 962 963 static LoopUnrollResult tryToUnrollLoop( 964 Loop *L, DominatorTree &DT, LoopInfo *LI, ScalarEvolution &SE, 965 const TargetTransformInfo &TTI, AssumptionCache &AC, 966 OptimizationRemarkEmitter &ORE, bool PreserveLCSSA, int OptLevel, 967 bool OnlyWhenForced, Optional<unsigned> ProvidedCount, 968 Optional<unsigned> ProvidedThreshold, Optional<bool> ProvidedAllowPartial, 969 Optional<bool> ProvidedRuntime, Optional<bool> ProvidedUpperBound, 970 Optional<bool> ProvidedAllowPeeling) { 971 LLVM_DEBUG(dbgs() << "Loop Unroll: F[" 972 << L->getHeader()->getParent()->getName() << "] Loop %" 973 << L->getHeader()->getName() << "\n"); 974 TransformationMode TM = hasUnrollTransformation(L); 975 if (TM & TM_Disable) 976 return LoopUnrollResult::Unmodified; 977 if (!L->isLoopSimplifyForm()) { 978 LLVM_DEBUG( 979 dbgs() << " Not unrolling loop which is not in loop-simplify form.\n"); 980 return LoopUnrollResult::Unmodified; 981 } 982 983 // When automtatic unrolling is disabled, do not unroll unless overridden for 984 // this loop. 985 if (OnlyWhenForced && !(TM & TM_Enable)) 986 return LoopUnrollResult::Unmodified; 987 988 unsigned NumInlineCandidates; 989 bool NotDuplicatable; 990 bool Convergent; 991 TargetTransformInfo::UnrollingPreferences UP = gatherUnrollingPreferences( 992 L, SE, TTI, OptLevel, ProvidedThreshold, ProvidedCount, 993 ProvidedAllowPartial, ProvidedRuntime, ProvidedUpperBound, 994 ProvidedAllowPeeling); 995 // Exit early if unrolling is disabled. 996 if (UP.Threshold == 0 && (!UP.Partial || UP.PartialThreshold == 0)) 997 return LoopUnrollResult::Unmodified; 998 999 SmallPtrSet<const Value *, 32> EphValues; 1000 CodeMetrics::collectEphemeralValues(L, &AC, EphValues); 1001 1002 unsigned LoopSize = 1003 ApproximateLoopSize(L, NumInlineCandidates, NotDuplicatable, Convergent, 1004 TTI, EphValues, UP.BEInsns); 1005 LLVM_DEBUG(dbgs() << " Loop Size = " << LoopSize << "\n"); 1006 if (NotDuplicatable) { 1007 LLVM_DEBUG(dbgs() << " Not unrolling loop which contains non-duplicatable" 1008 << " instructions.\n"); 1009 return LoopUnrollResult::Unmodified; 1010 } 1011 if (NumInlineCandidates != 0) { 1012 LLVM_DEBUG(dbgs() << " Not unrolling loop with inlinable calls.\n"); 1013 return LoopUnrollResult::Unmodified; 1014 } 1015 1016 // Find trip count and trip multiple if count is not available 1017 unsigned TripCount = 0; 1018 unsigned MaxTripCount = 0; 1019 unsigned TripMultiple = 1; 1020 // If there are multiple exiting blocks but one of them is the latch, use the 1021 // latch for the trip count estimation. Otherwise insist on a single exiting 1022 // block for the trip count estimation. 1023 BasicBlock *ExitingBlock = L->getLoopLatch(); 1024 if (!ExitingBlock || !L->isLoopExiting(ExitingBlock)) 1025 ExitingBlock = L->getExitingBlock(); 1026 if (ExitingBlock) { 1027 TripCount = SE.getSmallConstantTripCount(L, ExitingBlock); 1028 TripMultiple = SE.getSmallConstantTripMultiple(L, ExitingBlock); 1029 } 1030 1031 // If the loop contains a convergent operation, the prelude we'd add 1032 // to do the first few instructions before we hit the unrolled loop 1033 // is unsafe -- it adds a control-flow dependency to the convergent 1034 // operation. Therefore restrict remainder loop (try unrollig without). 1035 // 1036 // TODO: This is quite conservative. In practice, convergent_op() 1037 // is likely to be called unconditionally in the loop. In this 1038 // case, the program would be ill-formed (on most architectures) 1039 // unless n were the same on all threads in a thread group. 1040 // Assuming n is the same on all threads, any kind of unrolling is 1041 // safe. But currently llvm's notion of convergence isn't powerful 1042 // enough to express this. 1043 if (Convergent) 1044 UP.AllowRemainder = false; 1045 1046 // Try to find the trip count upper bound if we cannot find the exact trip 1047 // count. 1048 bool MaxOrZero = false; 1049 if (!TripCount) { 1050 MaxTripCount = SE.getSmallConstantMaxTripCount(L); 1051 MaxOrZero = SE.isBackedgeTakenCountMaxOrZero(L); 1052 // We can unroll by the upper bound amount if it's generally allowed or if 1053 // we know that the loop is executed either the upper bound or zero times. 1054 // (MaxOrZero unrolling keeps only the first loop test, so the number of 1055 // loop tests remains the same compared to the non-unrolled version, whereas 1056 // the generic upper bound unrolling keeps all but the last loop test so the 1057 // number of loop tests goes up which may end up being worse on targets with 1058 // constrained branch predictor resources so is controlled by an option.) 1059 // In addition we only unroll small upper bounds. 1060 if (!(UP.UpperBound || MaxOrZero) || MaxTripCount > UnrollMaxUpperBound) { 1061 MaxTripCount = 0; 1062 } 1063 } 1064 1065 // computeUnrollCount() decides whether it is beneficial to use upper bound to 1066 // fully unroll the loop. 1067 bool UseUpperBound = false; 1068 bool IsCountSetExplicitly = computeUnrollCount( 1069 L, TTI, DT, LI, SE, EphValues, &ORE, TripCount, MaxTripCount, 1070 TripMultiple, LoopSize, UP, UseUpperBound); 1071 if (!UP.Count) 1072 return LoopUnrollResult::Unmodified; 1073 // Unroll factor (Count) must be less or equal to TripCount. 1074 if (TripCount && UP.Count > TripCount) 1075 UP.Count = TripCount; 1076 1077 // Save loop properties before it is transformed. 1078 MDNode *OrigLoopID = L->getLoopID(); 1079 1080 // Unroll the loop. 1081 Loop *RemainderLoop = nullptr; 1082 LoopUnrollResult UnrollResult = UnrollLoop( 1083 L, UP.Count, TripCount, UP.Force, UP.Runtime, UP.AllowExpensiveTripCount, 1084 UseUpperBound, MaxOrZero, TripMultiple, UP.PeelCount, UP.UnrollRemainder, 1085 LI, &SE, &DT, &AC, &ORE, PreserveLCSSA, &RemainderLoop); 1086 if (UnrollResult == LoopUnrollResult::Unmodified) 1087 return LoopUnrollResult::Unmodified; 1088 1089 if (RemainderLoop) { 1090 Optional<MDNode *> RemainderLoopID = 1091 makeFollowupLoopID(OrigLoopID, {LLVMLoopUnrollFollowupAll, 1092 LLVMLoopUnrollFollowupRemainder}); 1093 if (RemainderLoopID.hasValue()) 1094 RemainderLoop->setLoopID(RemainderLoopID.getValue()); 1095 } 1096 1097 if (UnrollResult != LoopUnrollResult::FullyUnrolled) { 1098 Optional<MDNode *> NewLoopID = 1099 makeFollowupLoopID(OrigLoopID, {LLVMLoopUnrollFollowupAll, 1100 LLVMLoopUnrollFollowupUnrolled}); 1101 if (NewLoopID.hasValue()) { 1102 L->setLoopID(NewLoopID.getValue()); 1103 1104 // Do not setLoopAlreadyUnrolled if loop attributes have been specified 1105 // explicitly. 1106 return UnrollResult; 1107 } 1108 } 1109 1110 // If loop has an unroll count pragma or unrolled by explicitly set count 1111 // mark loop as unrolled to prevent unrolling beyond that requested. 1112 // If the loop was peeled, we already "used up" the profile information 1113 // we had, so we don't want to unroll or peel again. 1114 if (UnrollResult != LoopUnrollResult::FullyUnrolled && 1115 (IsCountSetExplicitly || UP.PeelCount)) 1116 L->setLoopAlreadyUnrolled(); 1117 1118 return UnrollResult; 1119 } 1120 1121 namespace { 1122 1123 class LoopUnroll : public LoopPass { 1124 public: 1125 static char ID; // Pass ID, replacement for typeid 1126 1127 int OptLevel; 1128 1129 /// If false, use a cost model to determine whether unrolling of a loop is 1130 /// profitable. If true, only loops that explicitly request unrolling via 1131 /// metadata are considered. All other loops are skipped. 1132 bool OnlyWhenForced; 1133 1134 Optional<unsigned> ProvidedCount; 1135 Optional<unsigned> ProvidedThreshold; 1136 Optional<bool> ProvidedAllowPartial; 1137 Optional<bool> ProvidedRuntime; 1138 Optional<bool> ProvidedUpperBound; 1139 Optional<bool> ProvidedAllowPeeling; 1140 1141 LoopUnroll(int OptLevel = 2, bool OnlyWhenForced = false, 1142 Optional<unsigned> Threshold = None, 1143 Optional<unsigned> Count = None, 1144 Optional<bool> AllowPartial = None, Optional<bool> Runtime = None, 1145 Optional<bool> UpperBound = None, 1146 Optional<bool> AllowPeeling = None) 1147 : LoopPass(ID), OptLevel(OptLevel), OnlyWhenForced(OnlyWhenForced), 1148 ProvidedCount(std::move(Count)), ProvidedThreshold(Threshold), 1149 ProvidedAllowPartial(AllowPartial), ProvidedRuntime(Runtime), 1150 ProvidedUpperBound(UpperBound), ProvidedAllowPeeling(AllowPeeling) { 1151 initializeLoopUnrollPass(*PassRegistry::getPassRegistry()); 1152 } 1153 1154 bool runOnLoop(Loop *L, LPPassManager &LPM) override { 1155 if (skipLoop(L)) 1156 return false; 1157 1158 Function &F = *L->getHeader()->getParent(); 1159 1160 auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree(); 1161 LoopInfo *LI = &getAnalysis<LoopInfoWrapperPass>().getLoopInfo(); 1162 ScalarEvolution &SE = getAnalysis<ScalarEvolutionWrapperPass>().getSE(); 1163 const TargetTransformInfo &TTI = 1164 getAnalysis<TargetTransformInfoWrapperPass>().getTTI(F); 1165 auto &AC = getAnalysis<AssumptionCacheTracker>().getAssumptionCache(F); 1166 // For the old PM, we can't use OptimizationRemarkEmitter as an analysis 1167 // pass. Function analyses need to be preserved across loop transformations 1168 // but ORE cannot be preserved (see comment before the pass definition). 1169 OptimizationRemarkEmitter ORE(&F); 1170 bool PreserveLCSSA = mustPreserveAnalysisID(LCSSAID); 1171 1172 LoopUnrollResult Result = tryToUnrollLoop( 1173 L, DT, LI, SE, TTI, AC, ORE, PreserveLCSSA, OptLevel, OnlyWhenForced, 1174 ProvidedCount, ProvidedThreshold, ProvidedAllowPartial, ProvidedRuntime, 1175 ProvidedUpperBound, ProvidedAllowPeeling); 1176 1177 if (Result == LoopUnrollResult::FullyUnrolled) 1178 LPM.markLoopAsDeleted(*L); 1179 1180 return Result != LoopUnrollResult::Unmodified; 1181 } 1182 1183 /// This transformation requires natural loop information & requires that 1184 /// loop preheaders be inserted into the CFG... 1185 void getAnalysisUsage(AnalysisUsage &AU) const override { 1186 AU.addRequired<AssumptionCacheTracker>(); 1187 AU.addRequired<TargetTransformInfoWrapperPass>(); 1188 // FIXME: Loop passes are required to preserve domtree, and for now we just 1189 // recreate dom info if anything gets unrolled. 1190 getLoopAnalysisUsage(AU); 1191 } 1192 }; 1193 1194 } // end anonymous namespace 1195 1196 char LoopUnroll::ID = 0; 1197 1198 INITIALIZE_PASS_BEGIN(LoopUnroll, "loop-unroll", "Unroll loops", false, false) 1199 INITIALIZE_PASS_DEPENDENCY(AssumptionCacheTracker) 1200 INITIALIZE_PASS_DEPENDENCY(LoopPass) 1201 INITIALIZE_PASS_DEPENDENCY(TargetTransformInfoWrapperPass) 1202 INITIALIZE_PASS_END(LoopUnroll, "loop-unroll", "Unroll loops", false, false) 1203 1204 Pass *llvm::createLoopUnrollPass(int OptLevel, bool OnlyWhenForced, 1205 int Threshold, int Count, int AllowPartial, 1206 int Runtime, int UpperBound, 1207 int AllowPeeling) { 1208 // TODO: It would make more sense for this function to take the optionals 1209 // directly, but that's dangerous since it would silently break out of tree 1210 // callers. 1211 return new LoopUnroll( 1212 OptLevel, OnlyWhenForced, 1213 Threshold == -1 ? None : Optional<unsigned>(Threshold), 1214 Count == -1 ? None : Optional<unsigned>(Count), 1215 AllowPartial == -1 ? None : Optional<bool>(AllowPartial), 1216 Runtime == -1 ? None : Optional<bool>(Runtime), 1217 UpperBound == -1 ? None : Optional<bool>(UpperBound), 1218 AllowPeeling == -1 ? None : Optional<bool>(AllowPeeling)); 1219 } 1220 1221 Pass *llvm::createSimpleLoopUnrollPass(int OptLevel, bool OnlyWhenForced) { 1222 return createLoopUnrollPass(OptLevel, OnlyWhenForced, -1, -1, 0, 0, 0, 0); 1223 } 1224 1225 PreservedAnalyses LoopFullUnrollPass::run(Loop &L, LoopAnalysisManager &AM, 1226 LoopStandardAnalysisResults &AR, 1227 LPMUpdater &Updater) { 1228 const auto &FAM = 1229 AM.getResult<FunctionAnalysisManagerLoopProxy>(L, AR).getManager(); 1230 Function *F = L.getHeader()->getParent(); 1231 1232 auto *ORE = FAM.getCachedResult<OptimizationRemarkEmitterAnalysis>(*F); 1233 // FIXME: This should probably be optional rather than required. 1234 if (!ORE) 1235 report_fatal_error( 1236 "LoopFullUnrollPass: OptimizationRemarkEmitterAnalysis not " 1237 "cached at a higher level"); 1238 1239 // Keep track of the previous loop structure so we can identify new loops 1240 // created by unrolling. 1241 Loop *ParentL = L.getParentLoop(); 1242 SmallPtrSet<Loop *, 4> OldLoops; 1243 if (ParentL) 1244 OldLoops.insert(ParentL->begin(), ParentL->end()); 1245 else 1246 OldLoops.insert(AR.LI.begin(), AR.LI.end()); 1247 1248 std::string LoopName = L.getName(); 1249 1250 bool Changed = 1251 tryToUnrollLoop(&L, AR.DT, &AR.LI, AR.SE, AR.TTI, AR.AC, *ORE, 1252 /*PreserveLCSSA*/ true, OptLevel, OnlyWhenForced, 1253 /*Count*/ None, 1254 /*Threshold*/ None, /*AllowPartial*/ false, 1255 /*Runtime*/ false, /*UpperBound*/ false, 1256 /*AllowPeeling*/ false) != LoopUnrollResult::Unmodified; 1257 if (!Changed) 1258 return PreservedAnalyses::all(); 1259 1260 // The parent must not be damaged by unrolling! 1261 #ifndef NDEBUG 1262 if (ParentL) 1263 ParentL->verifyLoop(); 1264 #endif 1265 1266 // Unrolling can do several things to introduce new loops into a loop nest: 1267 // - Full unrolling clones child loops within the current loop but then 1268 // removes the current loop making all of the children appear to be new 1269 // sibling loops. 1270 // 1271 // When a new loop appears as a sibling loop after fully unrolling, 1272 // its nesting structure has fundamentally changed and we want to revisit 1273 // it to reflect that. 1274 // 1275 // When unrolling has removed the current loop, we need to tell the 1276 // infrastructure that it is gone. 1277 // 1278 // Finally, we support a debugging/testing mode where we revisit child loops 1279 // as well. These are not expected to require further optimizations as either 1280 // they or the loop they were cloned from have been directly visited already. 1281 // But the debugging mode allows us to check this assumption. 1282 bool IsCurrentLoopValid = false; 1283 SmallVector<Loop *, 4> SibLoops; 1284 if (ParentL) 1285 SibLoops.append(ParentL->begin(), ParentL->end()); 1286 else 1287 SibLoops.append(AR.LI.begin(), AR.LI.end()); 1288 erase_if(SibLoops, [&](Loop *SibLoop) { 1289 if (SibLoop == &L) { 1290 IsCurrentLoopValid = true; 1291 return true; 1292 } 1293 1294 // Otherwise erase the loop from the list if it was in the old loops. 1295 return OldLoops.count(SibLoop) != 0; 1296 }); 1297 Updater.addSiblingLoops(SibLoops); 1298 1299 if (!IsCurrentLoopValid) { 1300 Updater.markLoopAsDeleted(L, LoopName); 1301 } else { 1302 // We can only walk child loops if the current loop remained valid. 1303 if (UnrollRevisitChildLoops) { 1304 // Walk *all* of the child loops. 1305 SmallVector<Loop *, 4> ChildLoops(L.begin(), L.end()); 1306 Updater.addChildLoops(ChildLoops); 1307 } 1308 } 1309 1310 return getLoopPassPreservedAnalyses(); 1311 } 1312 1313 template <typename RangeT> 1314 static SmallVector<Loop *, 8> appendLoopsToWorklist(RangeT &&Loops) { 1315 SmallVector<Loop *, 8> Worklist; 1316 // We use an internal worklist to build up the preorder traversal without 1317 // recursion. 1318 SmallVector<Loop *, 4> PreOrderLoops, PreOrderWorklist; 1319 1320 for (Loop *RootL : Loops) { 1321 assert(PreOrderLoops.empty() && "Must start with an empty preorder walk."); 1322 assert(PreOrderWorklist.empty() && 1323 "Must start with an empty preorder walk worklist."); 1324 PreOrderWorklist.push_back(RootL); 1325 do { 1326 Loop *L = PreOrderWorklist.pop_back_val(); 1327 PreOrderWorklist.append(L->begin(), L->end()); 1328 PreOrderLoops.push_back(L); 1329 } while (!PreOrderWorklist.empty()); 1330 1331 Worklist.append(PreOrderLoops.begin(), PreOrderLoops.end()); 1332 PreOrderLoops.clear(); 1333 } 1334 return Worklist; 1335 } 1336 1337 PreservedAnalyses LoopUnrollPass::run(Function &F, 1338 FunctionAnalysisManager &AM) { 1339 auto &SE = AM.getResult<ScalarEvolutionAnalysis>(F); 1340 auto &LI = AM.getResult<LoopAnalysis>(F); 1341 auto &TTI = AM.getResult<TargetIRAnalysis>(F); 1342 auto &DT = AM.getResult<DominatorTreeAnalysis>(F); 1343 auto &AC = AM.getResult<AssumptionAnalysis>(F); 1344 auto &ORE = AM.getResult<OptimizationRemarkEmitterAnalysis>(F); 1345 1346 LoopAnalysisManager *LAM = nullptr; 1347 if (auto *LAMProxy = AM.getCachedResult<LoopAnalysisManagerFunctionProxy>(F)) 1348 LAM = &LAMProxy->getManager(); 1349 1350 const ModuleAnalysisManager &MAM = 1351 AM.getResult<ModuleAnalysisManagerFunctionProxy>(F).getManager(); 1352 ProfileSummaryInfo *PSI = 1353 MAM.getCachedResult<ProfileSummaryAnalysis>(*F.getParent()); 1354 1355 bool Changed = false; 1356 1357 // The unroller requires loops to be in simplified form, and also needs LCSSA. 1358 // Since simplification may add new inner loops, it has to run before the 1359 // legality and profitability checks. This means running the loop unroller 1360 // will simplify all loops, regardless of whether anything end up being 1361 // unrolled. 1362 for (auto &L : LI) { 1363 Changed |= simplifyLoop(L, &DT, &LI, &SE, &AC, false /* PreserveLCSSA */); 1364 Changed |= formLCSSARecursively(*L, DT, &LI, &SE); 1365 } 1366 1367 SmallVector<Loop *, 8> Worklist = appendLoopsToWorklist(LI); 1368 1369 while (!Worklist.empty()) { 1370 // Because the LoopInfo stores the loops in RPO, we walk the worklist 1371 // from back to front so that we work forward across the CFG, which 1372 // for unrolling is only needed to get optimization remarks emitted in 1373 // a forward order. 1374 Loop &L = *Worklist.pop_back_val(); 1375 #ifndef NDEBUG 1376 Loop *ParentL = L.getParentLoop(); 1377 #endif 1378 1379 // Check if the profile summary indicates that the profiled application 1380 // has a huge working set size, in which case we disable peeling to avoid 1381 // bloating it further. 1382 Optional<bool> LocalAllowPeeling = UnrollOpts.AllowPeeling; 1383 if (PSI && PSI->hasHugeWorkingSetSize()) 1384 LocalAllowPeeling = false; 1385 std::string LoopName = L.getName(); 1386 // The API here is quite complex to call and we allow to select some 1387 // flavors of unrolling during construction time (by setting UnrollOpts). 1388 LoopUnrollResult Result = tryToUnrollLoop( 1389 &L, DT, &LI, SE, TTI, AC, ORE, 1390 /*PreserveLCSSA*/ true, UnrollOpts.OptLevel, UnrollOpts.OnlyWhenForced, 1391 /*Count*/ None, 1392 /*Threshold*/ None, UnrollOpts.AllowPartial, UnrollOpts.AllowRuntime, 1393 UnrollOpts.AllowUpperBound, LocalAllowPeeling); 1394 Changed |= Result != LoopUnrollResult::Unmodified; 1395 1396 // The parent must not be damaged by unrolling! 1397 #ifndef NDEBUG 1398 if (Result != LoopUnrollResult::Unmodified && ParentL) 1399 ParentL->verifyLoop(); 1400 #endif 1401 1402 // Clear any cached analysis results for L if we removed it completely. 1403 if (LAM && Result == LoopUnrollResult::FullyUnrolled) 1404 LAM->clear(L, LoopName); 1405 } 1406 1407 if (!Changed) 1408 return PreservedAnalyses::all(); 1409 1410 return getLoopPassPreservedAnalyses(); 1411 } 1412