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