Lines Matching +full:count +full:- +full:threshold
1 //===- LoopUnroll.cpp - Loop unroller pass --------------------------------===//
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7 //===----------------------------------------------------------------------===//
10 // been canonicalized by the -indvars pass, allowing it to determine the trip
12 //===----------------------------------------------------------------------===//
74 #define DEBUG_TYPE "loop-unroll"
77 "forget-scev-loop-unroll", cl::init(false), cl::Hidden,
79 " the current top-most loop. This is sometimes preferred to reduce"
83 UnrollThreshold("unroll-threshold", cl::Hidden,
84 cl::desc("The cost threshold for loop unrolling"));
88 "unroll-optsize-threshold", cl::init(0), cl::Hidden,
89 cl::desc("The cost threshold for loop unrolling when optimizing for "
93 "unroll-partial-threshold", cl::Hidden,
94 cl::desc("The cost threshold for partial loop unrolling"));
97 "unroll-max-percent-threshold-boost", cl::init(400), cl::Hidden,
99 "to the threshold when aggressively unrolling a loop due to the "
102 "threshold to DefaultThreshold*std::min(MaxPercentThresholdBoost, "
106 "unroll-max-iteration-count-to-analyze", cl::init(10), cl::Hidden,
111 "unroll-count", cl::Hidden,
112 cl::desc("Use this unroll count for all loops including those with "
116 "unroll-max-count", cl::Hidden,
117 cl::desc("Set the max unroll count for partial and runtime unrolling, for"
121 "unroll-full-max-count", cl::Hidden,
123 "Set the max unroll count for full unrolling, for testing purposes"));
126 UnrollAllowPartial("unroll-allow-partial", cl::Hidden,
128 "-unroll-threshold loop size is reached."));
131 "unroll-allow-remainder", cl::Hidden,
136 UnrollRuntime("unroll-runtime", cl::Hidden,
137 cl::desc("Unroll loops with run-time trip counts"));
140 "unroll-max-upperbound", cl::init(8), cl::Hidden,
142 "The max of trip count upper bound that is considered in unrolling"));
145 "pragma-unroll-threshold", cl::init(16 * 1024), cl::Hidden,
150 "flat-loop-tripcount-threshold", cl::init(5), cl::Hidden,
152 "threshold, the loop is considered as flat and will be less "
156 "unroll-remainder", cl::Hidden,
163 "unroll-revisit-child-loops", cl::Hidden,
164 cl::desc("Enqueue and re-visit child loops in the loop PM after unrolling. "
169 "unroll-threshold-aggressive", cl::init(300), cl::Hidden,
170 cl::desc("Threshold (max size of unrolled loop) to use in aggressive (O3) "
173 UnrollThresholdDefault("unroll-threshold-default", cl::init(150),
175 cl::desc("Default threshold (max size of unrolled "
179 "pragma-unroll-full-max-iterations", cl::init(1'000'000), cl::Hidden,
182 /// A magic value for use with the Threshold parameter to indicate
200 UP.Threshold = in gatherUnrollingPreferences()
206 UP.Count = 0; in gatherUnrollingPreferences()
227 bool OptForSize = L->getHeader()->getParent()->hasOptSize() || in gatherUnrollingPreferences()
230 llvm::shouldOptimizeForSize(L->getHeader(), PSI, BFI, in gatherUnrollingPreferences()
233 UP.Threshold = UP.OptSizeThreshold; in gatherUnrollingPreferences()
240 UP.Threshold = UnrollThreshold; in gatherUnrollingPreferences()
266 UP.Threshold = *UserThreshold; in gatherUnrollingPreferences()
270 UP.Count = *UserCount; in gatherUnrollingPreferences()
348 /// dynamic cost we mean that we won't count costs of blocks that are known not
351 /// cost of the 'false'-block).
360 // We want to be able to scale offsets by the trip count and add more offsets in analyzeLoopUnrollCost()
369 if (!L->isInnermost()) in analyzeLoopUnrollCost()
393 // this to recursively merge costs into the unrolled cost on-demand so that in analyzeLoopUnrollCost()
394 // we don't count the cost of any dead code. This is essentially a map from in analyzeLoopUnrollCost()
402 // PHI-used worklist used between iterations while accumulating cost. in analyzeLoopUnrollCost()
412 RootI.getFunction()->hasMinSize() ? in analyzeLoopUnrollCost()
415 for (;; --Iteration) { in analyzeLoopUnrollCost()
437 if (PhiI->getParent() == L->getHeader()) { in analyzeLoopUnrollCost()
444 // if it is an in-loop instruction. We'll use this to populate the in analyzeLoopUnrollCost()
445 // cost worklist for the next iteration (as we count backwards). in analyzeLoopUnrollCost()
447 PhiI->getIncomingValueForBlock(L->getLoopLatch()))) in analyzeLoopUnrollCost()
448 if (L->contains(OpI)) in analyzeLoopUnrollCost()
457 transform(I->operands(), std::back_inserter(Operands), in analyzeLoopUnrollCost()
466 LLVM_DEBUG(I->dump()); in analyzeLoopUnrollCost()
469 // We must count the cost of every operand which is not free, in analyzeLoopUnrollCost()
472 for (Value *Op : I->operands()) { in analyzeLoopUnrollCost()
476 if (!OpI || !L->contains(OpI)) in analyzeLoopUnrollCost()
489 "Cannot track PHI-used values past the first iteration!"); in analyzeLoopUnrollCost()
497 assert(L->isLoopSimplifyForm() && "Must put loop into normal form first."); in analyzeLoopUnrollCost()
498 assert(L->isLCSSAForm(DT) && in analyzeLoopUnrollCost()
499 "Must have loops in LCSSA form to track live-out values."); in analyzeLoopUnrollCost()
504 L->getHeader()->getParent()->hasMinSize() ? in analyzeLoopUnrollCost()
515 for (Instruction &I : *L->getHeader()) { in analyzeLoopUnrollCost()
523 PHI->getNumIncomingValues() == 2 && in analyzeLoopUnrollCost()
526 Value *V = PHI->getIncomingValueForBlock( in analyzeLoopUnrollCost()
527 Iteration == 0 ? L->getLoopPreheader() : L->getLoopLatch()); in analyzeLoopUnrollCost()
528 if (Iteration != 0 && SimplifiedValues.count(V)) in analyzeLoopUnrollCost()
533 // Now clear and re-populate the map for the next iteration. in analyzeLoopUnrollCost()
541 BBWorklist.insert(L->getHeader()); in analyzeLoopUnrollCost()
547 // it. We don't change the actual IR, just count optimization in analyzeLoopUnrollCost()
550 // These won't get into the final code - don't even try calculating the in analyzeLoopUnrollCost()
552 if (isa<DbgInfoIntrinsic>(I) || EphValues.count(&I)) in analyzeLoopUnrollCost()
575 const Function *Callee = CI->getCalledFunction(); in analyzeLoopUnrollCost()
582 // If the instruction might have a side-effect recursively account for in analyzeLoopUnrollCost()
589 LLVM_DEBUG(dbgs() << " Exceeded threshold.. exiting.\n" in analyzeLoopUnrollCost()
597 Instruction *TI = BB->getTerminator(); in analyzeLoopUnrollCost()
599 auto getSimplifiedConstant = [&](Value *V) -> Constant * { in analyzeLoopUnrollCost()
600 if (SimplifiedValues.count(V)) in analyzeLoopUnrollCost()
609 if (BI->isConditional()) { in analyzeLoopUnrollCost()
610 if (auto *SimpleCond = getSimplifiedConstant(BI->getCondition())) { in analyzeLoopUnrollCost()
613 KnownSucc = BI->getSuccessor(0); in analyzeLoopUnrollCost()
616 KnownSucc = BI->getSuccessor(SimpleCondVal->isZero() ? 1 : 0); in analyzeLoopUnrollCost()
620 if (auto *SimpleCond = getSimplifiedConstant(SI->getCondition())) { in analyzeLoopUnrollCost()
623 KnownSucc = SI->getSuccessor(0); in analyzeLoopUnrollCost()
626 KnownSucc = SI->findCaseValue(SimpleCondVal)->getCaseSuccessor(); in analyzeLoopUnrollCost()
630 if (L->contains(KnownSucc)) in analyzeLoopUnrollCost()
639 if (L->contains(Succ)) in analyzeLoopUnrollCost()
664 Value *Op = PN->getIncomingValueForBlock(ExitingBB); in analyzeLoopUnrollCost()
666 if (L->contains(OpI)) in analyzeLoopUnrollCost()
667 AddCostRecursively(*OpI, TripCount - 1); in analyzeLoopUnrollCost()
686 for (BasicBlock *BB : L->blocks()) in UnrollCostEstimator()
721 LLVM_DEBUG(dbgs() << " Non-duplicatable blocks prevent unrolling.\n"); in canUnroll()
733 return static_cast<uint64_t>(LS - UP.BEInsns) * CountOverwrite + UP.BEInsns; in getUnrolledLoopSize()
735 return static_cast<uint64_t>(LS - UP.BEInsns) * UP.Count + UP.BEInsns; in getUnrolledLoopSize()
739 // "llvm.loop.unroll.count"). If no such metadata node exists, then nullptr is
742 if (MDNode *LoopID = L->getLoopID()) in getUnrollMetadataForLoop()
766 MDNode *MD = getUnrollMetadataForLoop(L, "llvm.loop.unroll.count"); in unrollCountPragmaValue()
768 assert(MD->getNumOperands() == 2 && in unrollCountPragmaValue()
769 "Unroll count hint metadata should have two operands."); in unrollCountPragmaValue()
770 unsigned Count = in unrollCountPragmaValue() local
771 mdconst::extract<ConstantInt>(MD->getOperand(1))->getZExtValue(); in unrollCountPragmaValue()
772 assert(Count >= 1 && "Unroll count must be positive."); in unrollCountPragmaValue()
773 return Count; in unrollCountPragmaValue()
782 // the unroll threshold.
802 // 1st priority is unroll count set by "unroll-count" option. in shouldPragmaUnroll()
806 UCE.getUnrolledLoopSize(UP, (unsigned)UnrollCount) < UP.Threshold) in shouldPragmaUnroll()
810 // 2nd priority is unroll count set by pragma. in shouldPragmaUnroll()
817 // Certain cases with UBSAN can cause trip count to be calculated as in shouldPragmaUnroll()
821 LLVM_DEBUG(dbgs() << "Won't unroll; trip count is too large\n"); in shouldPragmaUnroll()
841 assert(FullUnrollTripCount && "should be non-zero!"); in shouldFullUnroll()
848 if (UCE.getUnrolledLoopSize(UP) < UP.Threshold) in shouldFullUnroll()
856 UP.Threshold * UP.MaxPercentThresholdBoost / 100, in shouldFullUnroll()
860 if (Cost->UnrolledCost < UP.Threshold * Boost / 100) in shouldFullUnroll()
876 << "-unroll-allow-partial not given\n"); in shouldPartialUnroll()
879 unsigned count = UP.Count; in shouldPartialUnroll() local
880 if (count == 0) in shouldPartialUnroll()
881 count = TripCount; in shouldPartialUnroll()
883 // Reduce unroll count to be modulo of TripCount for partial unrolling. in shouldPartialUnroll()
884 if (UCE.getUnrolledLoopSize(UP, count) > UP.PartialThreshold) in shouldPartialUnroll()
885 count = (std::max(UP.PartialThreshold, UP.BEInsns + 1) - UP.BEInsns) / in shouldPartialUnroll()
886 (LoopSize - UP.BEInsns); in shouldPartialUnroll()
887 if (count > UP.MaxCount) in shouldPartialUnroll()
888 count = UP.MaxCount; in shouldPartialUnroll()
889 while (count != 0 && TripCount % count != 0) in shouldPartialUnroll()
890 count--; in shouldPartialUnroll()
891 if (UP.AllowRemainder && count <= 1) { in shouldPartialUnroll()
892 // If there is no Count that is modulo of TripCount, set Count to in shouldPartialUnroll()
893 // largest power-of-two factor that satisfies the threshold limit. in shouldPartialUnroll()
896 count = UP.DefaultUnrollRuntimeCount; in shouldPartialUnroll()
897 while (count != 0 && in shouldPartialUnroll()
898 UCE.getUnrolledLoopSize(UP, count) > UP.PartialThreshold) in shouldPartialUnroll()
899 count >>= 1; in shouldPartialUnroll()
901 if (count < 2) { in shouldPartialUnroll()
902 count = 0; in shouldPartialUnroll()
905 count = TripCount; in shouldPartialUnroll()
907 if (count > UP.MaxCount) in shouldPartialUnroll()
908 count = UP.MaxCount; in shouldPartialUnroll()
910 LLVM_DEBUG(dbgs() << " partially unrolling with count: " << count << "\n"); in shouldPartialUnroll()
912 return count; in shouldPartialUnroll()
914 // Returns true if unroll count was set explicitly.
915 // Calculates unroll count and writes it to UP.Count.
916 // Unless IgnoreUser is true, will also use metadata and command-line options
920 // many LoopUnroll-specific options. The shared functionality should be
943 // Use an explicit peel count that has been specified for testing. In this in computeUnrollCount()
944 // case it's not permitted to also specify an explicit unroll count. in computeUnrollCount()
947 report_fatal_error("Cannot specify both explicit peel count and " in computeUnrollCount()
948 "explicit unroll count", /*GenCrashDiag=*/false); in computeUnrollCount()
950 UP.Count = 1; in computeUnrollCount()
954 // Check for explicit Count. in computeUnrollCount()
955 // 1st priority is unroll count set by "unroll-count" option. in computeUnrollCount()
956 // 2nd priority is unroll count set by pragma. in computeUnrollCount()
959 UP.Count = *UnrollFactor; in computeUnrollCount()
972 UP.Threshold = std::max<unsigned>(UP.Threshold, PragmaUnrollThreshold); in computeUnrollCount()
980 UP.Count = 0; in computeUnrollCount()
982 UP.Count = TripCount; in computeUnrollCount()
985 UP.Count = *UnrollFactor; in computeUnrollCount()
995 // loop tests remains the same compared to the non-unrolled version, whereas in computeUnrollCount()
1001 // cost of exact full unrolling. As such, if we have an exact count and in computeUnrollCount()
1005 UP.Count = MaxTripCount; in computeUnrollCount()
1008 UP.Count = *UnrollFactor; in computeUnrollCount()
1015 computePeelCount(L, LoopSize, PP, TripCount, DT, SE, AC, UP.Threshold); in computeUnrollCount()
1018 UP.Count = 1; in computeUnrollCount()
1030 UP.Count = *UnrollFactor; in computeUnrollCount()
1033 UP.Count != TripCount) in computeUnrollCount()
1034 ORE->emit([&]() { in computeUnrollCount()
1037 L->getStartLoc(), L->getHeader()) in computeUnrollCount()
1044 if (UP.Count == 0) { in computeUnrollCount()
1046 ORE->emit([&]() { in computeUnrollCount()
1049 L->getStartLoc(), L->getHeader()) in computeUnrollCount()
1061 ORE->emit([&]() { in computeUnrollCount()
1064 L->getStartLoc(), L->getHeader()) in computeUnrollCount()
1067 "because loop has a runtime trip count."; in computeUnrollCount()
1071 // Don't unroll a runtime trip count loop when it is disabled. in computeUnrollCount()
1073 UP.Count = 0; in computeUnrollCount()
1079 UP.Count = 0; in computeUnrollCount()
1083 // Check if the runtime trip count is too small when profile is available. in computeUnrollCount()
1084 if (L->getHeader()->getParent()->hasProfileData()) { in computeUnrollCount()
1095 dbgs() << " will not try to unroll loop with runtime trip count " in computeUnrollCount()
1096 << "-unroll-runtime not given\n"); in computeUnrollCount()
1097 UP.Count = 0; in computeUnrollCount()
1100 if (UP.Count == 0) in computeUnrollCount()
1101 UP.Count = UP.DefaultUnrollRuntimeCount; in computeUnrollCount()
1103 // Reduce unroll count to be the largest power-of-two factor of in computeUnrollCount()
1104 // the original count which satisfies the threshold limit. in computeUnrollCount()
1105 while (UP.Count != 0 && in computeUnrollCount()
1107 UP.Count >>= 1; in computeUnrollCount()
1110 unsigned OrigCount = UP.Count; in computeUnrollCount()
1113 if (!UP.AllowRemainder && UP.Count != 0 && (TripMultiple % UP.Count) != 0) { in computeUnrollCount()
1114 while (UP.Count != 0 && TripMultiple % UP.Count != 0) in computeUnrollCount()
1115 UP.Count >>= 1; in computeUnrollCount()
1119 "instruction), so unroll count must divide the trip " in computeUnrollCount()
1121 << TripMultiple << ". Reducing unroll count from " << OrigCount in computeUnrollCount()
1122 << " to " << UP.Count << ".\n"); in computeUnrollCount()
1127 ORE->emit([&]() { in computeUnrollCount()
1130 L->getStartLoc(), L->getHeader()) in computeUnrollCount()
1136 "count that divides the loop trip multiple of " in computeUnrollCount()
1138 << NV("UnrollCount", UP.Count) << " time(s)."; in computeUnrollCount()
1142 if (UP.Count > UP.MaxCount) in computeUnrollCount()
1143 UP.Count = UP.MaxCount; in computeUnrollCount()
1145 if (MaxTripCount && UP.Count > MaxTripCount) in computeUnrollCount()
1146 UP.Count = MaxTripCount; in computeUnrollCount()
1148 LLVM_DEBUG(dbgs() << " runtime unrolling with count: " << UP.Count in computeUnrollCount()
1150 if (UP.Count < 2) in computeUnrollCount()
1151 UP.Count = 0; in computeUnrollCount()
1172 << L->getHeader()->getParent()->getName() << "] Loop %" in tryToUnrollLoop()
1173 << L->getHeader()->getName() << "\n"); in tryToUnrollLoop()
1179 // parent loop has an explicit unroll-and-jam pragma. This is to prevent in tryToUnrollLoop()
1182 Loop *ParentL = L->getParentLoop(); in tryToUnrollLoop()
1192 // loop has an explicit unroll-and-jam pragma. This is to prevent automatic in tryToUnrollLoop()
1202 if (!L->isLoopSimplifyForm()) { in tryToUnrollLoop()
1204 dbgs() << " Not unrolling loop which is not in loop-simplify form.\n"); in tryToUnrollLoop()
1213 bool OptForSize = L->getHeader()->getParent()->hasOptSize(); in tryToUnrollLoop()
1222 // as threshold later on. in tryToUnrollLoop()
1223 if (UP.Threshold == 0 && (!UP.Partial || UP.PartialThreshold == 0) && in tryToUnrollLoop()
1239 // When optimizing for size, use LoopSize + 1 as threshold (we use < Threshold in tryToUnrollLoop()
1242 UP.Threshold = std::max(UP.Threshold, LoopSize + 1); in tryToUnrollLoop()
1249 // Find the smallest exact trip count for any exit. This is an upper bound in tryToUnrollLoop()
1250 // on the loop trip count, but an exit at an earlier iteration is still in tryToUnrollLoop()
1251 // possible. An unroll by the smallest exact trip count guarantees that all in tryToUnrollLoop()
1253 // the max trip count, which only guarantees that the backedge can be broken. in tryToUnrollLoop()
1257 L->getExitingBlocks(ExitingBlocks); in tryToUnrollLoop()
1264 // If no exact trip count is known, determine the trip multiple of either in tryToUnrollLoop()
1267 BasicBlock *ExitingBlock = L->getLoopLatch(); in tryToUnrollLoop()
1268 if (!ExitingBlock || !L->isLoopExiting(ExitingBlock)) in tryToUnrollLoop()
1269 ExitingBlock = L->getExitingBlock(); in tryToUnrollLoop()
1276 // is unsafe -- it adds a control-flow dependency to the convergent in tryToUnrollLoop()
1280 // trip count is uniform. in tryToUnrollLoop()
1283 // Try to find the trip count upper bound if we cannot find the exact trip in tryToUnrollLoop()
1284 // count. in tryToUnrollLoop()
1298 if (!UP.Count) in tryToUnrollLoop()
1304 assert(UP.Count == 1 && "Cannot perform peel and unroll in the same step"); in tryToUnrollLoop()
1305 LLVM_DEBUG(dbgs() << "PEELING loop %" << L->getHeader()->getName() in tryToUnrollLoop()
1306 << " with iteration count " << PP.PeelCount << "!\n"); in tryToUnrollLoop()
1308 return OptimizationRemark(DEBUG_TYPE, "Peeled", L->getStartLoc(), in tryToUnrollLoop()
1309 L->getHeader()) in tryToUnrollLoop()
1320 L->setLoopAlreadyUnrolled(); in tryToUnrollLoop()
1327 if (OnlyFullUnroll && (UP.Count < TripCount || UP.Count < MaxTripCount)) { in tryToUnrollLoop()
1333 // At this point, UP.Runtime indicates that run-time unrolling is allowed. in tryToUnrollLoop()
1335 // count and the unroll count doesn't divide the known trip multiple. in tryToUnrollLoop()
1338 UP.Runtime &= TripCount == 0 && TripMultiple % UP.Count != 0; in tryToUnrollLoop()
1341 MDNode *OrigLoopID = L->getLoopID(); in tryToUnrollLoop()
1346 ULO.Count = UP.Count; in tryToUnrollLoop()
1363 RemainderLoop->setLoopID(*RemainderLoopID); in tryToUnrollLoop()
1371 L->setLoopID(*NewLoopID); in tryToUnrollLoop()
1379 // If loop has an unroll count pragma or unrolled by explicitly set count in tryToUnrollLoop()
1382 L->setLoopAlreadyUnrolled(); in tryToUnrollLoop()
1401 /// top-most loop (call forgetTopMostLoop), of the loop being processed.
1416 std::optional<unsigned> Threshold = std::nullopt, in LoopUnroll() argument
1417 std::optional<unsigned> Count = std::nullopt, in LoopUnroll() argument
1425 ForgetAllSCEV(ForgetAllSCEV), ProvidedCount(std::move(Count)), in LoopUnroll()
1426 ProvidedThreshold(Threshold), ProvidedAllowPartial(AllowPartial), in LoopUnroll()
1438 Function &F = *L->getHeader()->getParent(); in runOnLoop()
1480 INITIALIZE_PASS_BEGIN(LoopUnroll, "loop-unroll", "Unroll loops", false, false)
1484 INITIALIZE_PASS_END(LoopUnroll, "loop-unroll", "Unroll loops", false, false) in INITIALIZE_PASS_DEPENDENCY()
1487 bool ForgetAllSCEV, int Threshold, int Count, in INITIALIZE_PASS_DEPENDENCY()
1495 Threshold == -1 ? std::nullopt : std::optional<unsigned>(Threshold), in INITIALIZE_PASS_DEPENDENCY()
1496 Count == -1 ? std::nullopt : std::optional<unsigned>(Count), in INITIALIZE_PASS_DEPENDENCY()
1497 AllowPartial == -1 ? std::nullopt : std::optional<bool>(AllowPartial), in INITIALIZE_PASS_DEPENDENCY()
1498 Runtime == -1 ? std::nullopt : std::optional<bool>(Runtime), in INITIALIZE_PASS_DEPENDENCY()
1499 UpperBound == -1 ? std::nullopt : std::optional<bool>(UpperBound), in INITIALIZE_PASS_DEPENDENCY()
1500 AllowPeeling == -1 ? std::nullopt : std::optional<bool>(AllowPeeling)); in INITIALIZE_PASS_DEPENDENCY()
1509 OptimizationRemarkEmitter ORE(L.getHeader()->getParent()); in run()
1516 OldLoops.insert(ParentL->begin(), ParentL->end()); in run()
1526 OnlyWhenForced, ForgetSCEV, /*Count*/ std::nullopt, in run()
1527 /*Threshold*/ std::nullopt, /*AllowPartial*/ false, in run()
1539 ParentL->verifyLoop(); in run()
1543 // - Full unrolling clones child loops within the current loop but then in run()
1561 SibLoops.append(ParentL->begin(), ParentL->end()); in run()
1605 LAM = &LAMProxy->getManager(); in run()
1610 auto *BFI = (PSI && PSI->hasProfileSummary()) ? in run()
1645 if (PSI && PSI->hasHugeWorkingSetSize()) in run()
1654 /*Count*/ std::nullopt, in run()
1655 /*Threshold*/ std::nullopt, UnrollOpts.AllowPartial, in run()
1664 ParentL->verifyLoop(); in run()
1669 LAM->clear(L, LoopName); in run()
1680 static_cast<PassInfoMixin<LoopUnrollPass> *>(this)->printPipeline( in printPipeline()
1684 OS << (*UnrollOpts.AllowPartial ? "" : "no-") << "partial;"; in printPipeline()
1686 OS << (*UnrollOpts.AllowPeeling ? "" : "no-") << "peeling;"; in printPipeline()
1688 OS << (*UnrollOpts.AllowRuntime ? "" : "no-") << "runtime;"; in printPipeline()
1690 OS << (*UnrollOpts.AllowUpperBound ? "" : "no-") << "upperbound;"; in printPipeline()
1692 OS << (*UnrollOpts.AllowProfileBasedPeeling ? "" : "no-") in printPipeline()
1693 << "profile-peeling;"; in printPipeline()
1695 OS << "full-unroll-max=" << UnrollOpts.FullUnrollMaxCount << ';'; in printPipeline()