Bug Summary

File:lib/Transforms/Vectorize/LoopVectorize.cpp
Warning:line 6450, column 35
Potential leak of memory pointed to by 'BlockMask'

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name LoopVectorize.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mthread-model posix -fmath-errno -masm-verbose -mconstructor-aliases -munwind-tables -fuse-init-array -target-cpu x86-64 -dwarf-column-info -debugger-tuning=gdb -momit-leaf-frame-pointer -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-9/lib/clang/9.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-9~svn362543/build-llvm/lib/Transforms/Vectorize -I /build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize -I /build/llvm-toolchain-snapshot-9~svn362543/build-llvm/include -I /build/llvm-toolchain-snapshot-9~svn362543/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0/backward -internal-isystem /usr/include/clang/9.0.0/include/ -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-9/lib/clang/9.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-comment -std=c++11 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-9~svn362543/build-llvm/lib/Transforms/Vectorize -fdebug-prefix-map=/build/llvm-toolchain-snapshot-9~svn362543=. -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -stack-protector 2 -fobjc-runtime=gcc -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -o /tmp/scan-build-2019-06-05-060531-1271-1 -x c++ /build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp -faddrsig

/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp

1//===- LoopVectorize.cpp - A Loop Vectorizer ------------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This is the LLVM loop vectorizer. This pass modifies 'vectorizable' loops
10// and generates target-independent LLVM-IR.
11// The vectorizer uses the TargetTransformInfo analysis to estimate the costs
12// of instructions in order to estimate the profitability of vectorization.
13//
14// The loop vectorizer combines consecutive loop iterations into a single
15// 'wide' iteration. After this transformation the index is incremented
16// by the SIMD vector width, and not by one.
17//
18// This pass has three parts:
19// 1. The main loop pass that drives the different parts.
20// 2. LoopVectorizationLegality - A unit that checks for the legality
21// of the vectorization.
22// 3. InnerLoopVectorizer - A unit that performs the actual
23// widening of instructions.
24// 4. LoopVectorizationCostModel - A unit that checks for the profitability
25// of vectorization. It decides on the optimal vector width, which
26// can be one, if vectorization is not profitable.
27//
28// There is a development effort going on to migrate loop vectorizer to the
29// VPlan infrastructure and to introduce outer loop vectorization support (see
30// docs/Proposal/VectorizationPlan.rst and
31// http://lists.llvm.org/pipermail/llvm-dev/2017-December/119523.html). For this
32// purpose, we temporarily introduced the VPlan-native vectorization path: an
33// alternative vectorization path that is natively implemented on top of the
34// VPlan infrastructure. See EnableVPlanNativePath for enabling.
35//
36//===----------------------------------------------------------------------===//
37//
38// The reduction-variable vectorization is based on the paper:
39// D. Nuzman and R. Henderson. Multi-platform Auto-vectorization.
40//
41// Variable uniformity checks are inspired by:
42// Karrenberg, R. and Hack, S. Whole Function Vectorization.
43//
44// The interleaved access vectorization is based on the paper:
45// Dorit Nuzman, Ira Rosen and Ayal Zaks. Auto-Vectorization of Interleaved
46// Data for SIMD
47//
48// Other ideas/concepts are from:
49// A. Zaks and D. Nuzman. Autovectorization in GCC-two years later.
50//
51// S. Maleki, Y. Gao, M. Garzaran, T. Wong and D. Padua. An Evaluation of
52// Vectorizing Compilers.
53//
54//===----------------------------------------------------------------------===//
55
56#include "llvm/Transforms/Vectorize/LoopVectorize.h"
57#include "LoopVectorizationPlanner.h"
58#include "VPRecipeBuilder.h"
59#include "VPlan.h"
60#include "VPlanHCFGBuilder.h"
61#include "VPlanHCFGTransforms.h"
62#include "VPlanPredicator.h"
63#include "llvm/ADT/APInt.h"
64#include "llvm/ADT/ArrayRef.h"
65#include "llvm/ADT/DenseMap.h"
66#include "llvm/ADT/DenseMapInfo.h"
67#include "llvm/ADT/Hashing.h"
68#include "llvm/ADT/MapVector.h"
69#include "llvm/ADT/None.h"
70#include "llvm/ADT/Optional.h"
71#include "llvm/ADT/STLExtras.h"
72#include "llvm/ADT/SetVector.h"
73#include "llvm/ADT/SmallPtrSet.h"
74#include "llvm/ADT/SmallVector.h"
75#include "llvm/ADT/Statistic.h"
76#include "llvm/ADT/StringRef.h"
77#include "llvm/ADT/Twine.h"
78#include "llvm/ADT/iterator_range.h"
79#include "llvm/Analysis/AssumptionCache.h"
80#include "llvm/Analysis/BasicAliasAnalysis.h"
81#include "llvm/Analysis/BlockFrequencyInfo.h"
82#include "llvm/Analysis/CFG.h"
83#include "llvm/Analysis/CodeMetrics.h"
84#include "llvm/Analysis/DemandedBits.h"
85#include "llvm/Analysis/GlobalsModRef.h"
86#include "llvm/Analysis/LoopAccessAnalysis.h"
87#include "llvm/Analysis/LoopAnalysisManager.h"
88#include "llvm/Analysis/LoopInfo.h"
89#include "llvm/Analysis/LoopIterator.h"
90#include "llvm/Analysis/MemorySSA.h"
91#include "llvm/Analysis/OptimizationRemarkEmitter.h"
92#include "llvm/Analysis/ProfileSummaryInfo.h"
93#include "llvm/Analysis/ScalarEvolution.h"
94#include "llvm/Analysis/ScalarEvolutionExpander.h"
95#include "llvm/Analysis/ScalarEvolutionExpressions.h"
96#include "llvm/Analysis/TargetLibraryInfo.h"
97#include "llvm/Analysis/TargetTransformInfo.h"
98#include "llvm/Analysis/VectorUtils.h"
99#include "llvm/IR/Attributes.h"
100#include "llvm/IR/BasicBlock.h"
101#include "llvm/IR/CFG.h"
102#include "llvm/IR/Constant.h"
103#include "llvm/IR/Constants.h"
104#include "llvm/IR/DataLayout.h"
105#include "llvm/IR/DebugInfoMetadata.h"
106#include "llvm/IR/DebugLoc.h"
107#include "llvm/IR/DerivedTypes.h"
108#include "llvm/IR/DiagnosticInfo.h"
109#include "llvm/IR/Dominators.h"
110#include "llvm/IR/Function.h"
111#include "llvm/IR/IRBuilder.h"
112#include "llvm/IR/InstrTypes.h"
113#include "llvm/IR/Instruction.h"
114#include "llvm/IR/Instructions.h"
115#include "llvm/IR/IntrinsicInst.h"
116#include "llvm/IR/Intrinsics.h"
117#include "llvm/IR/LLVMContext.h"
118#include "llvm/IR/Metadata.h"
119#include "llvm/IR/Module.h"
120#include "llvm/IR/Operator.h"
121#include "llvm/IR/Type.h"
122#include "llvm/IR/Use.h"
123#include "llvm/IR/User.h"
124#include "llvm/IR/Value.h"
125#include "llvm/IR/ValueHandle.h"
126#include "llvm/IR/Verifier.h"
127#include "llvm/Pass.h"
128#include "llvm/Support/Casting.h"
129#include "llvm/Support/CommandLine.h"
130#include "llvm/Support/Compiler.h"
131#include "llvm/Support/Debug.h"
132#include "llvm/Support/ErrorHandling.h"
133#include "llvm/Support/MathExtras.h"
134#include "llvm/Support/raw_ostream.h"
135#include "llvm/Transforms/Utils/BasicBlockUtils.h"
136#include "llvm/Transforms/Utils/LoopSimplify.h"
137#include "llvm/Transforms/Utils/LoopUtils.h"
138#include "llvm/Transforms/Utils/LoopVersioning.h"
139#include "llvm/Transforms/Utils/SizeOpts.h"
140#include "llvm/Transforms/Vectorize/LoopVectorizationLegality.h"
141#include <algorithm>
142#include <cassert>
143#include <cstdint>
144#include <cstdlib>
145#include <functional>
146#include <iterator>
147#include <limits>
148#include <memory>
149#include <string>
150#include <tuple>
151#include <utility>
152#include <vector>
153
154using namespace llvm;
155
156#define LV_NAME"loop-vectorize" "loop-vectorize"
157#define DEBUG_TYPE"loop-vectorize" LV_NAME"loop-vectorize"
158
159/// @{
160/// Metadata attribute names
161static const char *const LLVMLoopVectorizeFollowupAll =
162 "llvm.loop.vectorize.followup_all";
163static const char *const LLVMLoopVectorizeFollowupVectorized =
164 "llvm.loop.vectorize.followup_vectorized";
165static const char *const LLVMLoopVectorizeFollowupEpilogue =
166 "llvm.loop.vectorize.followup_epilogue";
167/// @}
168
169STATISTIC(LoopsVectorized, "Number of loops vectorized")static llvm::Statistic LoopsVectorized = {"loop-vectorize", "LoopsVectorized"
, "Number of loops vectorized", {0}, {false}}
;
170STATISTIC(LoopsAnalyzed, "Number of loops analyzed for vectorization")static llvm::Statistic LoopsAnalyzed = {"loop-vectorize", "LoopsAnalyzed"
, "Number of loops analyzed for vectorization", {0}, {false}}
;
171
172/// Loops with a known constant trip count below this number are vectorized only
173/// if no scalar iteration overheads are incurred.
174static cl::opt<unsigned> TinyTripCountVectorThreshold(
175 "vectorizer-min-trip-count", cl::init(16), cl::Hidden,
176 cl::desc("Loops with a constant trip count that is smaller than this "
177 "value are vectorized only if no scalar iteration overheads "
178 "are incurred."));
179
180static cl::opt<bool> MaximizeBandwidth(
181 "vectorizer-maximize-bandwidth", cl::init(false), cl::Hidden,
182 cl::desc("Maximize bandwidth when selecting vectorization factor which "
183 "will be determined by the smallest type in loop."));
184
185static cl::opt<bool> EnableInterleavedMemAccesses(
186 "enable-interleaved-mem-accesses", cl::init(false), cl::Hidden,
187 cl::desc("Enable vectorization on interleaved memory accesses in a loop"));
188
189/// An interleave-group may need masking if it resides in a block that needs
190/// predication, or in order to mask away gaps.
191static cl::opt<bool> EnableMaskedInterleavedMemAccesses(
192 "enable-masked-interleaved-mem-accesses", cl::init(false), cl::Hidden,
193 cl::desc("Enable vectorization on masked interleaved memory accesses in a loop"));
194
195/// We don't interleave loops with a known constant trip count below this
196/// number.
197static const unsigned TinyTripCountInterleaveThreshold = 128;
198
199static cl::opt<unsigned> ForceTargetNumScalarRegs(
200 "force-target-num-scalar-regs", cl::init(0), cl::Hidden,
201 cl::desc("A flag that overrides the target's number of scalar registers."));
202
203static cl::opt<unsigned> ForceTargetNumVectorRegs(
204 "force-target-num-vector-regs", cl::init(0), cl::Hidden,
205 cl::desc("A flag that overrides the target's number of vector registers."));
206
207static cl::opt<unsigned> ForceTargetMaxScalarInterleaveFactor(
208 "force-target-max-scalar-interleave", cl::init(0), cl::Hidden,
209 cl::desc("A flag that overrides the target's max interleave factor for "
210 "scalar loops."));
211
212static cl::opt<unsigned> ForceTargetMaxVectorInterleaveFactor(
213 "force-target-max-vector-interleave", cl::init(0), cl::Hidden,
214 cl::desc("A flag that overrides the target's max interleave factor for "
215 "vectorized loops."));
216
217static cl::opt<unsigned> ForceTargetInstructionCost(
218 "force-target-instruction-cost", cl::init(0), cl::Hidden,
219 cl::desc("A flag that overrides the target's expected cost for "
220 "an instruction to a single constant value. Mostly "
221 "useful for getting consistent testing."));
222
223static cl::opt<unsigned> SmallLoopCost(
224 "small-loop-cost", cl::init(20), cl::Hidden,
225 cl::desc(
226 "The cost of a loop that is considered 'small' by the interleaver."));
227
228static cl::opt<bool> LoopVectorizeWithBlockFrequency(
229 "loop-vectorize-with-block-frequency", cl::init(true), cl::Hidden,
230 cl::desc("Enable the use of the block frequency analysis to access PGO "
231 "heuristics minimizing code growth in cold regions and being more "
232 "aggressive in hot regions."));
233
234// Runtime interleave loops for load/store throughput.
235static cl::opt<bool> EnableLoadStoreRuntimeInterleave(
236 "enable-loadstore-runtime-interleave", cl::init(true), cl::Hidden,
237 cl::desc(
238 "Enable runtime interleaving until load/store ports are saturated"));
239
240/// The number of stores in a loop that are allowed to need predication.
241static cl::opt<unsigned> NumberOfStoresToPredicate(
242 "vectorize-num-stores-pred", cl::init(1), cl::Hidden,
243 cl::desc("Max number of stores to be predicated behind an if."));
244
245static cl::opt<bool> EnableIndVarRegisterHeur(
246 "enable-ind-var-reg-heur", cl::init(true), cl::Hidden,
247 cl::desc("Count the induction variable only once when interleaving"));
248
249static cl::opt<bool> EnableCondStoresVectorization(
250 "enable-cond-stores-vec", cl::init(true), cl::Hidden,
251 cl::desc("Enable if predication of stores during vectorization."));
252
253static cl::opt<unsigned> MaxNestedScalarReductionIC(
254 "max-nested-scalar-reduction-interleave", cl::init(2), cl::Hidden,
255 cl::desc("The maximum interleave count to use when interleaving a scalar "
256 "reduction in a nested loop."));
257
258cl::opt<bool> EnableVPlanNativePath(
259 "enable-vplan-native-path", cl::init(false), cl::Hidden,
260 cl::desc("Enable VPlan-native vectorization path with "
261 "support for outer loop vectorization."));
262
263// FIXME: Remove this switch once we have divergence analysis. Currently we
264// assume divergent non-backedge branches when this switch is true.
265cl::opt<bool> EnableVPlanPredication(
266 "enable-vplan-predication", cl::init(false), cl::Hidden,
267 cl::desc("Enable VPlan-native vectorization path predicator with "
268 "support for outer loop vectorization."));
269
270// This flag enables the stress testing of the VPlan H-CFG construction in the
271// VPlan-native vectorization path. It must be used in conjuction with
272// -enable-vplan-native-path. -vplan-verify-hcfg can also be used to enable the
273// verification of the H-CFGs built.
274static cl::opt<bool> VPlanBuildStressTest(
275 "vplan-build-stress-test", cl::init(false), cl::Hidden,
276 cl::desc(
277 "Build VPlan for every supported loop nest in the function and bail "
278 "out right after the build (stress test the VPlan H-CFG construction "
279 "in the VPlan-native vectorization path)."));
280
281cl::opt<bool> llvm::EnableLoopInterleaving(
282 "interleave-loops", cl::init(true), cl::Hidden,
283 cl::desc("Enable loop interleaving in Loop vectorization passes"));
284cl::opt<bool> llvm::EnableLoopVectorization(
285 "vectorize-loops", cl::init(true), cl::Hidden,
286 cl::desc("Run the Loop vectorization passes"));
287
288/// A helper function for converting Scalar types to vector types.
289/// If the incoming type is void, we return void. If the VF is 1, we return
290/// the scalar type.
291static Type *ToVectorTy(Type *Scalar, unsigned VF) {
292 if (Scalar->isVoidTy() || VF == 1)
293 return Scalar;
294 return VectorType::get(Scalar, VF);
295}
296
297/// A helper function that returns the type of loaded or stored value.
298static Type *getMemInstValueType(Value *I) {
299 assert((isa<LoadInst>(I) || isa<StoreInst>(I)) &&(((isa<LoadInst>(I) || isa<StoreInst>(I)) &&
"Expected Load or Store instruction") ? static_cast<void>
(0) : __assert_fail ("(isa<LoadInst>(I) || isa<StoreInst>(I)) && \"Expected Load or Store instruction\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 300, __PRETTY_FUNCTION__))
300 "Expected Load or Store instruction")(((isa<LoadInst>(I) || isa<StoreInst>(I)) &&
"Expected Load or Store instruction") ? static_cast<void>
(0) : __assert_fail ("(isa<LoadInst>(I) || isa<StoreInst>(I)) && \"Expected Load or Store instruction\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 300, __PRETTY_FUNCTION__))
;
301 if (auto *LI = dyn_cast<LoadInst>(I))
302 return LI->getType();
303 return cast<StoreInst>(I)->getValueOperand()->getType();
304}
305
306/// A helper function that returns true if the given type is irregular. The
307/// type is irregular if its allocated size doesn't equal the store size of an
308/// element of the corresponding vector type at the given vectorization factor.
309static bool hasIrregularType(Type *Ty, const DataLayout &DL, unsigned VF) {
310 // Determine if an array of VF elements of type Ty is "bitcast compatible"
311 // with a <VF x Ty> vector.
312 if (VF > 1) {
313 auto *VectorTy = VectorType::get(Ty, VF);
314 return VF * DL.getTypeAllocSize(Ty) != DL.getTypeStoreSize(VectorTy);
315 }
316
317 // If the vectorization factor is one, we just check if an array of type Ty
318 // requires padding between elements.
319 return DL.getTypeAllocSizeInBits(Ty) != DL.getTypeSizeInBits(Ty);
320}
321
322/// A helper function that returns the reciprocal of the block probability of
323/// predicated blocks. If we return X, we are assuming the predicated block
324/// will execute once for every X iterations of the loop header.
325///
326/// TODO: We should use actual block probability here, if available. Currently,
327/// we always assume predicated blocks have a 50% chance of executing.
328static unsigned getReciprocalPredBlockProb() { return 2; }
329
330/// A helper function that adds a 'fast' flag to floating-point operations.
331static Value *addFastMathFlag(Value *V) {
332 if (isa<FPMathOperator>(V))
333 cast<Instruction>(V)->setFastMathFlags(FastMathFlags::getFast());
334 return V;
335}
336
337static Value *addFastMathFlag(Value *V, FastMathFlags FMF) {
338 if (isa<FPMathOperator>(V))
339 cast<Instruction>(V)->setFastMathFlags(FMF);
340 return V;
341}
342
343/// A helper function that returns an integer or floating-point constant with
344/// value C.
345static Constant *getSignedIntOrFpConstant(Type *Ty, int64_t C) {
346 return Ty->isIntegerTy() ? ConstantInt::getSigned(Ty, C)
347 : ConstantFP::get(Ty, C);
348}
349
350namespace llvm {
351
352/// InnerLoopVectorizer vectorizes loops which contain only one basic
353/// block to a specified vectorization factor (VF).
354/// This class performs the widening of scalars into vectors, or multiple
355/// scalars. This class also implements the following features:
356/// * It inserts an epilogue loop for handling loops that don't have iteration
357/// counts that are known to be a multiple of the vectorization factor.
358/// * It handles the code generation for reduction variables.
359/// * Scalarization (implementation using scalars) of un-vectorizable
360/// instructions.
361/// InnerLoopVectorizer does not perform any vectorization-legality
362/// checks, and relies on the caller to check for the different legality
363/// aspects. The InnerLoopVectorizer relies on the
364/// LoopVectorizationLegality class to provide information about the induction
365/// and reduction variables that were found to a given vectorization factor.
366class InnerLoopVectorizer {
367public:
368 InnerLoopVectorizer(Loop *OrigLoop, PredicatedScalarEvolution &PSE,
369 LoopInfo *LI, DominatorTree *DT,
370 const TargetLibraryInfo *TLI,
371 const TargetTransformInfo *TTI, AssumptionCache *AC,
372 OptimizationRemarkEmitter *ORE, unsigned VecWidth,
373 unsigned UnrollFactor, LoopVectorizationLegality *LVL,
374 LoopVectorizationCostModel *CM)
375 : OrigLoop(OrigLoop), PSE(PSE), LI(LI), DT(DT), TLI(TLI), TTI(TTI),
376 AC(AC), ORE(ORE), VF(VecWidth), UF(UnrollFactor),
377 Builder(PSE.getSE()->getContext()),
378 VectorLoopValueMap(UnrollFactor, VecWidth), Legal(LVL), Cost(CM) {}
379 virtual ~InnerLoopVectorizer() = default;
380
381 /// Create a new empty loop. Unlink the old loop and connect the new one.
382 /// Return the pre-header block of the new loop.
383 BasicBlock *createVectorizedLoopSkeleton();
384
385 /// Widen a single instruction within the innermost loop.
386 void widenInstruction(Instruction &I);
387
388 /// Fix the vectorized code, taking care of header phi's, live-outs, and more.
389 void fixVectorizedLoop();
390
391 // Return true if any runtime check is added.
392 bool areSafetyChecksAdded() { return AddedSafetyChecks; }
393
394 /// A type for vectorized values in the new loop. Each value from the
395 /// original loop, when vectorized, is represented by UF vector values in the
396 /// new unrolled loop, where UF is the unroll factor.
397 using VectorParts = SmallVector<Value *, 2>;
398
399 /// Vectorize a single PHINode in a block. This method handles the induction
400 /// variable canonicalization. It supports both VF = 1 for unrolled loops and
401 /// arbitrary length vectors.
402 void widenPHIInstruction(Instruction *PN, unsigned UF, unsigned VF);
403
404 /// A helper function to scalarize a single Instruction in the innermost loop.
405 /// Generates a sequence of scalar instances for each lane between \p MinLane
406 /// and \p MaxLane, times each part between \p MinPart and \p MaxPart,
407 /// inclusive..
408 void scalarizeInstruction(Instruction *Instr, const VPIteration &Instance,
409 bool IfPredicateInstr);
410
411 /// Widen an integer or floating-point induction variable \p IV. If \p Trunc
412 /// is provided, the integer induction variable will first be truncated to
413 /// the corresponding type.
414 void widenIntOrFpInduction(PHINode *IV, TruncInst *Trunc = nullptr);
415
416 /// getOrCreateVectorValue and getOrCreateScalarValue coordinate to generate a
417 /// vector or scalar value on-demand if one is not yet available. When
418 /// vectorizing a loop, we visit the definition of an instruction before its
419 /// uses. When visiting the definition, we either vectorize or scalarize the
420 /// instruction, creating an entry for it in the corresponding map. (In some
421 /// cases, such as induction variables, we will create both vector and scalar
422 /// entries.) Then, as we encounter uses of the definition, we derive values
423 /// for each scalar or vector use unless such a value is already available.
424 /// For example, if we scalarize a definition and one of its uses is vector,
425 /// we build the required vector on-demand with an insertelement sequence
426 /// when visiting the use. Otherwise, if the use is scalar, we can use the
427 /// existing scalar definition.
428 ///
429 /// Return a value in the new loop corresponding to \p V from the original
430 /// loop at unroll index \p Part. If the value has already been vectorized,
431 /// the corresponding vector entry in VectorLoopValueMap is returned. If,
432 /// however, the value has a scalar entry in VectorLoopValueMap, we construct
433 /// a new vector value on-demand by inserting the scalar values into a vector
434 /// with an insertelement sequence. If the value has been neither vectorized
435 /// nor scalarized, it must be loop invariant, so we simply broadcast the
436 /// value into a vector.
437 Value *getOrCreateVectorValue(Value *V, unsigned Part);
438
439 /// Return a value in the new loop corresponding to \p V from the original
440 /// loop at unroll and vector indices \p Instance. If the value has been
441 /// vectorized but not scalarized, the necessary extractelement instruction
442 /// will be generated.
443 Value *getOrCreateScalarValue(Value *V, const VPIteration &Instance);
444
445 /// Construct the vector value of a scalarized value \p V one lane at a time.
446 void packScalarIntoVectorValue(Value *V, const VPIteration &Instance);
447
448 /// Try to vectorize the interleaved access group that \p Instr belongs to,
449 /// optionally masking the vector operations if \p BlockInMask is non-null.
450 void vectorizeInterleaveGroup(Instruction *Instr,
451 VectorParts *BlockInMask = nullptr);
452
453 /// Vectorize Load and Store instructions, optionally masking the vector
454 /// operations if \p BlockInMask is non-null.
455 void vectorizeMemoryInstruction(Instruction *Instr,
456 VectorParts *BlockInMask = nullptr);
457
458 /// Set the debug location in the builder using the debug location in
459 /// the instruction.
460 void setDebugLocFromInst(IRBuilder<> &B, const Value *Ptr);
461
462 /// Fix the non-induction PHIs in the OrigPHIsToFix vector.
463 void fixNonInductionPHIs(void);
464
465protected:
466 friend class LoopVectorizationPlanner;
467
468 /// A small list of PHINodes.
469 using PhiVector = SmallVector<PHINode *, 4>;
470
471 /// A type for scalarized values in the new loop. Each value from the
472 /// original loop, when scalarized, is represented by UF x VF scalar values
473 /// in the new unrolled loop, where UF is the unroll factor and VF is the
474 /// vectorization factor.
475 using ScalarParts = SmallVector<SmallVector<Value *, 4>, 2>;
476
477 /// Set up the values of the IVs correctly when exiting the vector loop.
478 void fixupIVUsers(PHINode *OrigPhi, const InductionDescriptor &II,
479 Value *CountRoundDown, Value *EndValue,
480 BasicBlock *MiddleBlock);
481
482 /// Create a new induction variable inside L.
483 PHINode *createInductionVariable(Loop *L, Value *Start, Value *End,
484 Value *Step, Instruction *DL);
485
486 /// Handle all cross-iteration phis in the header.
487 void fixCrossIterationPHIs();
488
489 /// Fix a first-order recurrence. This is the second phase of vectorizing
490 /// this phi node.
491 void fixFirstOrderRecurrence(PHINode *Phi);
492
493 /// Fix a reduction cross-iteration phi. This is the second phase of
494 /// vectorizing this phi node.
495 void fixReduction(PHINode *Phi);
496
497 /// The Loop exit block may have single value PHI nodes with some
498 /// incoming value. While vectorizing we only handled real values
499 /// that were defined inside the loop and we should have one value for
500 /// each predecessor of its parent basic block. See PR14725.
501 void fixLCSSAPHIs();
502
503 /// Iteratively sink the scalarized operands of a predicated instruction into
504 /// the block that was created for it.
505 void sinkScalarOperands(Instruction *PredInst);
506
507 /// Shrinks vector element sizes to the smallest bitwidth they can be legally
508 /// represented as.
509 void truncateToMinimalBitwidths();
510
511 /// Insert the new loop to the loop hierarchy and pass manager
512 /// and update the analysis passes.
513 void updateAnalysis();
514
515 /// Create a broadcast instruction. This method generates a broadcast
516 /// instruction (shuffle) for loop invariant values and for the induction
517 /// value. If this is the induction variable then we extend it to N, N+1, ...
518 /// this is needed because each iteration in the loop corresponds to a SIMD
519 /// element.
520 virtual Value *getBroadcastInstrs(Value *V);
521
522 /// This function adds (StartIdx, StartIdx + Step, StartIdx + 2*Step, ...)
523 /// to each vector element of Val. The sequence starts at StartIndex.
524 /// \p Opcode is relevant for FP induction variable.
525 virtual Value *getStepVector(Value *Val, int StartIdx, Value *Step,
526 Instruction::BinaryOps Opcode =
527 Instruction::BinaryOpsEnd);
528
529 /// Compute scalar induction steps. \p ScalarIV is the scalar induction
530 /// variable on which to base the steps, \p Step is the size of the step, and
531 /// \p EntryVal is the value from the original loop that maps to the steps.
532 /// Note that \p EntryVal doesn't have to be an induction variable - it
533 /// can also be a truncate instruction.
534 void buildScalarSteps(Value *ScalarIV, Value *Step, Instruction *EntryVal,
535 const InductionDescriptor &ID);
536
537 /// Create a vector induction phi node based on an existing scalar one. \p
538 /// EntryVal is the value from the original loop that maps to the vector phi
539 /// node, and \p Step is the loop-invariant step. If \p EntryVal is a
540 /// truncate instruction, instead of widening the original IV, we widen a
541 /// version of the IV truncated to \p EntryVal's type.
542 void createVectorIntOrFpInductionPHI(const InductionDescriptor &II,
543 Value *Step, Instruction *EntryVal);
544
545 /// Returns true if an instruction \p I should be scalarized instead of
546 /// vectorized for the chosen vectorization factor.
547 bool shouldScalarizeInstruction(Instruction *I) const;
548
549 /// Returns true if we should generate a scalar version of \p IV.
550 bool needsScalarInduction(Instruction *IV) const;
551
552 /// If there is a cast involved in the induction variable \p ID, which should
553 /// be ignored in the vectorized loop body, this function records the
554 /// VectorLoopValue of the respective Phi also as the VectorLoopValue of the
555 /// cast. We had already proved that the casted Phi is equal to the uncasted
556 /// Phi in the vectorized loop (under a runtime guard), and therefore
557 /// there is no need to vectorize the cast - the same value can be used in the
558 /// vector loop for both the Phi and the cast.
559 /// If \p VectorLoopValue is a scalarized value, \p Lane is also specified,
560 /// Otherwise, \p VectorLoopValue is a widened/vectorized value.
561 ///
562 /// \p EntryVal is the value from the original loop that maps to the vector
563 /// phi node and is used to distinguish what is the IV currently being
564 /// processed - original one (if \p EntryVal is a phi corresponding to the
565 /// original IV) or the "newly-created" one based on the proof mentioned above
566 /// (see also buildScalarSteps() and createVectorIntOrFPInductionPHI()). In the
567 /// latter case \p EntryVal is a TruncInst and we must not record anything for
568 /// that IV, but it's error-prone to expect callers of this routine to care
569 /// about that, hence this explicit parameter.
570 void recordVectorLoopValueForInductionCast(const InductionDescriptor &ID,
571 const Instruction *EntryVal,
572 Value *VectorLoopValue,
573 unsigned Part,
574 unsigned Lane = UINT_MAX(2147483647 *2U +1U));
575
576 /// Generate a shuffle sequence that will reverse the vector Vec.
577 virtual Value *reverseVector(Value *Vec);
578
579 /// Returns (and creates if needed) the original loop trip count.
580 Value *getOrCreateTripCount(Loop *NewLoop);
581
582 /// Returns (and creates if needed) the trip count of the widened loop.
583 Value *getOrCreateVectorTripCount(Loop *NewLoop);
584
585 /// Returns a bitcasted value to the requested vector type.
586 /// Also handles bitcasts of vector<float> <-> vector<pointer> types.
587 Value *createBitOrPointerCast(Value *V, VectorType *DstVTy,
588 const DataLayout &DL);
589
590 /// Emit a bypass check to see if the vector trip count is zero, including if
591 /// it overflows.
592 void emitMinimumIterationCountCheck(Loop *L, BasicBlock *Bypass);
593
594 /// Emit a bypass check to see if all of the SCEV assumptions we've
595 /// had to make are correct.
596 void emitSCEVChecks(Loop *L, BasicBlock *Bypass);
597
598 /// Emit bypass checks to check any memory assumptions we may have made.
599 void emitMemRuntimeChecks(Loop *L, BasicBlock *Bypass);
600
601 /// Compute the transformed value of Index at offset StartValue using step
602 /// StepValue.
603 /// For integer induction, returns StartValue + Index * StepValue.
604 /// For pointer induction, returns StartValue[Index * StepValue].
605 /// FIXME: The newly created binary instructions should contain nsw/nuw
606 /// flags, which can be found from the original scalar operations.
607 Value *emitTransformedIndex(IRBuilder<> &B, Value *Index, ScalarEvolution *SE,
608 const DataLayout &DL,
609 const InductionDescriptor &ID) const;
610
611 /// Add additional metadata to \p To that was not present on \p Orig.
612 ///
613 /// Currently this is used to add the noalias annotations based on the
614 /// inserted memchecks. Use this for instructions that are *cloned* into the
615 /// vector loop.
616 void addNewMetadata(Instruction *To, const Instruction *Orig);
617
618 /// Add metadata from one instruction to another.
619 ///
620 /// This includes both the original MDs from \p From and additional ones (\see
621 /// addNewMetadata). Use this for *newly created* instructions in the vector
622 /// loop.
623 void addMetadata(Instruction *To, Instruction *From);
624
625 /// Similar to the previous function but it adds the metadata to a
626 /// vector of instructions.
627 void addMetadata(ArrayRef<Value *> To, Instruction *From);
628
629 /// The original loop.
630 Loop *OrigLoop;
631
632 /// A wrapper around ScalarEvolution used to add runtime SCEV checks. Applies
633 /// dynamic knowledge to simplify SCEV expressions and converts them to a
634 /// more usable form.
635 PredicatedScalarEvolution &PSE;
636
637 /// Loop Info.
638 LoopInfo *LI;
639
640 /// Dominator Tree.
641 DominatorTree *DT;
642
643 /// Alias Analysis.
644 AliasAnalysis *AA;
645
646 /// Target Library Info.
647 const TargetLibraryInfo *TLI;
648
649 /// Target Transform Info.
650 const TargetTransformInfo *TTI;
651
652 /// Assumption Cache.
653 AssumptionCache *AC;
654
655 /// Interface to emit optimization remarks.
656 OptimizationRemarkEmitter *ORE;
657
658 /// LoopVersioning. It's only set up (non-null) if memchecks were
659 /// used.
660 ///
661 /// This is currently only used to add no-alias metadata based on the
662 /// memchecks. The actually versioning is performed manually.
663 std::unique_ptr<LoopVersioning> LVer;
664
665 /// The vectorization SIMD factor to use. Each vector will have this many
666 /// vector elements.
667 unsigned VF;
668
669 /// The vectorization unroll factor to use. Each scalar is vectorized to this
670 /// many different vector instructions.
671 unsigned UF;
672
673 /// The builder that we use
674 IRBuilder<> Builder;
675
676 // --- Vectorization state ---
677
678 /// The vector-loop preheader.
679 BasicBlock *LoopVectorPreHeader;
680
681 /// The scalar-loop preheader.
682 BasicBlock *LoopScalarPreHeader;
683
684 /// Middle Block between the vector and the scalar.
685 BasicBlock *LoopMiddleBlock;
686
687 /// The ExitBlock of the scalar loop.
688 BasicBlock *LoopExitBlock;
689
690 /// The vector loop body.
691 BasicBlock *LoopVectorBody;
692
693 /// The scalar loop body.
694 BasicBlock *LoopScalarBody;
695
696 /// A list of all bypass blocks. The first block is the entry of the loop.
697 SmallVector<BasicBlock *, 4> LoopBypassBlocks;
698
699 /// The new Induction variable which was added to the new block.
700 PHINode *Induction = nullptr;
701
702 /// The induction variable of the old basic block.
703 PHINode *OldInduction = nullptr;
704
705 /// Maps values from the original loop to their corresponding values in the
706 /// vectorized loop. A key value can map to either vector values, scalar
707 /// values or both kinds of values, depending on whether the key was
708 /// vectorized and scalarized.
709 VectorizerValueMap VectorLoopValueMap;
710
711 /// Store instructions that were predicated.
712 SmallVector<Instruction *, 4> PredicatedInstructions;
713
714 /// Trip count of the original loop.
715 Value *TripCount = nullptr;
716
717 /// Trip count of the widened loop (TripCount - TripCount % (VF*UF))
718 Value *VectorTripCount = nullptr;
719
720 /// The legality analysis.
721 LoopVectorizationLegality *Legal;
722
723 /// The profitablity analysis.
724 LoopVectorizationCostModel *Cost;
725
726 // Record whether runtime checks are added.
727 bool AddedSafetyChecks = false;
728
729 // Holds the end values for each induction variable. We save the end values
730 // so we can later fix-up the external users of the induction variables.
731 DenseMap<PHINode *, Value *> IVEndValues;
732
733 // Vector of original scalar PHIs whose corresponding widened PHIs need to be
734 // fixed up at the end of vector code generation.
735 SmallVector<PHINode *, 8> OrigPHIsToFix;
736};
737
738class InnerLoopUnroller : public InnerLoopVectorizer {
739public:
740 InnerLoopUnroller(Loop *OrigLoop, PredicatedScalarEvolution &PSE,
741 LoopInfo *LI, DominatorTree *DT,
742 const TargetLibraryInfo *TLI,
743 const TargetTransformInfo *TTI, AssumptionCache *AC,
744 OptimizationRemarkEmitter *ORE, unsigned UnrollFactor,
745 LoopVectorizationLegality *LVL,
746 LoopVectorizationCostModel *CM)
747 : InnerLoopVectorizer(OrigLoop, PSE, LI, DT, TLI, TTI, AC, ORE, 1,
748 UnrollFactor, LVL, CM) {}
749
750private:
751 Value *getBroadcastInstrs(Value *V) override;
752 Value *getStepVector(Value *Val, int StartIdx, Value *Step,
753 Instruction::BinaryOps Opcode =
754 Instruction::BinaryOpsEnd) override;
755 Value *reverseVector(Value *Vec) override;
756};
757
758} // end namespace llvm
759
760/// Look for a meaningful debug location on the instruction or it's
761/// operands.
762static Instruction *getDebugLocFromInstOrOperands(Instruction *I) {
763 if (!I)
764 return I;
765
766 DebugLoc Empty;
767 if (I->getDebugLoc() != Empty)
768 return I;
769
770 for (User::op_iterator OI = I->op_begin(), OE = I->op_end(); OI != OE; ++OI) {
771 if (Instruction *OpInst = dyn_cast<Instruction>(*OI))
772 if (OpInst->getDebugLoc() != Empty)
773 return OpInst;
774 }
775
776 return I;
777}
778
779void InnerLoopVectorizer::setDebugLocFromInst(IRBuilder<> &B, const Value *Ptr) {
780 if (const Instruction *Inst = dyn_cast_or_null<Instruction>(Ptr)) {
781 const DILocation *DIL = Inst->getDebugLoc();
782 if (DIL && Inst->getFunction()->isDebugInfoForProfiling() &&
783 !isa<DbgInfoIntrinsic>(Inst)) {
784 auto NewDIL = DIL->cloneByMultiplyingDuplicationFactor(UF * VF);
785 if (NewDIL)
786 B.SetCurrentDebugLocation(NewDIL.getValue());
787 else
788 LLVM_DEBUG(dbgs()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("loop-vectorize")) { dbgs() << "Failed to create new discriminator: "
<< DIL->getFilename() << " Line: " << DIL
->getLine(); } } while (false)
789 << "Failed to create new discriminator: "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("loop-vectorize")) { dbgs() << "Failed to create new discriminator: "
<< DIL->getFilename() << " Line: " << DIL
->getLine(); } } while (false)
790 << DIL->getFilename() << " Line: " << DIL->getLine())do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("loop-vectorize")) { dbgs() << "Failed to create new discriminator: "
<< DIL->getFilename() << " Line: " << DIL
->getLine(); } } while (false)
;
791 }
792 else
793 B.SetCurrentDebugLocation(DIL);
794 } else
795 B.SetCurrentDebugLocation(DebugLoc());
796}
797
798#ifndef NDEBUG
799/// \return string containing a file name and a line # for the given loop.
800static std::string getDebugLocString(const Loop *L) {
801 std::string Result;
802 if (L) {
803 raw_string_ostream OS(Result);
804 if (const DebugLoc LoopDbgLoc = L->getStartLoc())
805 LoopDbgLoc.print(OS);
806 else
807 // Just print the module name.
808 OS << L->getHeader()->getParent()->getParent()->getModuleIdentifier();
809 OS.flush();
810 }
811 return Result;
812}
813#endif
814
815void InnerLoopVectorizer::addNewMetadata(Instruction *To,
816 const Instruction *Orig) {
817 // If the loop was versioned with memchecks, add the corresponding no-alias
818 // metadata.
819 if (LVer && (isa<LoadInst>(Orig) || isa<StoreInst>(Orig)))
820 LVer->annotateInstWithNoAlias(To, Orig);
821}
822
823void InnerLoopVectorizer::addMetadata(Instruction *To,
824 Instruction *From) {
825 propagateMetadata(To, From);
826 addNewMetadata(To, From);
827}
828
829void InnerLoopVectorizer::addMetadata(ArrayRef<Value *> To,
830 Instruction *From) {
831 for (Value *V : To) {
832 if (Instruction *I = dyn_cast<Instruction>(V))
833 addMetadata(I, From);
834 }
835}
836
837namespace llvm {
838
839/// LoopVectorizationCostModel - estimates the expected speedups due to
840/// vectorization.
841/// In many cases vectorization is not profitable. This can happen because of
842/// a number of reasons. In this class we mainly attempt to predict the
843/// expected speedup/slowdowns due to the supported instruction set. We use the
844/// TargetTransformInfo to query the different backends for the cost of
845/// different operations.
846class LoopVectorizationCostModel {
847public:
848 LoopVectorizationCostModel(Loop *L, PredicatedScalarEvolution &PSE,
849 LoopInfo *LI, LoopVectorizationLegality *Legal,
850 const TargetTransformInfo &TTI,
851 const TargetLibraryInfo *TLI, DemandedBits *DB,
852 AssumptionCache *AC,
853 OptimizationRemarkEmitter *ORE, const Function *F,
854 const LoopVectorizeHints *Hints,
855 InterleavedAccessInfo &IAI)
856 : TheLoop(L), PSE(PSE), LI(LI), Legal(Legal), TTI(TTI), TLI(TLI), DB(DB),
857 AC(AC), ORE(ORE), TheFunction(F), Hints(Hints), InterleaveInfo(IAI) {}
858
859 /// \return An upper bound for the vectorization factor, or None if
860 /// vectorization and interleaving should be avoided up front.
861 Optional<unsigned> computeMaxVF(bool OptForSize);
862
863 /// \return The most profitable vectorization factor and the cost of that VF.
864 /// This method checks every power of two up to MaxVF. If UserVF is not ZERO
865 /// then this vectorization factor will be selected if vectorization is
866 /// possible.
867 VectorizationFactor selectVectorizationFactor(unsigned MaxVF);
868
869 /// Setup cost-based decisions for user vectorization factor.
870 void selectUserVectorizationFactor(unsigned UserVF) {
871 collectUniformsAndScalars(UserVF);
872 collectInstsToScalarize(UserVF);
873 }
874
875 /// \return The size (in bits) of the smallest and widest types in the code
876 /// that needs to be vectorized. We ignore values that remain scalar such as
877 /// 64 bit loop indices.
878 std::pair<unsigned, unsigned> getSmallestAndWidestTypes();
879
880 /// \return The desired interleave count.
881 /// If interleave count has been specified by metadata it will be returned.
882 /// Otherwise, the interleave count is computed and returned. VF and LoopCost
883 /// are the selected vectorization factor and the cost of the selected VF.
884 unsigned selectInterleaveCount(bool OptForSize, unsigned VF,
885 unsigned LoopCost);
886
887 /// Memory access instruction may be vectorized in more than one way.
888 /// Form of instruction after vectorization depends on cost.
889 /// This function takes cost-based decisions for Load/Store instructions
890 /// and collects them in a map. This decisions map is used for building
891 /// the lists of loop-uniform and loop-scalar instructions.
892 /// The calculated cost is saved with widening decision in order to
893 /// avoid redundant calculations.
894 void setCostBasedWideningDecision(unsigned VF);
895
896 /// A struct that represents some properties of the register usage
897 /// of a loop.
898 struct RegisterUsage {
899 /// Holds the number of loop invariant values that are used in the loop.
900 unsigned LoopInvariantRegs;
901
902 /// Holds the maximum number of concurrent live intervals in the loop.
903 unsigned MaxLocalUsers;
904 };
905
906 /// \return Returns information about the register usages of the loop for the
907 /// given vectorization factors.
908 SmallVector<RegisterUsage, 8> calculateRegisterUsage(ArrayRef<unsigned> VFs);
909
910 /// Collect values we want to ignore in the cost model.
911 void collectValuesToIgnore();
912
913 /// \returns The smallest bitwidth each instruction can be represented with.
914 /// The vector equivalents of these instructions should be truncated to this
915 /// type.
916 const MapVector<Instruction *, uint64_t> &getMinimalBitwidths() const {
917 return MinBWs;
918 }
919
920 /// \returns True if it is more profitable to scalarize instruction \p I for
921 /// vectorization factor \p VF.
922 bool isProfitableToScalarize(Instruction *I, unsigned VF) const {
923 assert(VF > 1 && "Profitable to scalarize relevant only for VF > 1.")((VF > 1 && "Profitable to scalarize relevant only for VF > 1."
) ? static_cast<void> (0) : __assert_fail ("VF > 1 && \"Profitable to scalarize relevant only for VF > 1.\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 923, __PRETTY_FUNCTION__))
;
924
925 // Cost model is not run in the VPlan-native path - return conservative
926 // result until this changes.
927 if (EnableVPlanNativePath)
928 return false;
929
930 auto Scalars = InstsToScalarize.find(VF);
931 assert(Scalars != InstsToScalarize.end() &&((Scalars != InstsToScalarize.end() && "VF not yet analyzed for scalarization profitability"
) ? static_cast<void> (0) : __assert_fail ("Scalars != InstsToScalarize.end() && \"VF not yet analyzed for scalarization profitability\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 932, __PRETTY_FUNCTION__))
932 "VF not yet analyzed for scalarization profitability")((Scalars != InstsToScalarize.end() && "VF not yet analyzed for scalarization profitability"
) ? static_cast<void> (0) : __assert_fail ("Scalars != InstsToScalarize.end() && \"VF not yet analyzed for scalarization profitability\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 932, __PRETTY_FUNCTION__))
;
933 return Scalars->second.find(I) != Scalars->second.end();
934 }
935
936 /// Returns true if \p I is known to be uniform after vectorization.
937 bool isUniformAfterVectorization(Instruction *I, unsigned VF) const {
938 if (VF == 1)
939 return true;
940
941 // Cost model is not run in the VPlan-native path - return conservative
942 // result until this changes.
943 if (EnableVPlanNativePath)
944 return false;
945
946 auto UniformsPerVF = Uniforms.find(VF);
947 assert(UniformsPerVF != Uniforms.end() &&((UniformsPerVF != Uniforms.end() && "VF not yet analyzed for uniformity"
) ? static_cast<void> (0) : __assert_fail ("UniformsPerVF != Uniforms.end() && \"VF not yet analyzed for uniformity\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 948, __PRETTY_FUNCTION__))
948 "VF not yet analyzed for uniformity")((UniformsPerVF != Uniforms.end() && "VF not yet analyzed for uniformity"
) ? static_cast<void> (0) : __assert_fail ("UniformsPerVF != Uniforms.end() && \"VF not yet analyzed for uniformity\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 948, __PRETTY_FUNCTION__))
;
949 return UniformsPerVF->second.find(I) != UniformsPerVF->second.end();
950 }
951
952 /// Returns true if \p I is known to be scalar after vectorization.
953 bool isScalarAfterVectorization(Instruction *I, unsigned VF) const {
954 if (VF == 1)
955 return true;
956
957 // Cost model is not run in the VPlan-native path - return conservative
958 // result until this changes.
959 if (EnableVPlanNativePath)
960 return false;
961
962 auto ScalarsPerVF = Scalars.find(VF);
963 assert(ScalarsPerVF != Scalars.end() &&((ScalarsPerVF != Scalars.end() && "Scalar values are not calculated for VF"
) ? static_cast<void> (0) : __assert_fail ("ScalarsPerVF != Scalars.end() && \"Scalar values are not calculated for VF\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 964, __PRETTY_FUNCTION__))
964 "Scalar values are not calculated for VF")((ScalarsPerVF != Scalars.end() && "Scalar values are not calculated for VF"
) ? static_cast<void> (0) : __assert_fail ("ScalarsPerVF != Scalars.end() && \"Scalar values are not calculated for VF\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 964, __PRETTY_FUNCTION__))
;
965 return ScalarsPerVF->second.find(I) != ScalarsPerVF->second.end();
966 }
967
968 /// \returns True if instruction \p I can be truncated to a smaller bitwidth
969 /// for vectorization factor \p VF.
970 bool canTruncateToMinimalBitwidth(Instruction *I, unsigned VF) const {
971 return VF > 1 && MinBWs.find(I) != MinBWs.end() &&
972 !isProfitableToScalarize(I, VF) &&
973 !isScalarAfterVectorization(I, VF);
974 }
975
976 /// Decision that was taken during cost calculation for memory instruction.
977 enum InstWidening {
978 CM_Unknown,
979 CM_Widen, // For consecutive accesses with stride +1.
980 CM_Widen_Reverse, // For consecutive accesses with stride -1.
981 CM_Interleave,
982 CM_GatherScatter,
983 CM_Scalarize
984 };
985
986 /// Save vectorization decision \p W and \p Cost taken by the cost model for
987 /// instruction \p I and vector width \p VF.
988 void setWideningDecision(Instruction *I, unsigned VF, InstWidening W,
989 unsigned Cost) {
990 assert(VF >= 2 && "Expected VF >=2")((VF >= 2 && "Expected VF >=2") ? static_cast<
void> (0) : __assert_fail ("VF >= 2 && \"Expected VF >=2\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 990, __PRETTY_FUNCTION__))
;
991 WideningDecisions[std::make_pair(I, VF)] = std::make_pair(W, Cost);
992 }
993
994 /// Save vectorization decision \p W and \p Cost taken by the cost model for
995 /// interleaving group \p Grp and vector width \p VF.
996 void setWideningDecision(const InterleaveGroup<Instruction> *Grp, unsigned VF,
997 InstWidening W, unsigned Cost) {
998 assert(VF >= 2 && "Expected VF >=2")((VF >= 2 && "Expected VF >=2") ? static_cast<
void> (0) : __assert_fail ("VF >= 2 && \"Expected VF >=2\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 998, __PRETTY_FUNCTION__))
;
999 /// Broadcast this decicion to all instructions inside the group.
1000 /// But the cost will be assigned to one instruction only.
1001 for (unsigned i = 0; i < Grp->getFactor(); ++i) {
1002 if (auto *I = Grp->getMember(i)) {
1003 if (Grp->getInsertPos() == I)
1004 WideningDecisions[std::make_pair(I, VF)] = std::make_pair(W, Cost);
1005 else
1006 WideningDecisions[std::make_pair(I, VF)] = std::make_pair(W, 0);
1007 }
1008 }
1009 }
1010
1011 /// Return the cost model decision for the given instruction \p I and vector
1012 /// width \p VF. Return CM_Unknown if this instruction did not pass
1013 /// through the cost modeling.
1014 InstWidening getWideningDecision(Instruction *I, unsigned VF) {
1015 assert(VF >= 2 && "Expected VF >=2")((VF >= 2 && "Expected VF >=2") ? static_cast<
void> (0) : __assert_fail ("VF >= 2 && \"Expected VF >=2\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 1015, __PRETTY_FUNCTION__))
;
1016
1017 // Cost model is not run in the VPlan-native path - return conservative
1018 // result until this changes.
1019 if (EnableVPlanNativePath)
1020 return CM_GatherScatter;
1021
1022 std::pair<Instruction *, unsigned> InstOnVF = std::make_pair(I, VF);
1023 auto Itr = WideningDecisions.find(InstOnVF);
1024 if (Itr == WideningDecisions.end())
1025 return CM_Unknown;
1026 return Itr->second.first;
1027 }
1028
1029 /// Return the vectorization cost for the given instruction \p I and vector
1030 /// width \p VF.
1031 unsigned getWideningCost(Instruction *I, unsigned VF) {
1032 assert(VF >= 2 && "Expected VF >=2")((VF >= 2 && "Expected VF >=2") ? static_cast<
void> (0) : __assert_fail ("VF >= 2 && \"Expected VF >=2\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 1032, __PRETTY_FUNCTION__))
;
1033 std::pair<Instruction *, unsigned> InstOnVF = std::make_pair(I, VF);
1034 assert(WideningDecisions.find(InstOnVF) != WideningDecisions.end() &&((WideningDecisions.find(InstOnVF) != WideningDecisions.end()
&& "The cost is not calculated") ? static_cast<void
> (0) : __assert_fail ("WideningDecisions.find(InstOnVF) != WideningDecisions.end() && \"The cost is not calculated\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 1035, __PRETTY_FUNCTION__))
1035 "The cost is not calculated")((WideningDecisions.find(InstOnVF) != WideningDecisions.end()
&& "The cost is not calculated") ? static_cast<void
> (0) : __assert_fail ("WideningDecisions.find(InstOnVF) != WideningDecisions.end() && \"The cost is not calculated\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 1035, __PRETTY_FUNCTION__))
;
1036 return WideningDecisions[InstOnVF].second;
1037 }
1038
1039 /// Return True if instruction \p I is an optimizable truncate whose operand
1040 /// is an induction variable. Such a truncate will be removed by adding a new
1041 /// induction variable with the destination type.
1042 bool isOptimizableIVTruncate(Instruction *I, unsigned VF) {
1043 // If the instruction is not a truncate, return false.
1044 auto *Trunc = dyn_cast<TruncInst>(I);
1045 if (!Trunc)
1046 return false;
1047
1048 // Get the source and destination types of the truncate.
1049 Type *SrcTy = ToVectorTy(cast<CastInst>(I)->getSrcTy(), VF);
1050 Type *DestTy = ToVectorTy(cast<CastInst>(I)->getDestTy(), VF);
1051
1052 // If the truncate is free for the given types, return false. Replacing a
1053 // free truncate with an induction variable would add an induction variable
1054 // update instruction to each iteration of the loop. We exclude from this
1055 // check the primary induction variable since it will need an update
1056 // instruction regardless.
1057 Value *Op = Trunc->getOperand(0);
1058 if (Op != Legal->getPrimaryInduction() && TTI.isTruncateFree(SrcTy, DestTy))
1059 return false;
1060
1061 // If the truncated value is not an induction variable, return false.
1062 return Legal->isInductionPhi(Op);
1063 }
1064
1065 /// Collects the instructions to scalarize for each predicated instruction in
1066 /// the loop.
1067 void collectInstsToScalarize(unsigned VF);
1068
1069 /// Collect Uniform and Scalar values for the given \p VF.
1070 /// The sets depend on CM decision for Load/Store instructions
1071 /// that may be vectorized as interleave, gather-scatter or scalarized.
1072 void collectUniformsAndScalars(unsigned VF) {
1073 // Do the analysis once.
1074 if (VF == 1 || Uniforms.find(VF) != Uniforms.end())
1075 return;
1076 setCostBasedWideningDecision(VF);
1077 collectLoopUniforms(VF);
1078 collectLoopScalars(VF);
1079 }
1080
1081 /// Returns true if the target machine supports masked store operation
1082 /// for the given \p DataType and kind of access to \p Ptr.
1083 bool isLegalMaskedStore(Type *DataType, Value *Ptr) {
1084 return Legal->isConsecutivePtr(Ptr) && TTI.isLegalMaskedStore(DataType);
1085 }
1086
1087 /// Returns true if the target machine supports masked load operation
1088 /// for the given \p DataType and kind of access to \p Ptr.
1089 bool isLegalMaskedLoad(Type *DataType, Value *Ptr) {
1090 return Legal->isConsecutivePtr(Ptr) && TTI.isLegalMaskedLoad(DataType);
1091 }
1092
1093 /// Returns true if the target machine supports masked scatter operation
1094 /// for the given \p DataType.
1095 bool isLegalMaskedScatter(Type *DataType) {
1096 return TTI.isLegalMaskedScatter(DataType);
1097 }
1098
1099 /// Returns true if the target machine supports masked gather operation
1100 /// for the given \p DataType.
1101 bool isLegalMaskedGather(Type *DataType) {
1102 return TTI.isLegalMaskedGather(DataType);
1103 }
1104
1105 /// Returns true if the target machine can represent \p V as a masked gather
1106 /// or scatter operation.
1107 bool isLegalGatherOrScatter(Value *V) {
1108 bool LI = isa<LoadInst>(V);
1109 bool SI = isa<StoreInst>(V);
1110 if (!LI && !SI)
1111 return false;
1112 auto *Ty = getMemInstValueType(V);
1113 return (LI && isLegalMaskedGather(Ty)) || (SI && isLegalMaskedScatter(Ty));
1114 }
1115
1116 /// Returns true if \p I is an instruction that will be scalarized with
1117 /// predication. Such instructions include conditional stores and
1118 /// instructions that may divide by zero.
1119 /// If a non-zero VF has been calculated, we check if I will be scalarized
1120 /// predication for that VF.
1121 bool isScalarWithPredication(Instruction *I, unsigned VF = 1);
1122
1123 // Returns true if \p I is an instruction that will be predicated either
1124 // through scalar predication or masked load/store or masked gather/scatter.
1125 // Superset of instructions that return true for isScalarWithPredication.
1126 bool isPredicatedInst(Instruction *I) {
1127 if (!blockNeedsPredication(I->getParent()))
1128 return false;
1129 // Loads and stores that need some form of masked operation are predicated
1130 // instructions.
1131 if (isa<LoadInst>(I) || isa<StoreInst>(I))
1132 return Legal->isMaskRequired(I);
1133 return isScalarWithPredication(I);
1134 }
1135
1136 /// Returns true if \p I is a memory instruction with consecutive memory
1137 /// access that can be widened.
1138 bool memoryInstructionCanBeWidened(Instruction *I, unsigned VF = 1);
1139
1140 /// Returns true if \p I is a memory instruction in an interleaved-group
1141 /// of memory accesses that can be vectorized with wide vector loads/stores
1142 /// and shuffles.
1143 bool interleavedAccessCanBeWidened(Instruction *I, unsigned VF = 1);
1144
1145 /// Check if \p Instr belongs to any interleaved access group.
1146 bool isAccessInterleaved(Instruction *Instr) {
1147 return InterleaveInfo.isInterleaved(Instr);
1148 }
1149
1150 /// Get the interleaved access group that \p Instr belongs to.
1151 const InterleaveGroup<Instruction> *
1152 getInterleavedAccessGroup(Instruction *Instr) {
1153 return InterleaveInfo.getInterleaveGroup(Instr);
1154 }
1155
1156 /// Returns true if an interleaved group requires a scalar iteration
1157 /// to handle accesses with gaps, and there is nothing preventing us from
1158 /// creating a scalar epilogue.
1159 bool requiresScalarEpilogue() const {
1160 return IsScalarEpilogueAllowed && InterleaveInfo.requiresScalarEpilogue();
1161 }
1162
1163 /// Returns true if a scalar epilogue is not allowed due to optsize.
1164 bool isScalarEpilogueAllowed() const { return IsScalarEpilogueAllowed; }
1165
1166 /// Returns true if all loop blocks should be masked to fold tail loop.
1167 bool foldTailByMasking() const { return FoldTailByMasking; }
1168
1169 bool blockNeedsPredication(BasicBlock *BB) {
1170 return foldTailByMasking() || Legal->blockNeedsPredication(BB);
1171 }
1172
1173 /// Estimate cost of an intrinsic call instruction CI if it were vectorized
1174 /// with factor VF. Return the cost of the instruction, including
1175 /// scalarization overhead if it's needed.
1176 unsigned getVectorIntrinsicCost(CallInst *CI, unsigned VF);
1177
1178 /// Estimate cost of a call instruction CI if it were vectorized with factor
1179 /// VF. Return the cost of the instruction, including scalarization overhead
1180 /// if it's needed. The flag NeedToScalarize shows if the call needs to be
1181 /// scalarized -
1182 // i.e. either vector version isn't available, or is too expensive.
1183 unsigned getVectorCallCost(CallInst *CI, unsigned VF, bool &NeedToScalarize);
1184
1185private:
1186 unsigned NumPredStores = 0;
1187
1188 /// \return An upper bound for the vectorization factor, larger than zero.
1189 /// One is returned if vectorization should best be avoided due to cost.
1190 unsigned computeFeasibleMaxVF(bool OptForSize, unsigned ConstTripCount);
1191
1192 /// The vectorization cost is a combination of the cost itself and a boolean
1193 /// indicating whether any of the contributing operations will actually
1194 /// operate on
1195 /// vector values after type legalization in the backend. If this latter value
1196 /// is
1197 /// false, then all operations will be scalarized (i.e. no vectorization has
1198 /// actually taken place).
1199 using VectorizationCostTy = std::pair<unsigned, bool>;
1200
1201 /// Returns the expected execution cost. The unit of the cost does
1202 /// not matter because we use the 'cost' units to compare different
1203 /// vector widths. The cost that is returned is *not* normalized by
1204 /// the factor width.
1205 VectorizationCostTy expectedCost(unsigned VF);
1206
1207 /// Returns the execution time cost of an instruction for a given vector
1208 /// width. Vector width of one means scalar.
1209 VectorizationCostTy getInstructionCost(Instruction *I, unsigned VF);
1210
1211 /// The cost-computation logic from getInstructionCost which provides
1212 /// the vector type as an output parameter.
1213 unsigned getInstructionCost(Instruction *I, unsigned VF, Type *&VectorTy);
1214
1215 /// Calculate vectorization cost of memory instruction \p I.
1216 unsigned getMemoryInstructionCost(Instruction *I, unsigned VF);
1217
1218 /// The cost computation for scalarized memory instruction.
1219 unsigned getMemInstScalarizationCost(Instruction *I, unsigned VF);
1220
1221 /// The cost computation for interleaving group of memory instructions.
1222 unsigned getInterleaveGroupCost(Instruction *I, unsigned VF);
1223
1224 /// The cost computation for Gather/Scatter instruction.
1225 unsigned getGatherScatterCost(Instruction *I, unsigned VF);
1226
1227 /// The cost computation for widening instruction \p I with consecutive
1228 /// memory access.
1229 unsigned getConsecutiveMemOpCost(Instruction *I, unsigned VF);
1230
1231 /// The cost calculation for Load/Store instruction \p I with uniform pointer -
1232 /// Load: scalar load + broadcast.
1233 /// Store: scalar store + (loop invariant value stored? 0 : extract of last
1234 /// element)
1235 unsigned getUniformMemOpCost(Instruction *I, unsigned VF);
1236
1237 /// Estimate the overhead of scalarizing an instruction. This is a
1238 /// convenience wrapper for the type-based getScalarizationOverhead API.
1239 unsigned getScalarizationOverhead(Instruction *I, unsigned VF);
1240
1241 /// Returns whether the instruction is a load or store and will be a emitted
1242 /// as a vector operation.
1243 bool isConsecutiveLoadOrStore(Instruction *I);
1244
1245 /// Returns true if an artificially high cost for emulated masked memrefs
1246 /// should be used.
1247 bool useEmulatedMaskMemRefHack(Instruction *I);
1248
1249 /// Create an analysis remark that explains why vectorization failed
1250 ///
1251 /// \p RemarkName is the identifier for the remark. \return the remark object
1252 /// that can be streamed to.
1253 OptimizationRemarkAnalysis createMissedAnalysis(StringRef RemarkName) {
1254 return createLVMissedAnalysis(Hints->vectorizeAnalysisPassName(),
1255 RemarkName, TheLoop);
1256 }
1257
1258 /// Map of scalar integer values to the smallest bitwidth they can be legally
1259 /// represented as. The vector equivalents of these values should be truncated
1260 /// to this type.
1261 MapVector<Instruction *, uint64_t> MinBWs;
1262
1263 /// A type representing the costs for instructions if they were to be
1264 /// scalarized rather than vectorized. The entries are Instruction-Cost
1265 /// pairs.
1266 using ScalarCostsTy = DenseMap<Instruction *, unsigned>;
1267
1268 /// A set containing all BasicBlocks that are known to present after
1269 /// vectorization as a predicated block.
1270 SmallPtrSet<BasicBlock *, 4> PredicatedBBsAfterVectorization;
1271
1272 /// Records whether it is allowed to have the original scalar loop execute at
1273 /// least once. This may be needed as a fallback loop in case runtime
1274 /// aliasing/dependence checks fail, or to handle the tail/remainder
1275 /// iterations when the trip count is unknown or doesn't divide by the VF,
1276 /// or as a peel-loop to handle gaps in interleave-groups.
1277 /// Under optsize and when the trip count is very small we don't allow any
1278 /// iterations to execute in the scalar loop.
1279 bool IsScalarEpilogueAllowed = true;
1280
1281 /// All blocks of loop are to be masked to fold tail of scalar iterations.
1282 bool FoldTailByMasking = false;
1283
1284 /// A map holding scalar costs for different vectorization factors. The
1285 /// presence of a cost for an instruction in the mapping indicates that the
1286 /// instruction will be scalarized when vectorizing with the associated
1287 /// vectorization factor. The entries are VF-ScalarCostTy pairs.
1288 DenseMap<unsigned, ScalarCostsTy> InstsToScalarize;
1289
1290 /// Holds the instructions known to be uniform after vectorization.
1291 /// The data is collected per VF.
1292 DenseMap<unsigned, SmallPtrSet<Instruction *, 4>> Uniforms;
1293
1294 /// Holds the instructions known to be scalar after vectorization.
1295 /// The data is collected per VF.
1296 DenseMap<unsigned, SmallPtrSet<Instruction *, 4>> Scalars;
1297
1298 /// Holds the instructions (address computations) that are forced to be
1299 /// scalarized.
1300 DenseMap<unsigned, SmallPtrSet<Instruction *, 4>> ForcedScalars;
1301
1302 /// Returns the expected difference in cost from scalarizing the expression
1303 /// feeding a predicated instruction \p PredInst. The instructions to
1304 /// scalarize and their scalar costs are collected in \p ScalarCosts. A
1305 /// non-negative return value implies the expression will be scalarized.
1306 /// Currently, only single-use chains are considered for scalarization.
1307 int computePredInstDiscount(Instruction *PredInst, ScalarCostsTy &ScalarCosts,
1308 unsigned VF);
1309
1310 /// Collect the instructions that are uniform after vectorization. An
1311 /// instruction is uniform if we represent it with a single scalar value in
1312 /// the vectorized loop corresponding to each vector iteration. Examples of
1313 /// uniform instructions include pointer operands of consecutive or
1314 /// interleaved memory accesses. Note that although uniformity implies an
1315 /// instruction will be scalar, the reverse is not true. In general, a
1316 /// scalarized instruction will be represented by VF scalar values in the
1317 /// vectorized loop, each corresponding to an iteration of the original
1318 /// scalar loop.
1319 void collectLoopUniforms(unsigned VF);
1320
1321 /// Collect the instructions that are scalar after vectorization. An
1322 /// instruction is scalar if it is known to be uniform or will be scalarized
1323 /// during vectorization. Non-uniform scalarized instructions will be
1324 /// represented by VF values in the vectorized loop, each corresponding to an
1325 /// iteration of the original scalar loop.
1326 void collectLoopScalars(unsigned VF);
1327
1328 /// Keeps cost model vectorization decision and cost for instructions.
1329 /// Right now it is used for memory instructions only.
1330 using DecisionList = DenseMap<std::pair<Instruction *, unsigned>,
1331 std::pair<InstWidening, unsigned>>;
1332
1333 DecisionList WideningDecisions;
1334
1335public:
1336 /// The loop that we evaluate.
1337 Loop *TheLoop;
1338
1339 /// Predicated scalar evolution analysis.
1340 PredicatedScalarEvolution &PSE;
1341
1342 /// Loop Info analysis.
1343 LoopInfo *LI;
1344
1345 /// Vectorization legality.
1346 LoopVectorizationLegality *Legal;
1347
1348 /// Vector target information.
1349 const TargetTransformInfo &TTI;
1350
1351 /// Target Library Info.
1352 const TargetLibraryInfo *TLI;
1353
1354 /// Demanded bits analysis.
1355 DemandedBits *DB;
1356
1357 /// Assumption cache.
1358 AssumptionCache *AC;
1359
1360 /// Interface to emit optimization remarks.
1361 OptimizationRemarkEmitter *ORE;
1362
1363 const Function *TheFunction;
1364
1365 /// Loop Vectorize Hint.
1366 const LoopVectorizeHints *Hints;
1367
1368 /// The interleave access information contains groups of interleaved accesses
1369 /// with the same stride and close to each other.
1370 InterleavedAccessInfo &InterleaveInfo;
1371
1372 /// Values to ignore in the cost model.
1373 SmallPtrSet<const Value *, 16> ValuesToIgnore;
1374
1375 /// Values to ignore in the cost model when VF > 1.
1376 SmallPtrSet<const Value *, 16> VecValuesToIgnore;
1377};
1378
1379} // end namespace llvm
1380
1381// Return true if \p OuterLp is an outer loop annotated with hints for explicit
1382// vectorization. The loop needs to be annotated with #pragma omp simd
1383// simdlen(#) or #pragma clang vectorize(enable) vectorize_width(#). If the
1384// vector length information is not provided, vectorization is not considered
1385// explicit. Interleave hints are not allowed either. These limitations will be
1386// relaxed in the future.
1387// Please, note that we are currently forced to abuse the pragma 'clang
1388// vectorize' semantics. This pragma provides *auto-vectorization hints*
1389// (i.e., LV must check that vectorization is legal) whereas pragma 'omp simd'
1390// provides *explicit vectorization hints* (LV can bypass legal checks and
1391// assume that vectorization is legal). However, both hints are implemented
1392// using the same metadata (llvm.loop.vectorize, processed by
1393// LoopVectorizeHints). This will be fixed in the future when the native IR
1394// representation for pragma 'omp simd' is introduced.
1395static bool isExplicitVecOuterLoop(Loop *OuterLp,
1396 OptimizationRemarkEmitter *ORE) {
1397 assert(!OuterLp->empty() && "This is not an outer loop")((!OuterLp->empty() && "This is not an outer loop"
) ? static_cast<void> (0) : __assert_fail ("!OuterLp->empty() && \"This is not an outer loop\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 1397, __PRETTY_FUNCTION__))
;
1398 LoopVectorizeHints Hints(OuterLp, true /*DisableInterleaving*/, *ORE);
1399
1400 // Only outer loops with an explicit vectorization hint are supported.
1401 // Unannotated outer loops are ignored.
1402 if (Hints.getForce() == LoopVectorizeHints::FK_Undefined)
1403 return false;
1404
1405 Function *Fn = OuterLp->getHeader()->getParent();
1406 if (!Hints.allowVectorization(Fn, OuterLp,
1407 true /*VectorizeOnlyWhenForced*/)) {
1408 LLVM_DEBUG(dbgs() << "LV: Loop hints prevent outer loop vectorization.\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("loop-vectorize")) { dbgs() << "LV: Loop hints prevent outer loop vectorization.\n"
; } } while (false)
;
1409 return false;
1410 }
1411
1412 if (Hints.getInterleave() > 1) {
1413 // TODO: Interleave support is future work.
1414 LLVM_DEBUG(dbgs() << "LV: Not vectorizing: Interleave is not supported for "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("loop-vectorize")) { dbgs() << "LV: Not vectorizing: Interleave is not supported for "
"outer loops.\n"; } } while (false)
1415 "outer loops.\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("loop-vectorize")) { dbgs() << "LV: Not vectorizing: Interleave is not supported for "
"outer loops.\n"; } } while (false)
;
1416 Hints.emitRemarkWithHints();
1417 return false;
1418 }
1419
1420 return true;
1421}
1422
1423static void collectSupportedLoops(Loop &L, LoopInfo *LI,
1424 OptimizationRemarkEmitter *ORE,
1425 SmallVectorImpl<Loop *> &V) {
1426 // Collect inner loops and outer loops without irreducible control flow. For
1427 // now, only collect outer loops that have explicit vectorization hints. If we
1428 // are stress testing the VPlan H-CFG construction, we collect the outermost
1429 // loop of every loop nest.
1430 if (L.empty() || VPlanBuildStressTest ||
1431 (EnableVPlanNativePath && isExplicitVecOuterLoop(&L, ORE))) {
1432 LoopBlocksRPO RPOT(&L);
1433 RPOT.perform(LI);
1434 if (!containsIrreducibleCFG<const BasicBlock *>(RPOT, *LI)) {
1435 V.push_back(&L);
1436 // TODO: Collect inner loops inside marked outer loops in case
1437 // vectorization fails for the outer loop. Do not invoke
1438 // 'containsIrreducibleCFG' again for inner loops when the outer loop is
1439 // already known to be reducible. We can use an inherited attribute for
1440 // that.
1441 return;
1442 }
1443 }
1444 for (Loop *InnerL : L)
1445 collectSupportedLoops(*InnerL, LI, ORE, V);
1446}
1447
1448namespace {
1449
1450/// The LoopVectorize Pass.
1451struct LoopVectorize : public FunctionPass {
1452 /// Pass identification, replacement for typeid
1453 static char ID;
1454
1455 LoopVectorizePass Impl;
1456
1457 explicit LoopVectorize(bool InterleaveOnlyWhenForced = false,
1458 bool VectorizeOnlyWhenForced = false)
1459 : FunctionPass(ID) {
1460 Impl.InterleaveOnlyWhenForced = InterleaveOnlyWhenForced;
1461 Impl.VectorizeOnlyWhenForced = VectorizeOnlyWhenForced;
1462 initializeLoopVectorizePass(*PassRegistry::getPassRegistry());
1463 }
1464
1465 bool runOnFunction(Function &F) override {
1466 if (skipFunction(F))
1467 return false;
1468
1469 auto *SE = &getAnalysis<ScalarEvolutionWrapperPass>().getSE();
1470 auto *LI = &getAnalysis<LoopInfoWrapperPass>().getLoopInfo();
1471 auto *TTI = &getAnalysis<TargetTransformInfoWrapperPass>().getTTI(F);
1472 auto *DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
1473 auto *BFI = &getAnalysis<BlockFrequencyInfoWrapperPass>().getBFI();
1474 auto *TLIP = getAnalysisIfAvailable<TargetLibraryInfoWrapperPass>();
1475 auto *TLI = TLIP ? &TLIP->getTLI() : nullptr;
1476 auto *AA = &getAnalysis<AAResultsWrapperPass>().getAAResults();
1477 auto *AC = &getAnalysis<AssumptionCacheTracker>().getAssumptionCache(F);
1478 auto *LAA = &getAnalysis<LoopAccessLegacyAnalysis>();
1479 auto *DB = &getAnalysis<DemandedBitsWrapperPass>().getDemandedBits();
1480 auto *ORE = &getAnalysis<OptimizationRemarkEmitterWrapperPass>().getORE();
1481 auto *PSI = &getAnalysis<ProfileSummaryInfoWrapperPass>().getPSI();
1482
1483 std::function<const LoopAccessInfo &(Loop &)> GetLAA =
1484 [&](Loop &L) -> const LoopAccessInfo & { return LAA->getInfo(&L); };
1485
1486 return Impl.runImpl(F, *SE, *LI, *TTI, *DT, *BFI, TLI, *DB, *AA, *AC,
1487 GetLAA, *ORE, PSI);
1488 }
1489
1490 void getAnalysisUsage(AnalysisUsage &AU) const override {
1491 AU.addRequired<AssumptionCacheTracker>();
1492 AU.addRequired<BlockFrequencyInfoWrapperPass>();
1493 AU.addRequired<DominatorTreeWrapperPass>();
1494 AU.addRequired<LoopInfoWrapperPass>();
1495 AU.addRequired<ScalarEvolutionWrapperPass>();
1496 AU.addRequired<TargetTransformInfoWrapperPass>();
1497 AU.addRequired<AAResultsWrapperPass>();
1498 AU.addRequired<LoopAccessLegacyAnalysis>();
1499 AU.addRequired<DemandedBitsWrapperPass>();
1500 AU.addRequired<OptimizationRemarkEmitterWrapperPass>();
1501
1502 // We currently do not preserve loopinfo/dominator analyses with outer loop
1503 // vectorization. Until this is addressed, mark these analyses as preserved
1504 // only for non-VPlan-native path.
1505 // TODO: Preserve Loop and Dominator analyses for VPlan-native path.
1506 if (!EnableVPlanNativePath) {
1507 AU.addPreserved<LoopInfoWrapperPass>();
1508 AU.addPreserved<DominatorTreeWrapperPass>();
1509 }
1510
1511 AU.addPreserved<BasicAAWrapperPass>();
1512 AU.addPreserved<GlobalsAAWrapperPass>();
1513 AU.addRequired<ProfileSummaryInfoWrapperPass>();
1514 }
1515};
1516
1517} // end anonymous namespace
1518
1519//===----------------------------------------------------------------------===//
1520// Implementation of LoopVectorizationLegality, InnerLoopVectorizer and
1521// LoopVectorizationCostModel and LoopVectorizationPlanner.
1522//===----------------------------------------------------------------------===//
1523
1524Value *InnerLoopVectorizer::getBroadcastInstrs(Value *V) {
1525 // We need to place the broadcast of invariant variables outside the loop,
1526 // but only if it's proven safe to do so. Else, broadcast will be inside
1527 // vector loop body.
1528 Instruction *Instr = dyn_cast<Instruction>(V);
1529 bool SafeToHoist = OrigLoop->isLoopInvariant(V) &&
1530 (!Instr ||
1531 DT->dominates(Instr->getParent(), LoopVectorPreHeader));
1532 // Place the code for broadcasting invariant variables in the new preheader.
1533 IRBuilder<>::InsertPointGuard Guard(Builder);
1534 if (SafeToHoist)
1535 Builder.SetInsertPoint(LoopVectorPreHeader->getTerminator());
1536
1537 // Broadcast the scalar into all locations in the vector.
1538 Value *Shuf = Builder.CreateVectorSplat(VF, V, "broadcast");
1539
1540 return Shuf;
1541}
1542
1543void InnerLoopVectorizer::createVectorIntOrFpInductionPHI(
1544 const InductionDescriptor &II, Value *Step, Instruction *EntryVal) {
1545 assert((isa<PHINode>(EntryVal) || isa<TruncInst>(EntryVal)) &&(((isa<PHINode>(EntryVal) || isa<TruncInst>(EntryVal
)) && "Expected either an induction phi-node or a truncate of it!"
) ? static_cast<void> (0) : __assert_fail ("(isa<PHINode>(EntryVal) || isa<TruncInst>(EntryVal)) && \"Expected either an induction phi-node or a truncate of it!\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 1546, __PRETTY_FUNCTION__))
1546 "Expected either an induction phi-node or a truncate of it!")(((isa<PHINode>(EntryVal) || isa<TruncInst>(EntryVal
)) && "Expected either an induction phi-node or a truncate of it!"
) ? static_cast<void> (0) : __assert_fail ("(isa<PHINode>(EntryVal) || isa<TruncInst>(EntryVal)) && \"Expected either an induction phi-node or a truncate of it!\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 1546, __PRETTY_FUNCTION__))
;
1547 Value *Start = II.getStartValue();
1548
1549 // Construct the initial value of the vector IV in the vector loop preheader
1550 auto CurrIP = Builder.saveIP();
1551 Builder.SetInsertPoint(LoopVectorPreHeader->getTerminator());
1552 if (isa<TruncInst>(EntryVal)) {
1553 assert(Start->getType()->isIntegerTy() &&((Start->getType()->isIntegerTy() && "Truncation requires an integer type"
) ? static_cast<void> (0) : __assert_fail ("Start->getType()->isIntegerTy() && \"Truncation requires an integer type\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 1554, __PRETTY_FUNCTION__))
1554 "Truncation requires an integer type")((Start->getType()->isIntegerTy() && "Truncation requires an integer type"
) ? static_cast<void> (0) : __assert_fail ("Start->getType()->isIntegerTy() && \"Truncation requires an integer type\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 1554, __PRETTY_FUNCTION__))
;
1555 auto *TruncType = cast<IntegerType>(EntryVal->getType());
1556 Step = Builder.CreateTrunc(Step, TruncType);
1557 Start = Builder.CreateCast(Instruction::Trunc, Start, TruncType);
1558 }
1559 Value *SplatStart = Builder.CreateVectorSplat(VF, Start);
1560 Value *SteppedStart =
1561 getStepVector(SplatStart, 0, Step, II.getInductionOpcode());
1562
1563 // We create vector phi nodes for both integer and floating-point induction
1564 // variables. Here, we determine the kind of arithmetic we will perform.
1565 Instruction::BinaryOps AddOp;
1566 Instruction::BinaryOps MulOp;
1567 if (Step->getType()->isIntegerTy()) {
1568 AddOp = Instruction::Add;
1569 MulOp = Instruction::Mul;
1570 } else {
1571 AddOp = II.getInductionOpcode();
1572 MulOp = Instruction::FMul;
1573 }
1574
1575 // Multiply the vectorization factor by the step using integer or
1576 // floating-point arithmetic as appropriate.
1577 Value *ConstVF = getSignedIntOrFpConstant(Step->getType(), VF);
1578 Value *Mul = addFastMathFlag(Builder.CreateBinOp(MulOp, Step, ConstVF));
1579
1580 // Create a vector splat to use in the induction update.
1581 //
1582 // FIXME: If the step is non-constant, we create the vector splat with
1583 // IRBuilder. IRBuilder can constant-fold the multiply, but it doesn't
1584 // handle a constant vector splat.
1585 Value *SplatVF = isa<Constant>(Mul)
1586 ? ConstantVector::getSplat(VF, cast<Constant>(Mul))
1587 : Builder.CreateVectorSplat(VF, Mul);
1588 Builder.restoreIP(CurrIP);
1589
1590 // We may need to add the step a number of times, depending on the unroll
1591 // factor. The last of those goes into the PHI.
1592 PHINode *VecInd = PHINode::Create(SteppedStart->getType(), 2, "vec.ind",
1593 &*LoopVectorBody->getFirstInsertionPt());
1594 VecInd->setDebugLoc(EntryVal->getDebugLoc());
1595 Instruction *LastInduction = VecInd;
1596 for (unsigned Part = 0; Part < UF; ++Part) {
1597 VectorLoopValueMap.setVectorValue(EntryVal, Part, LastInduction);
1598
1599 if (isa<TruncInst>(EntryVal))
1600 addMetadata(LastInduction, EntryVal);
1601 recordVectorLoopValueForInductionCast(II, EntryVal, LastInduction, Part);
1602
1603 LastInduction = cast<Instruction>(addFastMathFlag(
1604 Builder.CreateBinOp(AddOp, LastInduction, SplatVF, "step.add")));
1605 LastInduction->setDebugLoc(EntryVal->getDebugLoc());
1606 }
1607
1608 // Move the last step to the end of the latch block. This ensures consistent
1609 // placement of all induction updates.
1610 auto *LoopVectorLatch = LI->getLoopFor(LoopVectorBody)->getLoopLatch();
1611 auto *Br = cast<BranchInst>(LoopVectorLatch->getTerminator());
1612 auto *ICmp = cast<Instruction>(Br->getCondition());
1613 LastInduction->moveBefore(ICmp);
1614 LastInduction->setName("vec.ind.next");
1615
1616 VecInd->addIncoming(SteppedStart, LoopVectorPreHeader);
1617 VecInd->addIncoming(LastInduction, LoopVectorLatch);
1618}
1619
1620bool InnerLoopVectorizer::shouldScalarizeInstruction(Instruction *I) const {
1621 return Cost->isScalarAfterVectorization(I, VF) ||
1622 Cost->isProfitableToScalarize(I, VF);
1623}
1624
1625bool InnerLoopVectorizer::needsScalarInduction(Instruction *IV) const {
1626 if (shouldScalarizeInstruction(IV))
1627 return true;
1628 auto isScalarInst = [&](User *U) -> bool {
1629 auto *I = cast<Instruction>(U);
1630 return (OrigLoop->contains(I) && shouldScalarizeInstruction(I));
1631 };
1632 return llvm::any_of(IV->users(), isScalarInst);
1633}
1634
1635void InnerLoopVectorizer::recordVectorLoopValueForInductionCast(
1636 const InductionDescriptor &ID, const Instruction *EntryVal,
1637 Value *VectorLoopVal, unsigned Part, unsigned Lane) {
1638 assert((isa<PHINode>(EntryVal) || isa<TruncInst>(EntryVal)) &&(((isa<PHINode>(EntryVal) || isa<TruncInst>(EntryVal
)) && "Expected either an induction phi-node or a truncate of it!"
) ? static_cast<void> (0) : __assert_fail ("(isa<PHINode>(EntryVal) || isa<TruncInst>(EntryVal)) && \"Expected either an induction phi-node or a truncate of it!\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 1639, __PRETTY_FUNCTION__))
1639 "Expected either an induction phi-node or a truncate of it!")(((isa<PHINode>(EntryVal) || isa<TruncInst>(EntryVal
)) && "Expected either an induction phi-node or a truncate of it!"
) ? static_cast<void> (0) : __assert_fail ("(isa<PHINode>(EntryVal) || isa<TruncInst>(EntryVal)) && \"Expected either an induction phi-node or a truncate of it!\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 1639, __PRETTY_FUNCTION__))
;
1640
1641 // This induction variable is not the phi from the original loop but the
1642 // newly-created IV based on the proof that casted Phi is equal to the
1643 // uncasted Phi in the vectorized loop (under a runtime guard possibly). It
1644 // re-uses the same InductionDescriptor that original IV uses but we don't
1645 // have to do any recording in this case - that is done when original IV is
1646 // processed.
1647 if (isa<TruncInst>(EntryVal))
1648 return;
1649
1650 const SmallVectorImpl<Instruction *> &Casts = ID.getCastInsts();
1651 if (Casts.empty())
1652 return;
1653 // Only the first Cast instruction in the Casts vector is of interest.
1654 // The rest of the Casts (if exist) have no uses outside the
1655 // induction update chain itself.
1656 Instruction *CastInst = *Casts.begin();
1657 if (Lane < UINT_MAX(2147483647 *2U +1U))
1658 VectorLoopValueMap.setScalarValue(CastInst, {Part, Lane}, VectorLoopVal);
1659 else
1660 VectorLoopValueMap.setVectorValue(CastInst, Part, VectorLoopVal);
1661}
1662
1663void InnerLoopVectorizer::widenIntOrFpInduction(PHINode *IV, TruncInst *Trunc) {
1664 assert((IV->getType()->isIntegerTy() || IV != OldInduction) &&(((IV->getType()->isIntegerTy() || IV != OldInduction) &&
"Primary induction variable must have an integer type") ? static_cast
<void> (0) : __assert_fail ("(IV->getType()->isIntegerTy() || IV != OldInduction) && \"Primary induction variable must have an integer type\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 1665, __PRETTY_FUNCTION__))
1665 "Primary induction variable must have an integer type")(((IV->getType()->isIntegerTy() || IV != OldInduction) &&
"Primary induction variable must have an integer type") ? static_cast
<void> (0) : __assert_fail ("(IV->getType()->isIntegerTy() || IV != OldInduction) && \"Primary induction variable must have an integer type\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 1665, __PRETTY_FUNCTION__))
;
1666
1667 auto II = Legal->getInductionVars()->find(IV);
1668 assert(II != Legal->getInductionVars()->end() && "IV is not an induction")((II != Legal->getInductionVars()->end() && "IV is not an induction"
) ? static_cast<void> (0) : __assert_fail ("II != Legal->getInductionVars()->end() && \"IV is not an induction\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 1668, __PRETTY_FUNCTION__))
;
1669
1670 auto ID = II->second;
1671 assert(IV->getType() == ID.getStartValue()->getType() && "Types must match")((IV->getType() == ID.getStartValue()->getType() &&
"Types must match") ? static_cast<void> (0) : __assert_fail
("IV->getType() == ID.getStartValue()->getType() && \"Types must match\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 1671, __PRETTY_FUNCTION__))
;
1672
1673 // The scalar value to broadcast. This will be derived from the canonical
1674 // induction variable.
1675 Value *ScalarIV = nullptr;
1676
1677 // The value from the original loop to which we are mapping the new induction
1678 // variable.
1679 Instruction *EntryVal = Trunc ? cast<Instruction>(Trunc) : IV;
1680
1681 // True if we have vectorized the induction variable.
1682 auto VectorizedIV = false;
1683
1684 // Determine if we want a scalar version of the induction variable. This is
1685 // true if the induction variable itself is not widened, or if it has at
1686 // least one user in the loop that is not widened.
1687 auto NeedsScalarIV = VF > 1 && needsScalarInduction(EntryVal);
1688
1689 // Generate code for the induction step. Note that induction steps are
1690 // required to be loop-invariant
1691 assert(PSE.getSE()->isLoopInvariant(ID.getStep(), OrigLoop) &&((PSE.getSE()->isLoopInvariant(ID.getStep(), OrigLoop) &&
"Induction step should be loop invariant") ? static_cast<
void> (0) : __assert_fail ("PSE.getSE()->isLoopInvariant(ID.getStep(), OrigLoop) && \"Induction step should be loop invariant\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 1692, __PRETTY_FUNCTION__))
1692 "Induction step should be loop invariant")((PSE.getSE()->isLoopInvariant(ID.getStep(), OrigLoop) &&
"Induction step should be loop invariant") ? static_cast<
void> (0) : __assert_fail ("PSE.getSE()->isLoopInvariant(ID.getStep(), OrigLoop) && \"Induction step should be loop invariant\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 1692, __PRETTY_FUNCTION__))
;
1693 auto &DL = OrigLoop->getHeader()->getModule()->getDataLayout();
1694 Value *Step = nullptr;
1695 if (PSE.getSE()->isSCEVable(IV->getType())) {
1696 SCEVExpander Exp(*PSE.getSE(), DL, "induction");
1697 Step = Exp.expandCodeFor(ID.getStep(), ID.getStep()->getType(),
1698 LoopVectorPreHeader->getTerminator());
1699 } else {
1700 Step = cast<SCEVUnknown>(ID.getStep())->getValue();
1701 }
1702
1703 // Try to create a new independent vector induction variable. If we can't
1704 // create the phi node, we will splat the scalar induction variable in each
1705 // loop iteration.
1706 if (VF > 1 && !shouldScalarizeInstruction(EntryVal)) {
1707 createVectorIntOrFpInductionPHI(ID, Step, EntryVal);
1708 VectorizedIV = true;
1709 }
1710
1711 // If we haven't yet vectorized the induction variable, or if we will create
1712 // a scalar one, we need to define the scalar induction variable and step
1713 // values. If we were given a truncation type, truncate the canonical
1714 // induction variable and step. Otherwise, derive these values from the
1715 // induction descriptor.
1716 if (!VectorizedIV || NeedsScalarIV) {
1717 ScalarIV = Induction;
1718 if (IV != OldInduction) {
1719 ScalarIV = IV->getType()->isIntegerTy()
1720 ? Builder.CreateSExtOrTrunc(Induction, IV->getType())
1721 : Builder.CreateCast(Instruction::SIToFP, Induction,
1722 IV->getType());
1723 ScalarIV = emitTransformedIndex(Builder, ScalarIV, PSE.getSE(), DL, ID);
1724 ScalarIV->setName("offset.idx");
1725 }
1726 if (Trunc) {
1727 auto *TruncType = cast<IntegerType>(Trunc->getType());
1728 assert(Step->getType()->isIntegerTy() &&((Step->getType()->isIntegerTy() && "Truncation requires an integer step"
) ? static_cast<void> (0) : __assert_fail ("Step->getType()->isIntegerTy() && \"Truncation requires an integer step\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 1729, __PRETTY_FUNCTION__))
1729 "Truncation requires an integer step")((Step->getType()->isIntegerTy() && "Truncation requires an integer step"
) ? static_cast<void> (0) : __assert_fail ("Step->getType()->isIntegerTy() && \"Truncation requires an integer step\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 1729, __PRETTY_FUNCTION__))
;
1730 ScalarIV = Builder.CreateTrunc(ScalarIV, TruncType);
1731 Step = Builder.CreateTrunc(Step, TruncType);
1732 }
1733 }
1734
1735 // If we haven't yet vectorized the induction variable, splat the scalar
1736 // induction variable, and build the necessary step vectors.
1737 // TODO: Don't do it unless the vectorized IV is really required.
1738 if (!VectorizedIV) {
1739 Value *Broadcasted = getBroadcastInstrs(ScalarIV);
1740 for (unsigned Part = 0; Part < UF; ++Part) {
1741 Value *EntryPart =
1742 getStepVector(Broadcasted, VF * Part, Step, ID.getInductionOpcode());
1743 VectorLoopValueMap.setVectorValue(EntryVal, Part, EntryPart);
1744 if (Trunc)
1745 addMetadata(EntryPart, Trunc);
1746 recordVectorLoopValueForInductionCast(ID, EntryVal, EntryPart, Part);
1747 }
1748 }
1749
1750 // If an induction variable is only used for counting loop iterations or
1751 // calculating addresses, it doesn't need to be widened. Create scalar steps
1752 // that can be used by instructions we will later scalarize. Note that the
1753 // addition of the scalar steps will not increase the number of instructions
1754 // in the loop in the common case prior to InstCombine. We will be trading
1755 // one vector extract for each scalar step.
1756 if (NeedsScalarIV)
1757 buildScalarSteps(ScalarIV, Step, EntryVal, ID);
1758}
1759
1760Value *InnerLoopVectorizer::getStepVector(Value *Val, int StartIdx, Value *Step,
1761 Instruction::BinaryOps BinOp) {
1762 // Create and check the types.
1763 assert(Val->getType()->isVectorTy() && "Must be a vector")((Val->getType()->isVectorTy() && "Must be a vector"
) ? static_cast<void> (0) : __assert_fail ("Val->getType()->isVectorTy() && \"Must be a vector\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 1763, __PRETTY_FUNCTION__))
;
1764 int VLen = Val->getType()->getVectorNumElements();
1765
1766 Type *STy = Val->getType()->getScalarType();
1767 assert((STy->isIntegerTy() || STy->isFloatingPointTy()) &&(((STy->isIntegerTy() || STy->isFloatingPointTy()) &&
"Induction Step must be an integer or FP") ? static_cast<
void> (0) : __assert_fail ("(STy->isIntegerTy() || STy->isFloatingPointTy()) && \"Induction Step must be an integer or FP\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 1768, __PRETTY_FUNCTION__))
1768 "Induction Step must be an integer or FP")(((STy->isIntegerTy() || STy->isFloatingPointTy()) &&
"Induction Step must be an integer or FP") ? static_cast<
void> (0) : __assert_fail ("(STy->isIntegerTy() || STy->isFloatingPointTy()) && \"Induction Step must be an integer or FP\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 1768, __PRETTY_FUNCTION__))
;
1769 assert(Step->getType() == STy && "Step has wrong type")((Step->getType() == STy && "Step has wrong type")
? static_cast<void> (0) : __assert_fail ("Step->getType() == STy && \"Step has wrong type\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 1769, __PRETTY_FUNCTION__))
;
1770
1771 SmallVector<Constant *, 8> Indices;
1772
1773 if (STy->isIntegerTy()) {
1774 // Create a vector of consecutive numbers from zero to VF.
1775 for (int i = 0; i < VLen; ++i)
1776 Indices.push_back(ConstantInt::get(STy, StartIdx + i));
1777
1778 // Add the consecutive indices to the vector value.
1779 Constant *Cv = ConstantVector::get(Indices);
1780 assert(Cv->getType() == Val->getType() && "Invalid consecutive vec")((Cv->getType() == Val->getType() && "Invalid consecutive vec"
) ? static_cast<void> (0) : __assert_fail ("Cv->getType() == Val->getType() && \"Invalid consecutive vec\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 1780, __PRETTY_FUNCTION__))
;
1781 Step = Builder.CreateVectorSplat(VLen, Step);
1782 assert(Step->getType() == Val->getType() && "Invalid step vec")((Step->getType() == Val->getType() && "Invalid step vec"
) ? static_cast<void> (0) : __assert_fail ("Step->getType() == Val->getType() && \"Invalid step vec\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 1782, __PRETTY_FUNCTION__))
;
1783 // FIXME: The newly created binary instructions should contain nsw/nuw flags,
1784 // which can be found from the original scalar operations.
1785 Step = Builder.CreateMul(Cv, Step);
1786 return Builder.CreateAdd(Val, Step, "induction");
1787 }
1788
1789 // Floating point induction.
1790 assert((BinOp == Instruction::FAdd || BinOp == Instruction::FSub) &&(((BinOp == Instruction::FAdd || BinOp == Instruction::FSub) &&
"Binary Opcode should be specified for FP induction") ? static_cast
<void> (0) : __assert_fail ("(BinOp == Instruction::FAdd || BinOp == Instruction::FSub) && \"Binary Opcode should be specified for FP induction\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 1791, __PRETTY_FUNCTION__))
1791 "Binary Opcode should be specified for FP induction")(((BinOp == Instruction::FAdd || BinOp == Instruction::FSub) &&
"Binary Opcode should be specified for FP induction") ? static_cast
<void> (0) : __assert_fail ("(BinOp == Instruction::FAdd || BinOp == Instruction::FSub) && \"Binary Opcode should be specified for FP induction\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 1791, __PRETTY_FUNCTION__))
;
1792 // Create a vector of consecutive numbers from zero to VF.
1793 for (int i = 0; i < VLen; ++i)
1794 Indices.push_back(ConstantFP::get(STy, (double)(StartIdx + i)));
1795
1796 // Add the consecutive indices to the vector value.
1797 Constant *Cv = ConstantVector::get(Indices);
1798
1799 Step = Builder.CreateVectorSplat(VLen, Step);
1800
1801 // Floating point operations had to be 'fast' to enable the induction.
1802 FastMathFlags Flags;
1803 Flags.setFast();
1804
1805 Value *MulOp = Builder.CreateFMul(Cv, Step);
1806 if (isa<Instruction>(MulOp))
1807 // Have to check, MulOp may be a constant
1808 cast<Instruction>(MulOp)->setFastMathFlags(Flags);
1809
1810 Value *BOp = Builder.CreateBinOp(BinOp, Val, MulOp, "induction");
1811 if (isa<Instruction>(BOp))
1812 cast<Instruction>(BOp)->setFastMathFlags(Flags);
1813 return BOp;
1814}
1815
1816void InnerLoopVectorizer::buildScalarSteps(Value *ScalarIV, Value *Step,
1817 Instruction *EntryVal,
1818 const InductionDescriptor &ID) {
1819 // We shouldn't have to build scalar steps if we aren't vectorizing.
1820 assert(VF > 1 && "VF should be greater than one")((VF > 1 && "VF should be greater than one") ? static_cast
<void> (0) : __assert_fail ("VF > 1 && \"VF should be greater than one\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 1820, __PRETTY_FUNCTION__))
;
1821
1822 // Get the value type and ensure it and the step have the same integer type.
1823 Type *ScalarIVTy = ScalarIV->getType()->getScalarType();
1824 assert(ScalarIVTy == Step->getType() &&((ScalarIVTy == Step->getType() && "Val and Step should have the same type"
) ? static_cast<void> (0) : __assert_fail ("ScalarIVTy == Step->getType() && \"Val and Step should have the same type\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 1825, __PRETTY_FUNCTION__))
1825 "Val and Step should have the same type")((ScalarIVTy == Step->getType() && "Val and Step should have the same type"
) ? static_cast<void> (0) : __assert_fail ("ScalarIVTy == Step->getType() && \"Val and Step should have the same type\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 1825, __PRETTY_FUNCTION__))
;
1826
1827 // We build scalar steps for both integer and floating-point induction
1828 // variables. Here, we determine the kind of arithmetic we will perform.
1829 Instruction::BinaryOps AddOp;
1830 Instruction::BinaryOps MulOp;
1831 if (ScalarIVTy->isIntegerTy()) {
1832 AddOp = Instruction::Add;
1833 MulOp = Instruction::Mul;
1834 } else {
1835 AddOp = ID.getInductionOpcode();
1836 MulOp = Instruction::FMul;
1837 }
1838
1839 // Determine the number of scalars we need to generate for each unroll
1840 // iteration. If EntryVal is uniform, we only need to generate the first
1841 // lane. Otherwise, we generate all VF values.
1842 unsigned Lanes =
1843 Cost->isUniformAfterVectorization(cast<Instruction>(EntryVal), VF) ? 1
1844 : VF;
1845 // Compute the scalar steps and save the results in VectorLoopValueMap.
1846 for (unsigned Part = 0; Part < UF; ++Part) {
1847 for (unsigned Lane = 0; Lane < Lanes; ++Lane) {
1848 auto *StartIdx = getSignedIntOrFpConstant(ScalarIVTy, VF * Part + Lane);
1849 auto *Mul = addFastMathFlag(Builder.CreateBinOp(MulOp, StartIdx, Step));
1850 auto *Add = addFastMathFlag(Builder.CreateBinOp(AddOp, ScalarIV, Mul));
1851 VectorLoopValueMap.setScalarValue(EntryVal, {Part, Lane}, Add);
1852 recordVectorLoopValueForInductionCast(ID, EntryVal, Add, Part, Lane);
1853 }
1854 }
1855}
1856
1857Value *InnerLoopVectorizer::getOrCreateVectorValue(Value *V, unsigned Part) {
1858 assert(V != Induction && "The new induction variable should not be used.")((V != Induction && "The new induction variable should not be used."
) ? static_cast<void> (0) : __assert_fail ("V != Induction && \"The new induction variable should not be used.\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 1858, __PRETTY_FUNCTION__))
;
1859 assert(!V->getType()->isVectorTy() && "Can't widen a vector")((!V->getType()->isVectorTy() && "Can't widen a vector"
) ? static_cast<void> (0) : __assert_fail ("!V->getType()->isVectorTy() && \"Can't widen a vector\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 1859, __PRETTY_FUNCTION__))
;
1860 assert(!V->getType()->isVoidTy() && "Type does not produce a value")((!V->getType()->isVoidTy() && "Type does not produce a value"
) ? static_cast<void> (0) : __assert_fail ("!V->getType()->isVoidTy() && \"Type does not produce a value\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 1860, __PRETTY_FUNCTION__))
;
1861
1862 // If we have a stride that is replaced by one, do it here. Defer this for
1863 // the VPlan-native path until we start running Legal checks in that path.
1864 if (!EnableVPlanNativePath && Legal->hasStride(V))
1865 V = ConstantInt::get(V->getType(), 1);
1866
1867 // If we have a vector mapped to this value, return it.
1868 if (VectorLoopValueMap.hasVectorValue(V, Part))
1869 return VectorLoopValueMap.getVectorValue(V, Part);
1870
1871 // If the value has not been vectorized, check if it has been scalarized
1872 // instead. If it has been scalarized, and we actually need the value in
1873 // vector form, we will construct the vector values on demand.
1874 if (VectorLoopValueMap.hasAnyScalarValue(V)) {
1875 Value *ScalarValue = VectorLoopValueMap.getScalarValue(V, {Part, 0});
1876
1877 // If we've scalarized a value, that value should be an instruction.
1878 auto *I = cast<Instruction>(V);
1879
1880 // If we aren't vectorizing, we can just copy the scalar map values over to
1881 // the vector map.
1882 if (VF == 1) {
1883 VectorLoopValueMap.setVectorValue(V, Part, ScalarValue);
1884 return ScalarValue;
1885 }
1886
1887 // Get the last scalar instruction we generated for V and Part. If the value
1888 // is known to be uniform after vectorization, this corresponds to lane zero
1889 // of the Part unroll iteration. Otherwise, the last instruction is the one
1890 // we created for the last vector lane of the Part unroll iteration.
1891 unsigned LastLane = Cost->isUniformAfterVectorization(I, VF) ? 0 : VF - 1;
1892 auto *LastInst = cast<Instruction>(
1893 VectorLoopValueMap.getScalarValue(V, {Part, LastLane}));
1894
1895 // Set the insert point after the last scalarized instruction. This ensures
1896 // the insertelement sequence will directly follow the scalar definitions.
1897 auto OldIP = Builder.saveIP();
1898 auto NewIP = std::next(BasicBlock::iterator(LastInst));
1899 Builder.SetInsertPoint(&*NewIP);
1900
1901 // However, if we are vectorizing, we need to construct the vector values.
1902 // If the value is known to be uniform after vectorization, we can just
1903 // broadcast the scalar value corresponding to lane zero for each unroll
1904 // iteration. Otherwise, we construct the vector values using insertelement
1905 // instructions. Since the resulting vectors are stored in
1906 // VectorLoopValueMap, we will only generate the insertelements once.
1907 Value *VectorValue = nullptr;
1908 if (Cost->isUniformAfterVectorization(I, VF)) {
1909 VectorValue = getBroadcastInstrs(ScalarValue);
1910 VectorLoopValueMap.setVectorValue(V, Part, VectorValue);
1911 } else {
1912 // Initialize packing with insertelements to start from undef.
1913 Value *Undef = UndefValue::get(VectorType::get(V->getType(), VF));
1914 VectorLoopValueMap.setVectorValue(V, Part, Undef);
1915 for (unsigned Lane = 0; Lane < VF; ++Lane)
1916 packScalarIntoVectorValue(V, {Part, Lane});
1917 VectorValue = VectorLoopValueMap.getVectorValue(V, Part);
1918 }
1919 Builder.restoreIP(OldIP);
1920 return VectorValue;
1921 }
1922
1923 // If this scalar is unknown, assume that it is a constant or that it is
1924 // loop invariant. Broadcast V and save the value for future uses.
1925 Value *B = getBroadcastInstrs(V);
1926 VectorLoopValueMap.setVectorValue(V, Part, B);
1927 return B;
1928}
1929
1930Value *
1931InnerLoopVectorizer::getOrCreateScalarValue(Value *V,
1932 const VPIteration &Instance) {
1933 // If the value is not an instruction contained in the loop, it should
1934 // already be scalar.
1935 if (OrigLoop->isLoopInvariant(V))
1936 return V;
1937
1938 assert(Instance.Lane > 0((Instance.Lane > 0 ? !Cost->isUniformAfterVectorization
(cast<Instruction>(V), VF) : true && "Uniform values only have lane zero"
) ? static_cast<void> (0) : __assert_fail ("Instance.Lane > 0 ? !Cost->isUniformAfterVectorization(cast<Instruction>(V), VF) : true && \"Uniform values only have lane zero\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 1940, __PRETTY_FUNCTION__))
1939 ? !Cost->isUniformAfterVectorization(cast<Instruction>(V), VF)((Instance.Lane > 0 ? !Cost->isUniformAfterVectorization
(cast<Instruction>(V), VF) : true && "Uniform values only have lane zero"
) ? static_cast<void> (0) : __assert_fail ("Instance.Lane > 0 ? !Cost->isUniformAfterVectorization(cast<Instruction>(V), VF) : true && \"Uniform values only have lane zero\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 1940, __PRETTY_FUNCTION__))
1940 : true && "Uniform values only have lane zero")((Instance.Lane > 0 ? !Cost->isUniformAfterVectorization
(cast<Instruction>(V), VF) : true && "Uniform values only have lane zero"
) ? static_cast<void> (0) : __assert_fail ("Instance.Lane > 0 ? !Cost->isUniformAfterVectorization(cast<Instruction>(V), VF) : true && \"Uniform values only have lane zero\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 1940, __PRETTY_FUNCTION__))
;
1941
1942 // If the value from the original loop has not been vectorized, it is
1943 // represented by UF x VF scalar values in the new loop. Return the requested
1944 // scalar value.
1945 if (VectorLoopValueMap.hasScalarValue(V, Instance))
1946 return VectorLoopValueMap.getScalarValue(V, Instance);
1947
1948 // If the value has not been scalarized, get its entry in VectorLoopValueMap
1949 // for the given unroll part. If this entry is not a vector type (i.e., the
1950 // vectorization factor is one), there is no need to generate an
1951 // extractelement instruction.
1952 auto *U = getOrCreateVectorValue(V, Instance.Part);
1953 if (!U->getType()->isVectorTy()) {
1954 assert(VF == 1 && "Value not scalarized has non-vector type")((VF == 1 && "Value not scalarized has non-vector type"
) ? static_cast<void> (0) : __assert_fail ("VF == 1 && \"Value not scalarized has non-vector type\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 1954, __PRETTY_FUNCTION__))
;
1955 return U;
1956 }
1957
1958 // Otherwise, the value from the original loop has been vectorized and is
1959 // represented by UF vector values. Extract and return the requested scalar
1960 // value from the appropriate vector lane.
1961 return Builder.CreateExtractElement(U, Builder.getInt32(Instance.Lane));
1962}
1963
1964void InnerLoopVectorizer::packScalarIntoVectorValue(
1965 Value *V, const VPIteration &Instance) {
1966 assert(V != Induction && "The new induction variable should not be used.")((V != Induction && "The new induction variable should not be used."
) ? static_cast<void> (0) : __assert_fail ("V != Induction && \"The new induction variable should not be used.\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 1966, __PRETTY_FUNCTION__))
;
1967 assert(!V->getType()->isVectorTy() && "Can't pack a vector")((!V->getType()->isVectorTy() && "Can't pack a vector"
) ? static_cast<void> (0) : __assert_fail ("!V->getType()->isVectorTy() && \"Can't pack a vector\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 1967, __PRETTY_FUNCTION__))
;
1968 assert(!V->getType()->isVoidTy() && "Type does not produce a value")((!V->getType()->isVoidTy() && "Type does not produce a value"
) ? static_cast<void> (0) : __assert_fail ("!V->getType()->isVoidTy() && \"Type does not produce a value\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 1968, __PRETTY_FUNCTION__))
;
1969
1970 Value *ScalarInst = VectorLoopValueMap.getScalarValue(V, Instance);
1971 Value *VectorValue = VectorLoopValueMap.getVectorValue(V, Instance.Part);
1972 VectorValue = Builder.CreateInsertElement(VectorValue, ScalarInst,
1973 Builder.getInt32(Instance.Lane));
1974 VectorLoopValueMap.resetVectorValue(V, Instance.Part, VectorValue);
1975}
1976
1977Value *InnerLoopVectorizer::reverseVector(Value *Vec) {
1978 assert(Vec->getType()->isVectorTy() && "Invalid type")((Vec->getType()->isVectorTy() && "Invalid type"
) ? static_cast<void> (0) : __assert_fail ("Vec->getType()->isVectorTy() && \"Invalid type\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 1978, __PRETTY_FUNCTION__))
;
1979 SmallVector<Constant *, 8> ShuffleMask;
1980 for (unsigned i = 0; i < VF; ++i)
1981 ShuffleMask.push_back(Builder.getInt32(VF - i - 1));
1982
1983 return Builder.CreateShuffleVector(Vec, UndefValue::get(Vec->getType()),
1984 ConstantVector::get(ShuffleMask),
1985 "reverse");
1986}
1987
1988// Return whether we allow using masked interleave-groups (for dealing with
1989// strided loads/stores that reside in predicated blocks, or for dealing
1990// with gaps).
1991static bool useMaskedInterleavedAccesses(const TargetTransformInfo &TTI) {
1992 // If an override option has been passed in for interleaved accesses, use it.
1993 if (EnableMaskedInterleavedMemAccesses.getNumOccurrences() > 0)
1994 return EnableMaskedInterleavedMemAccesses;
1995
1996 return TTI.enableMaskedInterleavedAccessVectorization();
1997}
1998
1999// Try to vectorize the interleave group that \p Instr belongs to.
2000//
2001// E.g. Translate following interleaved load group (factor = 3):
2002// for (i = 0; i < N; i+=3) {
2003// R = Pic[i]; // Member of index 0
2004// G = Pic[i+1]; // Member of index 1
2005// B = Pic[i+2]; // Member of index 2
2006// ... // do something to R, G, B
2007// }
2008// To:
2009// %wide.vec = load <12 x i32> ; Read 4 tuples of R,G,B
2010// %R.vec = shuffle %wide.vec, undef, <0, 3, 6, 9> ; R elements
2011// %G.vec = shuffle %wide.vec, undef, <1, 4, 7, 10> ; G elements
2012// %B.vec = shuffle %wide.vec, undef, <2, 5, 8, 11> ; B elements
2013//
2014// Or translate following interleaved store group (factor = 3):
2015// for (i = 0; i < N; i+=3) {
2016// ... do something to R, G, B
2017// Pic[i] = R; // Member of index 0
2018// Pic[i+1] = G; // Member of index 1
2019// Pic[i+2] = B; // Member of index 2
2020// }
2021// To:
2022// %R_G.vec = shuffle %R.vec, %G.vec, <0, 1, 2, ..., 7>
2023// %B_U.vec = shuffle %B.vec, undef, <0, 1, 2, 3, u, u, u, u>
2024// %interleaved.vec = shuffle %R_G.vec, %B_U.vec,
2025// <0, 4, 8, 1, 5, 9, 2, 6, 10, 3, 7, 11> ; Interleave R,G,B elements
2026// store <12 x i32> %interleaved.vec ; Write 4 tuples of R,G,B
2027void InnerLoopVectorizer::vectorizeInterleaveGroup(Instruction *Instr,
2028 VectorParts *BlockInMask) {
2029 const InterleaveGroup<Instruction> *Group =
2030 Cost->getInterleavedAccessGroup(Instr);
2031 assert(Group && "Fail to get an interleaved access group.")((Group && "Fail to get an interleaved access group."
) ? static_cast<void> (0) : __assert_fail ("Group && \"Fail to get an interleaved access group.\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 2031, __PRETTY_FUNCTION__))
;
2032
2033 // Skip if current instruction is not the insert position.
2034 if (Instr != Group->getInsertPos())
2035 return;
2036
2037 const DataLayout &DL = Instr->getModule()->getDataLayout();
2038 Value *Ptr = getLoadStorePointerOperand(Instr);
2039
2040 // Prepare for the vector type of the interleaved load/store.
2041 Type *ScalarTy = getMemInstValueType(Instr);
2042 unsigned InterleaveFactor = Group->getFactor();
2043 Type *VecTy = VectorType::get(ScalarTy, InterleaveFactor * VF);
2044 Type *PtrTy = VecTy->getPointerTo(getLoadStoreAddressSpace(Instr));
2045
2046 // Prepare for the new pointers.
2047 setDebugLocFromInst(Builder, Ptr);
2048 SmallVector<Value *, 2> NewPtrs;
2049 unsigned Index = Group->getIndex(Instr);
2050
2051 VectorParts Mask;
2052 bool IsMaskForCondRequired = BlockInMask;
2053 if (IsMaskForCondRequired) {
2054 Mask = *BlockInMask;
2055 // TODO: extend the masked interleaved-group support to reversed access.
2056 assert(!Group->isReverse() && "Reversed masked interleave-group "((!Group->isReverse() && "Reversed masked interleave-group "
"not supported.") ? static_cast<void> (0) : __assert_fail
("!Group->isReverse() && \"Reversed masked interleave-group \" \"not supported.\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 2057, __PRETTY_FUNCTION__))
2057 "not supported.")((!Group->isReverse() && "Reversed masked interleave-group "
"not supported.") ? static_cast<void> (0) : __assert_fail
("!Group->isReverse() && \"Reversed masked interleave-group \" \"not supported.\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 2057, __PRETTY_FUNCTION__))
;
2058 }
2059
2060 // If the group is reverse, adjust the index to refer to the last vector lane
2061 // instead of the first. We adjust the index from the first vector lane,
2062 // rather than directly getting the pointer for lane VF - 1, because the
2063 // pointer operand of the interleaved access is supposed to be uniform. For
2064 // uniform instructions, we're only required to generate a value for the
2065 // first vector lane in each unroll iteration.
2066 if (Group->isReverse())
2067 Index += (VF - 1) * Group->getFactor();
2068
2069 bool InBounds = false;
2070 if (auto *gep = dyn_cast<GetElementPtrInst>(Ptr->stripPointerCasts()))
2071 InBounds = gep->isInBounds();
2072
2073 for (unsigned Part = 0; Part < UF; Part++) {
2074 Value *NewPtr = getOrCreateScalarValue(Ptr, {Part, 0});
2075
2076 // Notice current instruction could be any index. Need to adjust the address
2077 // to the member of index 0.
2078 //
2079 // E.g. a = A[i+1]; // Member of index 1 (Current instruction)
2080 // b = A[i]; // Member of index 0
2081 // Current pointer is pointed to A[i+1], adjust it to A[i].
2082 //
2083 // E.g. A[i+1] = a; // Member of index 1
2084 // A[i] = b; // Member of index 0
2085 // A[i+2] = c; // Member of index 2 (Current instruction)
2086 // Current pointer is pointed to A[i+2], adjust it to A[i].
2087 NewPtr = Builder.CreateGEP(ScalarTy, NewPtr, Builder.getInt32(-Index));
2088 if (InBounds)
2089 cast<GetElementPtrInst>(NewPtr)->setIsInBounds(true);
2090
2091 // Cast to the vector pointer type.
2092 NewPtrs.push_back(Builder.CreateBitCast(NewPtr, PtrTy));
2093 }
2094
2095 setDebugLocFromInst(Builder, Instr);
2096 Value *UndefVec = UndefValue::get(VecTy);
2097
2098 Value *MaskForGaps = nullptr;
2099 if (Group->requiresScalarEpilogue() && !Cost->isScalarEpilogueAllowed()) {
2100 MaskForGaps = createBitMaskForGaps(Builder, VF, *Group);
2101 assert(MaskForGaps && "Mask for Gaps is required but it is null")((MaskForGaps && "Mask for Gaps is required but it is null"
) ? static_cast<void> (0) : __assert_fail ("MaskForGaps && \"Mask for Gaps is required but it is null\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 2101, __PRETTY_FUNCTION__))
;
2102 }
2103
2104 // Vectorize the interleaved load group.
2105 if (isa<LoadInst>(Instr)) {
2106 // For each unroll part, create a wide load for the group.
2107 SmallVector<Value *, 2> NewLoads;
2108 for (unsigned Part = 0; Part < UF; Part++) {
2109 Instruction *NewLoad;
2110 if (IsMaskForCondRequired || MaskForGaps) {
2111 assert(useMaskedInterleavedAccesses(*TTI) &&((useMaskedInterleavedAccesses(*TTI) && "masked interleaved groups are not allowed."
) ? static_cast<void> (0) : __assert_fail ("useMaskedInterleavedAccesses(*TTI) && \"masked interleaved groups are not allowed.\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 2112, __PRETTY_FUNCTION__))
2112 "masked interleaved groups are not allowed.")((useMaskedInterleavedAccesses(*TTI) && "masked interleaved groups are not allowed."
) ? static_cast<void> (0) : __assert_fail ("useMaskedInterleavedAccesses(*TTI) && \"masked interleaved groups are not allowed.\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 2112, __PRETTY_FUNCTION__))
;
2113 Value *GroupMask = MaskForGaps;
2114 if (IsMaskForCondRequired) {
2115 auto *Undefs = UndefValue::get(Mask[Part]->getType());
2116 auto *RepMask = createReplicatedMask(Builder, InterleaveFactor, VF);
2117 Value *ShuffledMask = Builder.CreateShuffleVector(
2118 Mask[Part], Undefs, RepMask, "interleaved.mask");
2119 GroupMask = MaskForGaps
2120 ? Builder.CreateBinOp(Instruction::And, ShuffledMask,
2121 MaskForGaps)
2122 : ShuffledMask;
2123 }
2124 NewLoad =
2125 Builder.CreateMaskedLoad(NewPtrs[Part], Group->getAlignment(),
2126 GroupMask, UndefVec, "wide.masked.vec");
2127 }
2128 else
2129 NewLoad = Builder.CreateAlignedLoad(VecTy, NewPtrs[Part],
2130 Group->getAlignment(), "wide.vec");
2131 Group->addMetadata(NewLoad);
2132 NewLoads.push_back(NewLoad);
2133 }
2134
2135 // For each member in the group, shuffle out the appropriate data from the
2136 // wide loads.
2137 for (unsigned I = 0; I < InterleaveFactor; ++I) {
2138 Instruction *Member = Group->getMember(I);
2139
2140 // Skip the gaps in the group.
2141 if (!Member)
2142 continue;
2143
2144 Constant *StrideMask = createStrideMask(Builder, I, InterleaveFactor, VF);
2145 for (unsigned Part = 0; Part < UF; Part++) {
2146 Value *StridedVec = Builder.CreateShuffleVector(
2147 NewLoads[Part], UndefVec, StrideMask, "strided.vec");
2148
2149 // If this member has different type, cast the result type.
2150 if (Member->getType() != ScalarTy) {
2151 VectorType *OtherVTy = VectorType::get(Member->getType(), VF);
2152 StridedVec = createBitOrPointerCast(StridedVec, OtherVTy, DL);
2153 }
2154
2155 if (Group->isReverse())
2156 StridedVec = reverseVector(StridedVec);
2157
2158 VectorLoopValueMap.setVectorValue(Member, Part, StridedVec);
2159 }
2160 }
2161 return;
2162 }
2163
2164 // The sub vector type for current instruction.
2165 VectorType *SubVT = VectorType::get(ScalarTy, VF);
2166
2167 // Vectorize the interleaved store group.
2168 for (unsigned Part = 0; Part < UF; Part++) {
2169 // Collect the stored vector from each member.
2170 SmallVector<Value *, 4> StoredVecs;
2171 for (unsigned i = 0; i < InterleaveFactor; i++) {
2172 // Interleaved store group doesn't allow a gap, so each index has a member
2173 Instruction *Member = Group->getMember(i);
2174 assert(Member && "Fail to get a member from an interleaved store group")((Member && "Fail to get a member from an interleaved store group"
) ? static_cast<void> (0) : __assert_fail ("Member && \"Fail to get a member from an interleaved store group\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 2174, __PRETTY_FUNCTION__))
;
2175
2176 Value *StoredVec = getOrCreateVectorValue(
2177 cast<StoreInst>(Member)->getValueOperand(), Part);
2178 if (Group->isReverse())
2179 StoredVec = reverseVector(StoredVec);
2180
2181 // If this member has different type, cast it to a unified type.
2182
2183 if (StoredVec->getType() != SubVT)
2184 StoredVec = createBitOrPointerCast(StoredVec, SubVT, DL);
2185
2186 StoredVecs.push_back(StoredVec);
2187 }
2188
2189 // Concatenate all vectors into a wide vector.
2190 Value *WideVec = concatenateVectors(Builder, StoredVecs);
2191
2192 // Interleave the elements in the wide vector.
2193 Constant *IMask = createInterleaveMask(Builder, VF, InterleaveFactor);
2194 Value *IVec = Builder.CreateShuffleVector(WideVec, UndefVec, IMask,
2195 "interleaved.vec");
2196
2197 Instruction *NewStoreInstr;
2198 if (IsMaskForCondRequired) {
2199 auto *Undefs = UndefValue::get(Mask[Part]->getType());
2200 auto *RepMask = createReplicatedMask(Builder, InterleaveFactor, VF);
2201 Value *ShuffledMask = Builder.CreateShuffleVector(
2202 Mask[Part], Undefs, RepMask, "interleaved.mask");
2203 NewStoreInstr = Builder.CreateMaskedStore(
2204 IVec, NewPtrs[Part], Group->getAlignment(), ShuffledMask);
2205 }
2206 else
2207 NewStoreInstr = Builder.CreateAlignedStore(IVec, NewPtrs[Part],
2208 Group->getAlignment());
2209
2210 Group->addMetadata(NewStoreInstr);
2211 }
2212}
2213
2214void InnerLoopVectorizer::vectorizeMemoryInstruction(Instruction *Instr,
2215 VectorParts *BlockInMask) {
2216 // Attempt to issue a wide load.
2217 LoadInst *LI = dyn_cast<LoadInst>(Instr);
2218 StoreInst *SI = dyn_cast<StoreInst>(Instr);
2219
2220 assert((LI || SI) && "Invalid Load/Store instruction")(((LI || SI) && "Invalid Load/Store instruction") ? static_cast
<void> (0) : __assert_fail ("(LI || SI) && \"Invalid Load/Store instruction\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 2220, __PRETTY_FUNCTION__))
;
2221
2222 LoopVectorizationCostModel::InstWidening Decision =
2223 Cost->getWideningDecision(Instr, VF);
2224 assert(Decision != LoopVectorizationCostModel::CM_Unknown &&((Decision != LoopVectorizationCostModel::CM_Unknown &&
"CM decision should be taken at this point") ? static_cast<
void> (0) : __assert_fail ("Decision != LoopVectorizationCostModel::CM_Unknown && \"CM decision should be taken at this point\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 2225, __PRETTY_FUNCTION__))
2225 "CM decision should be taken at this point")((Decision != LoopVectorizationCostModel::CM_Unknown &&
"CM decision should be taken at this point") ? static_cast<
void> (0) : __assert_fail ("Decision != LoopVectorizationCostModel::CM_Unknown && \"CM decision should be taken at this point\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 2225, __PRETTY_FUNCTION__))
;
2226 if (Decision == LoopVectorizationCostModel::CM_Interleave)
2227 return vectorizeInterleaveGroup(Instr);
2228
2229 Type *ScalarDataTy = getMemInstValueType(Instr);
2230 Type *DataTy = VectorType::get(ScalarDataTy, VF);
2231 Value *Ptr = getLoadStorePointerOperand(Instr);
2232 unsigned Alignment = getLoadStoreAlignment(Instr);
2233 // An alignment of 0 means target abi alignment. We need to use the scalar's
2234 // target abi alignment in such a case.
2235 const DataLayout &DL = Instr->getModule()->getDataLayout();
2236 if (!Alignment)
2237 Alignment = DL.getABITypeAlignment(ScalarDataTy);
2238 unsigned AddressSpace = getLoadStoreAddressSpace(Instr);
2239
2240 // Determine if the pointer operand of the access is either consecutive or
2241 // reverse consecutive.
2242 bool Reverse = (Decision == LoopVectorizationCostModel::CM_Widen_Reverse);
2243 bool ConsecutiveStride =
2244 Reverse || (Decision == LoopVectorizationCostModel::CM_Widen);
2245 bool CreateGatherScatter =
2246 (Decision == LoopVectorizationCostModel::CM_GatherScatter);
2247
2248 // Either Ptr feeds a vector load/store, or a vector GEP should feed a vector
2249 // gather/scatter. Otherwise Decision should have been to Scalarize.
2250 assert((ConsecutiveStride || CreateGatherScatter) &&(((ConsecutiveStride || CreateGatherScatter) && "The instruction should be scalarized"
) ? static_cast<void> (0) : __assert_fail ("(ConsecutiveStride || CreateGatherScatter) && \"The instruction should be scalarized\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 2251, __PRETTY_FUNCTION__))
2251 "The instruction should be scalarized")(((ConsecutiveStride || CreateGatherScatter) && "The instruction should be scalarized"
) ? static_cast<void> (0) : __assert_fail ("(ConsecutiveStride || CreateGatherScatter) && \"The instruction should be scalarized\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 2251, __PRETTY_FUNCTION__))
;
2252
2253 // Handle consecutive loads/stores.
2254 if (ConsecutiveStride)
2255 Ptr = getOrCreateScalarValue(Ptr, {0, 0});
2256
2257 VectorParts Mask;
2258 bool isMaskRequired = BlockInMask;
2259 if (isMaskRequired)
2260 Mask = *BlockInMask;
2261
2262 bool InBounds = false;
2263 if (auto *gep = dyn_cast<GetElementPtrInst>(
2264 getLoadStorePointerOperand(Instr)->stripPointerCasts()))
2265 InBounds = gep->isInBounds();
2266
2267 const auto CreateVecPtr = [&](unsigned Part, Value *Ptr) -> Value * {
2268 // Calculate the pointer for the specific unroll-part.
2269 GetElementPtrInst *PartPtr = nullptr;
2270
2271 if (Reverse) {
2272 // If the address is consecutive but reversed, then the
2273 // wide store needs to start at the last vector element.
2274 PartPtr = cast<GetElementPtrInst>(
2275 Builder.CreateGEP(ScalarDataTy, Ptr, Builder.getInt32(-Part * VF)));
2276 PartPtr->setIsInBounds(InBounds);
2277 PartPtr = cast<GetElementPtrInst>(
2278 Builder.CreateGEP(ScalarDataTy, PartPtr, Builder.getInt32(1 - VF)));
2279 PartPtr->setIsInBounds(InBounds);
2280 if (isMaskRequired) // Reverse of a null all-one mask is a null mask.
2281 Mask[Part] = reverseVector(Mask[Part]);
2282 } else {
2283 PartPtr = cast<GetElementPtrInst>(
2284 Builder.CreateGEP(ScalarDataTy, Ptr, Builder.getInt32(Part * VF)));
2285 PartPtr->setIsInBounds(InBounds);
2286 }
2287
2288 return Builder.CreateBitCast(PartPtr, DataTy->getPointerTo(AddressSpace));
2289 };
2290
2291 // Handle Stores:
2292 if (SI) {
2293 setDebugLocFromInst(Builder, SI);
2294
2295 for (unsigned Part = 0; Part < UF; ++Part) {
2296 Instruction *NewSI = nullptr;
2297 Value *StoredVal = getOrCreateVectorValue(SI->getValueOperand(), Part);
2298 if (CreateGatherScatter) {
2299 Value *MaskPart = isMaskRequired ? Mask[Part] : nullptr;
2300 Value *VectorGep = getOrCreateVectorValue(Ptr, Part);
2301 NewSI = Builder.CreateMaskedScatter(StoredVal, VectorGep, Alignment,
2302 MaskPart);
2303 } else {
2304 if (Reverse) {
2305 // If we store to reverse consecutive memory locations, then we need
2306 // to reverse the order of elements in the stored value.
2307 StoredVal = reverseVector(StoredVal);
2308 // We don't want to update the value in the map as it might be used in
2309 // another expression. So don't call resetVectorValue(StoredVal).
2310 }
2311 auto *VecPtr = CreateVecPtr(Part, Ptr);
2312 if (isMaskRequired)
2313 NewSI = Builder.CreateMaskedStore(StoredVal, VecPtr, Alignment,
2314 Mask[Part]);
2315 else
2316 NewSI = Builder.CreateAlignedStore(StoredVal, VecPtr, Alignment);
2317 }
2318 addMetadata(NewSI, SI);
2319 }
2320 return;
2321 }
2322
2323 // Handle loads.
2324 assert(LI && "Must have a load instruction")((LI && "Must have a load instruction") ? static_cast
<void> (0) : __assert_fail ("LI && \"Must have a load instruction\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 2324, __PRETTY_FUNCTION__))
;
2325 setDebugLocFromInst(Builder, LI);
2326 for (unsigned Part = 0; Part < UF; ++Part) {
2327 Value *NewLI;
2328 if (CreateGatherScatter) {
2329 Value *MaskPart = isMaskRequired ? Mask[Part] : nullptr;
2330 Value *VectorGep = getOrCreateVectorValue(Ptr, Part);
2331 NewLI = Builder.CreateMaskedGather(VectorGep, Alignment, MaskPart,
2332 nullptr, "wide.masked.gather");
2333 addMetadata(NewLI, LI);
2334 } else {
2335 auto *VecPtr = CreateVecPtr(Part, Ptr);
2336 if (isMaskRequired)
2337 NewLI = Builder.CreateMaskedLoad(VecPtr, Alignment, Mask[Part],
2338 UndefValue::get(DataTy),
2339 "wide.masked.load");
2340 else
2341 NewLI =
2342 Builder.CreateAlignedLoad(DataTy, VecPtr, Alignment, "wide.load");
2343
2344 // Add metadata to the load, but setVectorValue to the reverse shuffle.
2345 addMetadata(NewLI, LI);
2346 if (Reverse)
2347 NewLI = reverseVector(NewLI);
2348 }
2349 VectorLoopValueMap.setVectorValue(Instr, Part, NewLI);
2350 }
2351}
2352
2353void InnerLoopVectorizer::scalarizeInstruction(Instruction *Instr,
2354 const VPIteration &Instance,
2355 bool IfPredicateInstr) {
2356 assert(!Instr->getType()->isAggregateType() && "Can't handle vectors")((!Instr->getType()->isAggregateType() && "Can't handle vectors"
) ? static_cast<void> (0) : __assert_fail ("!Instr->getType()->isAggregateType() && \"Can't handle vectors\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 2356, __PRETTY_FUNCTION__))
;
2357
2358 setDebugLocFromInst(Builder, Instr);
2359
2360 // Does this instruction return a value ?
2361 bool IsVoidRetTy = Instr->getType()->isVoidTy();
2362
2363 Instruction *Cloned = Instr->clone();
2364 if (!IsVoidRetTy)
2365 Cloned->setName(Instr->getName() + ".cloned");
2366
2367 // Replace the operands of the cloned instructions with their scalar
2368 // equivalents in the new loop.
2369 for (unsigned op = 0, e = Instr->getNumOperands(); op != e; ++op) {
2370 auto *NewOp = getOrCreateScalarValue(Instr->getOperand(op), Instance);
2371 Cloned->setOperand(op, NewOp);
2372 }
2373 addNewMetadata(Cloned, Instr);
2374
2375 // Place the cloned scalar in the new loop.
2376 Builder.Insert(Cloned);
2377
2378 // Add the cloned scalar to the scalar map entry.
2379 VectorLoopValueMap.setScalarValue(Instr, Instance, Cloned);
2380
2381 // If we just cloned a new assumption, add it the assumption cache.
2382 if (auto *II = dyn_cast<IntrinsicInst>(Cloned))
2383 if (II->getIntrinsicID() == Intrinsic::assume)
2384 AC->registerAssumption(II);
2385
2386 // End if-block.
2387 if (IfPredicateInstr)
2388 PredicatedInstructions.push_back(Cloned);
2389}
2390
2391PHINode *InnerLoopVectorizer::createInductionVariable(Loop *L, Value *Start,
2392 Value *End, Value *Step,
2393 Instruction *DL) {
2394 BasicBlock *Header = L->getHeader();
2395 BasicBlock *Latch = L->getLoopLatch();
2396 // As we're just creating this loop, it's possible no latch exists
2397 // yet. If so, use the header as this will be a single block loop.
2398 if (!Latch)
2399 Latch = Header;
2400
2401 IRBuilder<> Builder(&*Header->getFirstInsertionPt());
2402 Instruction *OldInst = getDebugLocFromInstOrOperands(OldInduction);
2403 setDebugLocFromInst(Builder, OldInst);
2404 auto *Induction = Builder.CreatePHI(Start->getType(), 2, "index");
2405
2406 Builder.SetInsertPoint(Latch->getTerminator());
2407 setDebugLocFromInst(Builder, OldInst);
2408
2409 // Create i+1 and fill the PHINode.
2410 Value *Next = Builder.CreateAdd(Induction, Step, "index.next");
2411 Induction->addIncoming(Start, L->getLoopPreheader());
2412 Induction->addIncoming(Next, Latch);
2413 // Create the compare.
2414 Value *ICmp = Builder.CreateICmpEQ(Next, End);
2415 Builder.CreateCondBr(ICmp, L->getExitBlock(), Header);
2416
2417 // Now we have two terminators. Remove the old one from the block.
2418 Latch->getTerminator()->eraseFromParent();
2419
2420 return Induction;
2421}
2422
2423Value *InnerLoopVectorizer::getOrCreateTripCount(Loop *L) {
2424 if (TripCount)
2425 return TripCount;
2426
2427 assert(L && "Create Trip Count for null loop.")((L && "Create Trip Count for null loop.") ? static_cast
<void> (0) : __assert_fail ("L && \"Create Trip Count for null loop.\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 2427, __PRETTY_FUNCTION__))
;
2428 IRBuilder<> Builder(L->getLoopPreheader()->getTerminator());
2429 // Find the loop boundaries.
2430 ScalarEvolution *SE = PSE.getSE();
2431 const SCEV *BackedgeTakenCount = PSE.getBackedgeTakenCount();
2432 assert(BackedgeTakenCount != SE->getCouldNotCompute() &&((BackedgeTakenCount != SE->getCouldNotCompute() &&
"Invalid loop count") ? static_cast<void> (0) : __assert_fail
("BackedgeTakenCount != SE->getCouldNotCompute() && \"Invalid loop count\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 2433, __PRETTY_FUNCTION__))
2433 "Invalid loop count")((BackedgeTakenCount != SE->getCouldNotCompute() &&
"Invalid loop count") ? static_cast<void> (0) : __assert_fail
("BackedgeTakenCount != SE->getCouldNotCompute() && \"Invalid loop count\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 2433, __PRETTY_FUNCTION__))
;
2434
2435 Type *IdxTy = Legal->getWidestInductionType();
2436 assert(IdxTy && "No type for induction")((IdxTy && "No type for induction") ? static_cast<
void> (0) : __assert_fail ("IdxTy && \"No type for induction\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 2436, __PRETTY_FUNCTION__))
;
2437
2438 // The exit count might have the type of i64 while the phi is i32. This can
2439 // happen if we have an induction variable that is sign extended before the
2440 // compare. The only way that we get a backedge taken count is that the
2441 // induction variable was signed and as such will not overflow. In such a case
2442 // truncation is legal.
2443 if (BackedgeTakenCount->getType()->getPrimitiveSizeInBits() >
2444 IdxTy->getPrimitiveSizeInBits())
2445 BackedgeTakenCount = SE->getTruncateOrNoop(BackedgeTakenCount, IdxTy);
2446 BackedgeTakenCount = SE->getNoopOrZeroExtend(BackedgeTakenCount, IdxTy);
2447
2448 // Get the total trip count from the count by adding 1.
2449 const SCEV *ExitCount = SE->getAddExpr(
2450 BackedgeTakenCount, SE->getOne(BackedgeTakenCount->getType()));
2451
2452 const DataLayout &DL = L->getHeader()->getModule()->getDataLayout();
2453
2454 // Expand the trip count and place the new instructions in the preheader.
2455 // Notice that the pre-header does not change, only the loop body.
2456 SCEVExpander Exp(*SE, DL, "induction");
2457
2458 // Count holds the overall loop count (N).
2459 TripCount = Exp.expandCodeFor(ExitCount, ExitCount->getType(),
2460 L->getLoopPreheader()->getTerminator());
2461
2462 if (TripCount->getType()->isPointerTy())
2463 TripCount =
2464 CastInst::CreatePointerCast(TripCount, IdxTy, "exitcount.ptrcnt.to.int",
2465 L->getLoopPreheader()->getTerminator());
2466
2467 return TripCount;
2468}
2469
2470Value *InnerLoopVectorizer::getOrCreateVectorTripCount(Loop *L) {
2471 if (VectorTripCount)
2472 return VectorTripCount;
2473
2474 Value *TC = getOrCreateTripCount(L);
2475 IRBuilder<> Builder(L->getLoopPreheader()->getTerminator());
2476
2477 Type *Ty = TC->getType();
2478 Constant *Step = ConstantInt::get(Ty, VF * UF);
2479
2480 // If the tail is to be folded by masking, round the number of iterations N
2481 // up to a multiple of Step instead of rounding down. This is done by first
2482 // adding Step-1 and then rounding down. Note that it's ok if this addition
2483 // overflows: the vector induction variable will eventually wrap to zero given
2484 // that it starts at zero and its Step is a power of two; the loop will then
2485 // exit, with the last early-exit vector comparison also producing all-true.
2486 if (Cost->foldTailByMasking()) {
2487 assert(isPowerOf2_32(VF * UF) &&((isPowerOf2_32(VF * UF) && "VF*UF must be a power of 2 when folding tail by masking"
) ? static_cast<void> (0) : __assert_fail ("isPowerOf2_32(VF * UF) && \"VF*UF must be a power of 2 when folding tail by masking\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 2488, __PRETTY_FUNCTION__))
2488 "VF*UF must be a power of 2 when folding tail by masking")((isPowerOf2_32(VF * UF) && "VF*UF must be a power of 2 when folding tail by masking"
) ? static_cast<void> (0) : __assert_fail ("isPowerOf2_32(VF * UF) && \"VF*UF must be a power of 2 when folding tail by masking\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 2488, __PRETTY_FUNCTION__))
;
2489 TC = Builder.CreateAdd(TC, ConstantInt::get(Ty, VF * UF - 1), "n.rnd.up");
2490 }
2491
2492 // Now we need to generate the expression for the part of the loop that the
2493 // vectorized body will execute. This is equal to N - (N % Step) if scalar
2494 // iterations are not required for correctness, or N - Step, otherwise. Step
2495 // is equal to the vectorization factor (number of SIMD elements) times the
2496 // unroll factor (number of SIMD instructions).
2497 Value *R = Builder.CreateURem(TC, Step, "n.mod.vf");
2498
2499 // If there is a non-reversed interleaved group that may speculatively access
2500 // memory out-of-bounds, we need to ensure that there will be at least one
2501 // iteration of the scalar epilogue loop. Thus, if the step evenly divides
2502 // the trip count, we set the remainder to be equal to the step. If the step
2503 // does not evenly divide the trip count, no adjustment is necessary since
2504 // there will already be scalar iterations. Note that the minimum iterations
2505 // check ensures that N >= Step.
2506 if (VF > 1 && Cost->requiresScalarEpilogue()) {
2507 auto *IsZero = Builder.CreateICmpEQ(R, ConstantInt::get(R->getType(), 0));
2508 R = Builder.CreateSelect(IsZero, Step, R);
2509 }
2510
2511 VectorTripCount = Builder.CreateSub(TC, R, "n.vec");
2512
2513 return VectorTripCount;
2514}
2515
2516Value *InnerLoopVectorizer::createBitOrPointerCast(Value *V, VectorType *DstVTy,
2517 const DataLayout &DL) {
2518 // Verify that V is a vector type with same number of elements as DstVTy.
2519 unsigned VF = DstVTy->getNumElements();
2520 VectorType *SrcVecTy = cast<VectorType>(V->getType());
2521 assert((VF == SrcVecTy->getNumElements()) && "Vector dimensions do not match")(((VF == SrcVecTy->getNumElements()) && "Vector dimensions do not match"
) ? static_cast<void> (0) : __assert_fail ("(VF == SrcVecTy->getNumElements()) && \"Vector dimensions do not match\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 2521, __PRETTY_FUNCTION__))
;
2522 Type *SrcElemTy = SrcVecTy->getElementType();
2523 Type *DstElemTy = DstVTy->getElementType();
2524 assert((DL.getTypeSizeInBits(SrcElemTy) == DL.getTypeSizeInBits(DstElemTy)) &&(((DL.getTypeSizeInBits(SrcElemTy) == DL.getTypeSizeInBits(DstElemTy
)) && "Vector elements must have same size") ? static_cast
<void> (0) : __assert_fail ("(DL.getTypeSizeInBits(SrcElemTy) == DL.getTypeSizeInBits(DstElemTy)) && \"Vector elements must have same size\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 2525, __PRETTY_FUNCTION__))
2525 "Vector elements must have same size")(((DL.getTypeSizeInBits(SrcElemTy) == DL.getTypeSizeInBits(DstElemTy
)) && "Vector elements must have same size") ? static_cast
<void> (0) : __assert_fail ("(DL.getTypeSizeInBits(SrcElemTy) == DL.getTypeSizeInBits(DstElemTy)) && \"Vector elements must have same size\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 2525, __PRETTY_FUNCTION__))
;
2526
2527 // Do a direct cast if element types are castable.
2528 if (CastInst::isBitOrNoopPointerCastable(SrcElemTy, DstElemTy, DL)) {
2529 return Builder.CreateBitOrPointerCast(V, DstVTy);
2530 }
2531 // V cannot be directly casted to desired vector type.
2532 // May happen when V is a floating point vector but DstVTy is a vector of
2533 // pointers or vice-versa. Handle this using a two-step bitcast using an
2534 // intermediate Integer type for the bitcast i.e. Ptr <-> Int <-> Float.
2535 assert((DstElemTy->isPointerTy() != SrcElemTy->isPointerTy()) &&(((DstElemTy->isPointerTy() != SrcElemTy->isPointerTy()
) && "Only one type should be a pointer type") ? static_cast
<void> (0) : __assert_fail ("(DstElemTy->isPointerTy() != SrcElemTy->isPointerTy()) && \"Only one type should be a pointer type\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 2536, __PRETTY_FUNCTION__))
2536 "Only one type should be a pointer type")(((DstElemTy->isPointerTy() != SrcElemTy->isPointerTy()
) && "Only one type should be a pointer type") ? static_cast
<void> (0) : __assert_fail ("(DstElemTy->isPointerTy() != SrcElemTy->isPointerTy()) && \"Only one type should be a pointer type\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 2536, __PRETTY_FUNCTION__))
;
2537 assert((DstElemTy->isFloatingPointTy() != SrcElemTy->isFloatingPointTy()) &&(((DstElemTy->isFloatingPointTy() != SrcElemTy->isFloatingPointTy
()) && "Only one type should be a floating point type"
) ? static_cast<void> (0) : __assert_fail ("(DstElemTy->isFloatingPointTy() != SrcElemTy->isFloatingPointTy()) && \"Only one type should be a floating point type\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 2538, __PRETTY_FUNCTION__))
2538 "Only one type should be a floating point type")(((DstElemTy->isFloatingPointTy() != SrcElemTy->isFloatingPointTy
()) && "Only one type should be a floating point type"
) ? static_cast<void> (0) : __assert_fail ("(DstElemTy->isFloatingPointTy() != SrcElemTy->isFloatingPointTy()) && \"Only one type should be a floating point type\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 2538, __PRETTY_FUNCTION__))
;
2539 Type *IntTy =
2540 IntegerType::getIntNTy(V->getContext(), DL.getTypeSizeInBits(SrcElemTy));
2541 VectorType *VecIntTy = VectorType::get(IntTy, VF);
2542 Value *CastVal = Builder.CreateBitOrPointerCast(V, VecIntTy);
2543 return Builder.CreateBitOrPointerCast(CastVal, DstVTy);
2544}
2545
2546void InnerLoopVectorizer::emitMinimumIterationCountCheck(Loop *L,
2547 BasicBlock *Bypass) {
2548 Value *Count = getOrCreateTripCount(L);
2549 BasicBlock *BB = L->getLoopPreheader();
2550 IRBuilder<> Builder(BB->getTerminator());
2551
2552 // Generate code to check if the loop's trip count is less than VF * UF, or
2553 // equal to it in case a scalar epilogue is required; this implies that the
2554 // vector trip count is zero. This check also covers the case where adding one
2555 // to the backedge-taken count overflowed leading to an incorrect trip count
2556 // of zero. In this case we will also jump to the scalar loop.
2557 auto P = Cost->requiresScalarEpilogue() ? ICmpInst::ICMP_ULE
2558 : ICmpInst::ICMP_ULT;
2559
2560 // If tail is to be folded, vector loop takes care of all iterations.
2561 Value *CheckMinIters = Builder.getFalse();
2562 if (!Cost->foldTailByMasking())
2563 CheckMinIters = Builder.CreateICmp(
2564 P, Count, ConstantInt::get(Count->getType(), VF * UF),
2565 "min.iters.check");
2566
2567 BasicBlock *NewBB = BB->splitBasicBlock(BB->getTerminator(), "vector.ph");
2568 // Update dominator tree immediately if the generated block is a
2569 // LoopBypassBlock because SCEV expansions to generate loop bypass
2570 // checks may query it before the current function is finished.
2571 DT->addNewBlock(NewBB, BB);
2572 if (L->getParentLoop())
2573 L->getParentLoop()->addBasicBlockToLoop(NewBB, *LI);
2574 ReplaceInstWithInst(BB->getTerminator(),
2575 BranchInst::Create(Bypass, NewBB, CheckMinIters));
2576 LoopBypassBlocks.push_back(BB);
2577}
2578
2579void InnerLoopVectorizer::emitSCEVChecks(Loop *L, BasicBlock *Bypass) {
2580 BasicBlock *BB = L->getLoopPreheader();
2581
2582 // Generate the code to check that the SCEV assumptions that we made.
2583 // We want the new basic block to start at the first instruction in a
2584 // sequence of instructions that form a check.
2585 SCEVExpander Exp(*PSE.getSE(), Bypass->getModule()->getDataLayout(),
2586 "scev.check");
2587 Value *SCEVCheck =
2588 Exp.expandCodeForPredicate(&PSE.getUnionPredicate(), BB->getTerminator());
2589
2590 if (auto *C = dyn_cast<ConstantInt>(SCEVCheck))
2591 if (C->isZero())
2592 return;
2593
2594 assert(!Cost->foldTailByMasking() &&((!Cost->foldTailByMasking() && "Cannot SCEV check stride or overflow when folding tail"
) ? static_cast<void> (0) : __assert_fail ("!Cost->foldTailByMasking() && \"Cannot SCEV check stride or overflow when folding tail\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 2595, __PRETTY_FUNCTION__))
2595 "Cannot SCEV check stride or overflow when folding tail")((!Cost->foldTailByMasking() && "Cannot SCEV check stride or overflow when folding tail"
) ? static_cast<void> (0) : __assert_fail ("!Cost->foldTailByMasking() && \"Cannot SCEV check stride or overflow when folding tail\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 2595, __PRETTY_FUNCTION__))
;
2596 // Create a new block containing the stride check.
2597 BB->setName("vector.scevcheck");
2598 auto *NewBB = BB->splitBasicBlock(BB->getTerminator(), "vector.ph");
2599 // Update dominator tree immediately if the generated block is a
2600 // LoopBypassBlock because SCEV expansions to generate loop bypass
2601 // checks may query it before the current function is finished.
2602 DT->addNewBlock(NewBB, BB);
2603 if (L->getParentLoop())
2604 L->getParentLoop()->addBasicBlockToLoop(NewBB, *LI);
2605 ReplaceInstWithInst(BB->getTerminator(),
2606 BranchInst::Create(Bypass, NewBB, SCEVCheck));
2607 LoopBypassBlocks.push_back(BB);
2608 AddedSafetyChecks = true;
2609}
2610
2611void InnerLoopVectorizer::emitMemRuntimeChecks(Loop *L, BasicBlock *Bypass) {
2612 // VPlan-native path does not do any analysis for runtime checks currently.
2613 if (EnableVPlanNativePath)
2614 return;
2615
2616 BasicBlock *BB = L->getLoopPreheader();
2617
2618 // Generate the code that checks in runtime if arrays overlap. We put the
2619 // checks into a separate block to make the more common case of few elements
2620 // faster.
2621 Instruction *FirstCheckInst;
2622 Instruction *MemRuntimeCheck;
2623 std::tie(FirstCheckInst, MemRuntimeCheck) =
2624 Legal->getLAI()->addRuntimeChecks(BB->getTerminator());
2625 if (!MemRuntimeCheck)
2626 return;
2627
2628 assert(!Cost->foldTailByMasking() && "Cannot check memory when folding tail")((!Cost->foldTailByMasking() && "Cannot check memory when folding tail"
) ? static_cast<void> (0) : __assert_fail ("!Cost->foldTailByMasking() && \"Cannot check memory when folding tail\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 2628, __PRETTY_FUNCTION__))
;
2629 // Create a new block containing the memory check.
2630 BB->setName("vector.memcheck");
2631 auto *NewBB = BB->splitBasicBlock(BB->getTerminator(), "vector.ph");
2632 // Update dominator tree immediately if the generated block is a
2633 // LoopBypassBlock because SCEV expansions to generate loop bypass
2634 // checks may query it before the current function is finished.
2635 DT->addNewBlock(NewBB, BB);
2636 if (L->getParentLoop())
2637 L->getParentLoop()->addBasicBlockToLoop(NewBB, *LI);
2638 ReplaceInstWithInst(BB->getTerminator(),
2639 BranchInst::Create(Bypass, NewBB, MemRuntimeCheck));
2640 LoopBypassBlocks.push_back(BB);
2641 AddedSafetyChecks = true;
2642
2643 // We currently don't use LoopVersioning for the actual loop cloning but we
2644 // still use it to add the noalias metadata.
2645 LVer = llvm::make_unique<LoopVersioning>(*Legal->getLAI(), OrigLoop, LI, DT,
2646 PSE.getSE());
2647 LVer->prepareNoAliasMetadata();
2648}
2649
2650Value *InnerLoopVectorizer::emitTransformedIndex(
2651 IRBuilder<> &B, Value *Index, ScalarEvolution *SE, const DataLayout &DL,
2652 const InductionDescriptor &ID) const {
2653
2654 SCEVExpander Exp(*SE, DL, "induction");
2655 auto Step = ID.getStep();
2656 auto StartValue = ID.getStartValue();
2657 assert(Index->getType() == Step->getType() &&((Index->getType() == Step->getType() && "Index type does not match StepValue type"
) ? static_cast<void> (0) : __assert_fail ("Index->getType() == Step->getType() && \"Index type does not match StepValue type\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 2658, __PRETTY_FUNCTION__))
2658 "Index type does not match StepValue type")((Index->getType() == Step->getType() && "Index type does not match StepValue type"
) ? static_cast<void> (0) : __assert_fail ("Index->getType() == Step->getType() && \"Index type does not match StepValue type\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 2658, __PRETTY_FUNCTION__))
;
2659
2660 // Note: the IR at this point is broken. We cannot use SE to create any new
2661 // SCEV and then expand it, hoping that SCEV's simplification will give us
2662 // a more optimal code. Unfortunately, attempt of doing so on invalid IR may
2663 // lead to various SCEV crashes. So all we can do is to use builder and rely
2664 // on InstCombine for future simplifications. Here we handle some trivial
2665 // cases only.
2666 auto CreateAdd = [&B](Value *X, Value *Y) {
2667 assert(X->getType() == Y->getType() && "Types don't match!")((X->getType() == Y->getType() && "Types don't match!"
) ? static_cast<void> (0) : __assert_fail ("X->getType() == Y->getType() && \"Types don't match!\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 2667, __PRETTY_FUNCTION__))
;
2668 if (auto *CX = dyn_cast<ConstantInt>(X))
2669 if (CX->isZero())
2670 return Y;
2671 if (auto *CY = dyn_cast<ConstantInt>(Y))
2672 if (CY->isZero())
2673 return X;
2674 return B.CreateAdd(X, Y);
2675 };
2676
2677 auto CreateMul = [&B](Value *X, Value *Y) {
2678 assert(X->getType() == Y->getType() && "Types don't match!")((X->getType() == Y->getType() && "Types don't match!"
) ? static_cast<void> (0) : __assert_fail ("X->getType() == Y->getType() && \"Types don't match!\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 2678, __PRETTY_FUNCTION__))
;
2679 if (auto *CX = dyn_cast<ConstantInt>(X))
2680 if (CX->isOne())
2681 return Y;
2682 if (auto *CY = dyn_cast<ConstantInt>(Y))
2683 if (CY->isOne())
2684 return X;
2685 return B.CreateMul(X, Y);
2686 };
2687
2688 switch (ID.getKind()) {
2689 case InductionDescriptor::IK_IntInduction: {
2690 assert(Index->getType() == StartValue->getType() &&((Index->getType() == StartValue->getType() && "Index type does not match StartValue type"
) ? static_cast<void> (0) : __assert_fail ("Index->getType() == StartValue->getType() && \"Index type does not match StartValue type\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 2691, __PRETTY_FUNCTION__))
2691 "Index type does not match StartValue type")((Index->getType() == StartValue->getType() && "Index type does not match StartValue type"
) ? static_cast<void> (0) : __assert_fail ("Index->getType() == StartValue->getType() && \"Index type does not match StartValue type\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 2691, __PRETTY_FUNCTION__))
;
2692 if (ID.getConstIntStepValue() && ID.getConstIntStepValue()->isMinusOne())
2693 return B.CreateSub(StartValue, Index);
2694 auto *Offset = CreateMul(
2695 Index, Exp.expandCodeFor(Step, Index->getType(), &*B.GetInsertPoint()));
2696 return CreateAdd(StartValue, Offset);
2697 }
2698 case InductionDescriptor::IK_PtrInduction: {
2699 assert(isa<SCEVConstant>(Step) &&((isa<SCEVConstant>(Step) && "Expected constant step for pointer induction"
) ? static_cast<void> (0) : __assert_fail ("isa<SCEVConstant>(Step) && \"Expected constant step for pointer induction\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 2700, __PRETTY_FUNCTION__))
2700 "Expected constant step for pointer induction")((isa<SCEVConstant>(Step) && "Expected constant step for pointer induction"
) ? static_cast<void> (0) : __assert_fail ("isa<SCEVConstant>(Step) && \"Expected constant step for pointer induction\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 2700, __PRETTY_FUNCTION__))
;
2701 return B.CreateGEP(
2702 StartValue->getType()->getPointerElementType(), StartValue,
2703 CreateMul(Index, Exp.expandCodeFor(Step, Index->getType(),
2704 &*B.GetInsertPoint())));
2705 }
2706 case InductionDescriptor::IK_FpInduction: {
2707 assert(Step->getType()->isFloatingPointTy() && "Expected FP Step value")((Step->getType()->isFloatingPointTy() && "Expected FP Step value"
) ? static_cast<void> (0) : __assert_fail ("Step->getType()->isFloatingPointTy() && \"Expected FP Step value\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 2707, __PRETTY_FUNCTION__))
;
2708 auto InductionBinOp = ID.getInductionBinOp();
2709 assert(InductionBinOp &&((InductionBinOp && (InductionBinOp->getOpcode() ==
Instruction::FAdd || InductionBinOp->getOpcode() == Instruction
::FSub) && "Original bin op should be defined for FP induction"
) ? static_cast<void> (0) : __assert_fail ("InductionBinOp && (InductionBinOp->getOpcode() == Instruction::FAdd || InductionBinOp->getOpcode() == Instruction::FSub) && \"Original bin op should be defined for FP induction\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 2712, __PRETTY_FUNCTION__))
2710 (InductionBinOp->getOpcode() == Instruction::FAdd ||((InductionBinOp && (InductionBinOp->getOpcode() ==
Instruction::FAdd || InductionBinOp->getOpcode() == Instruction
::FSub) && "Original bin op should be defined for FP induction"
) ? static_cast<void> (0) : __assert_fail ("InductionBinOp && (InductionBinOp->getOpcode() == Instruction::FAdd || InductionBinOp->getOpcode() == Instruction::FSub) && \"Original bin op should be defined for FP induction\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 2712, __PRETTY_FUNCTION__))
2711 InductionBinOp->getOpcode() == Instruction::FSub) &&((InductionBinOp && (InductionBinOp->getOpcode() ==
Instruction::FAdd || InductionBinOp->getOpcode() == Instruction
::FSub) && "Original bin op should be defined for FP induction"
) ? static_cast<void> (0) : __assert_fail ("InductionBinOp && (InductionBinOp->getOpcode() == Instruction::FAdd || InductionBinOp->getOpcode() == Instruction::FSub) && \"Original bin op should be defined for FP induction\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 2712, __PRETTY_FUNCTION__))
2712 "Original bin op should be defined for FP induction")((InductionBinOp && (InductionBinOp->getOpcode() ==
Instruction::FAdd || InductionBinOp->getOpcode() == Instruction
::FSub) && "Original bin op should be defined for FP induction"
) ? static_cast<void> (0) : __assert_fail ("InductionBinOp && (InductionBinOp->getOpcode() == Instruction::FAdd || InductionBinOp->getOpcode() == Instruction::FSub) && \"Original bin op should be defined for FP induction\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 2712, __PRETTY_FUNCTION__))
;
2713
2714 Value *StepValue = cast<SCEVUnknown>(Step)->getValue();
2715
2716 // Floating point operations had to be 'fast' to enable the induction.
2717 FastMathFlags Flags;
2718 Flags.setFast();
2719
2720 Value *MulExp = B.CreateFMul(StepValue, Index);
2721 if (isa<Instruction>(MulExp))
2722 // We have to check, the MulExp may be a constant.
2723 cast<Instruction>(MulExp)->setFastMathFlags(Flags);
2724
2725 Value *BOp = B.CreateBinOp(InductionBinOp->getOpcode(), StartValue, MulExp,
2726 "induction");
2727 if (isa<Instruction>(BOp))
2728 cast<Instruction>(BOp)->setFastMathFlags(Flags);
2729
2730 return BOp;
2731 }
2732 case InductionDescriptor::IK_NoInduction:
2733 return nullptr;
2734 }
2735 llvm_unreachable("invalid enum")::llvm::llvm_unreachable_internal("invalid enum", "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 2735)
;
2736}
2737
2738BasicBlock *InnerLoopVectorizer::createVectorizedLoopSkeleton() {
2739 /*
2740 In this function we generate a new loop. The new loop will contain
2741 the vectorized instructions while the old loop will continue to run the
2742 scalar remainder.
2743
2744 [ ] <-- loop iteration number check.
2745 / |
2746 / v
2747 | [ ] <-- vector loop bypass (may consist of multiple blocks).
2748 | / |
2749 | / v
2750 || [ ] <-- vector pre header.
2751 |/ |
2752 | v
2753 | [ ] \
2754 | [ ]_| <-- vector loop.
2755 | |
2756 | v
2757 | -[ ] <--- middle-block.
2758 | / |
2759 | / v
2760 -|- >[ ] <--- new preheader.
2761 | |
2762 | v
2763 | [ ] \
2764 | [ ]_| <-- old scalar loop to handle remainder.
2765 \ |
2766 \ v
2767 >[ ] <-- exit block.
2768 ...
2769 */
2770
2771 BasicBlock *OldBasicBlock = OrigLoop->getHeader();
2772 BasicBlock *VectorPH = OrigLoop->getLoopPreheader();
2773 BasicBlock *ExitBlock = OrigLoop->getExitBlock();
2774 MDNode *OrigLoopID = OrigLoop->getLoopID();
2775 assert(VectorPH && "Invalid loop structure")((VectorPH && "Invalid loop structure") ? static_cast
<void> (0) : __assert_fail ("VectorPH && \"Invalid loop structure\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 2775, __PRETTY_FUNCTION__))
;
2776 assert(ExitBlock && "Must have an exit block")((ExitBlock && "Must have an exit block") ? static_cast
<void> (0) : __assert_fail ("ExitBlock && \"Must have an exit block\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 2776, __PRETTY_FUNCTION__))
;
2777
2778 // Some loops have a single integer induction variable, while other loops
2779 // don't. One example is c++ iterators that often have multiple pointer
2780 // induction variables. In the code below we also support a case where we
2781 // don't have a single induction variable.
2782 //
2783 // We try to obtain an induction variable from the original loop as hard
2784 // as possible. However if we don't find one that:
2785 // - is an integer
2786 // - counts from zero, stepping by one
2787 // - is the size of the widest induction variable type
2788 // then we create a new one.
2789 OldInduction = Legal->getPrimaryInduction();
2790 Type *IdxTy = Legal->getWidestInductionType();
2791
2792 // Split the single block loop into the two loop structure described above.
2793 BasicBlock *VecBody =
2794 VectorPH->splitBasicBlock(VectorPH->getTerminator(), "vector.body");
2795 BasicBlock *MiddleBlock =
2796 VecBody->splitBasicBlock(VecBody->getTerminator(), "middle.block");
2797 BasicBlock *ScalarPH =
2798 MiddleBlock->splitBasicBlock(MiddleBlock->getTerminator(), "scalar.ph");
2799
2800 // Create and register the new vector loop.
2801 Loop *Lp = LI->AllocateLoop();
2802 Loop *ParentLoop = OrigLoop->getParentLoop();
2803
2804 // Insert the new loop into the loop nest and register the new basic blocks
2805 // before calling any utilities such as SCEV that require valid LoopInfo.
2806 if (ParentLoop) {
2807 ParentLoop->addChildLoop(Lp);
2808 ParentLoop->addBasicBlockToLoop(ScalarPH, *LI);
2809 ParentLoop->addBasicBlockToLoop(MiddleBlock, *LI);
2810 } else {
2811 LI->addTopLevelLoop(Lp);
2812 }
2813 Lp->addBasicBlockToLoop(VecBody, *LI);
2814
2815 // Find the loop boundaries.
2816 Value *Count = getOrCreateTripCount(Lp);
2817
2818 Value *StartIdx = ConstantInt::get(IdxTy, 0);
2819
2820 // Now, compare the new count to zero. If it is zero skip the vector loop and
2821 // jump to the scalar loop. This check also covers the case where the
2822 // backedge-taken count is uint##_max: adding one to it will overflow leading
2823 // to an incorrect trip count of zero. In this (rare) case we will also jump
2824 // to the scalar loop.
2825 emitMinimumIterationCountCheck(Lp, ScalarPH);
2826
2827 // Generate the code to check any assumptions that we've made for SCEV
2828 // expressions.
2829 emitSCEVChecks(Lp, ScalarPH);
2830
2831 // Generate the code that checks in runtime if arrays overlap. We put the
2832 // checks into a separate block to make the more common case of few elements
2833 // faster.
2834 emitMemRuntimeChecks(Lp, ScalarPH);
2835
2836 // Generate the induction variable.
2837 // The loop step is equal to the vectorization factor (num of SIMD elements)
2838 // times the unroll factor (num of SIMD instructions).
2839 Value *CountRoundDown = getOrCreateVectorTripCount(Lp);
2840 Constant *Step = ConstantInt::get(IdxTy, VF * UF);
2841 Induction =
2842 createInductionVariable(Lp, StartIdx, CountRoundDown, Step,
2843 getDebugLocFromInstOrOperands(OldInduction));
2844
2845 // We are going to resume the execution of the scalar loop.
2846 // Go over all of the induction variables that we found and fix the
2847 // PHIs that are left in the scalar version of the loop.
2848 // The starting values of PHI nodes depend on the counter of the last
2849 // iteration in the vectorized loop.
2850 // If we come from a bypass edge then we need to start from the original
2851 // start value.
2852
2853 // This variable saves the new starting index for the scalar loop. It is used
2854 // to test if there are any tail iterations left once the vector loop has
2855 // completed.
2856 LoopVectorizationLegality::InductionList *List = Legal->getInductionVars();
2857 for (auto &InductionEntry : *List) {
2858 PHINode *OrigPhi = InductionEntry.first;
2859 InductionDescriptor II = InductionEntry.second;
2860
2861 // Create phi nodes to merge from the backedge-taken check block.
2862 PHINode *BCResumeVal = PHINode::Create(
2863 OrigPhi->getType(), 3, "bc.resume.val", ScalarPH->getTerminator());
2864 // Copy original phi DL over to the new one.
2865 BCResumeVal->setDebugLoc(OrigPhi->getDebugLoc());
2866 Value *&EndValue = IVEndValues[OrigPhi];
2867 if (OrigPhi == OldInduction) {
2868 // We know what the end value is.
2869 EndValue = CountRoundDown;
2870 } else {
2871 IRBuilder<> B(Lp->getLoopPreheader()->getTerminator());
2872 Type *StepType = II.getStep()->getType();
2873 Instruction::CastOps CastOp =
2874 CastInst::getCastOpcode(CountRoundDown, true, StepType, true);
2875 Value *CRD = B.CreateCast(CastOp, CountRoundDown, StepType, "cast.crd");
2876 const DataLayout &DL = OrigLoop->getHeader()->getModule()->getDataLayout();
2877 EndValue = emitTransformedIndex(B, CRD, PSE.getSE(), DL, II);
2878 EndValue->setName("ind.end");
2879 }
2880
2881 // The new PHI merges the original incoming value, in case of a bypass,
2882 // or the value at the end of the vectorized loop.
2883 BCResumeVal->addIncoming(EndValue, MiddleBlock);
2884
2885 // Fix the scalar body counter (PHI node).
2886 unsigned BlockIdx = OrigPhi->getBasicBlockIndex(ScalarPH);
2887
2888 // The old induction's phi node in the scalar body needs the truncated
2889 // value.
2890 for (BasicBlock *BB : LoopBypassBlocks)
2891 BCResumeVal->addIncoming(II.getStartValue(), BB);
2892 OrigPhi->setIncomingValue(BlockIdx, BCResumeVal);
2893 }
2894
2895 // We need the OrigLoop (scalar loop part) latch terminator to help
2896 // produce correct debug info for the middle block BB instructions.
2897 // The legality check stage guarantees that the loop will have a single
2898 // latch.
2899 assert(isa<BranchInst>(OrigLoop->getLoopLatch()->getTerminator()) &&((isa<BranchInst>(OrigLoop->getLoopLatch()->getTerminator
()) && "Scalar loop latch terminator isn't a branch")
? static_cast<void> (0) : __assert_fail ("isa<BranchInst>(OrigLoop->getLoopLatch()->getTerminator()) && \"Scalar loop latch terminator isn't a branch\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 2900, __PRETTY_FUNCTION__))
2900 "Scalar loop latch terminator isn't a branch")((isa<BranchInst>(OrigLoop->getLoopLatch()->getTerminator
()) && "Scalar loop latch terminator isn't a branch")
? static_cast<void> (0) : __assert_fail ("isa<BranchInst>(OrigLoop->getLoopLatch()->getTerminator()) && \"Scalar loop latch terminator isn't a branch\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 2900, __PRETTY_FUNCTION__))
;
2901 BranchInst *ScalarLatchBr =
2902 cast<BranchInst>(OrigLoop->getLoopLatch()->getTerminator());
2903
2904 // Add a check in the middle block to see if we have completed
2905 // all of the iterations in the first vector loop.
2906 // If (N - N%VF) == N, then we *don't* need to run the remainder.
2907 // If tail is to be folded, we know we don't need to run the remainder.
2908 Value *CmpN = Builder.getTrue();
2909 if (!Cost->foldTailByMasking()) {
2910 CmpN =
2911 CmpInst::Create(Instruction::ICmp, CmpInst::ICMP_EQ, Count,
2912 CountRoundDown, "cmp.n", MiddleBlock->getTerminator());
2913
2914 // Provide correct stepping behaviour by using the same DebugLoc as the
2915 // scalar loop latch branch cmp if it exists.
2916 if (CmpInst *ScalarLatchCmp =
2917 dyn_cast_or_null<CmpInst>(ScalarLatchBr->getCondition()))
2918 cast<Instruction>(CmpN)->setDebugLoc(ScalarLatchCmp->getDebugLoc());
2919 }
2920
2921 BranchInst *BrInst = BranchInst::Create(ExitBlock, ScalarPH, CmpN);
2922 BrInst->setDebugLoc(ScalarLatchBr->getDebugLoc());
2923 ReplaceInstWithInst(MiddleBlock->getTerminator(), BrInst);
2924
2925 // Get ready to start creating new instructions into the vectorized body.
2926 Builder.SetInsertPoint(&*VecBody->getFirstInsertionPt());
2927
2928 // Save the state.
2929 LoopVectorPreHeader = Lp->getLoopPreheader();
2930 LoopScalarPreHeader = ScalarPH;
2931 LoopMiddleBlock = MiddleBlock;
2932 LoopExitBlock = ExitBlock;
2933 LoopVectorBody = VecBody;
2934 LoopScalarBody = OldBasicBlock;
2935
2936 Optional<MDNode *> VectorizedLoopID =
2937 makeFollowupLoopID(OrigLoopID, {LLVMLoopVectorizeFollowupAll,
2938 LLVMLoopVectorizeFollowupVectorized});
2939 if (VectorizedLoopID.hasValue()) {
2940 Lp->setLoopID(VectorizedLoopID.getValue());
2941
2942 // Do not setAlreadyVectorized if loop attributes have been defined
2943 // explicitly.
2944 return LoopVectorPreHeader;
2945 }
2946
2947 // Keep all loop hints from the original loop on the vector loop (we'll
2948 // replace the vectorizer-specific hints below).
2949 if (MDNode *LID = OrigLoop->getLoopID())
2950 Lp->setLoopID(LID);
2951
2952 LoopVectorizeHints Hints(Lp, true, *ORE);
2953 Hints.setAlreadyVectorized();
2954
2955 return LoopVectorPreHeader;
2956}
2957
2958// Fix up external users of the induction variable. At this point, we are
2959// in LCSSA form, with all external PHIs that use the IV having one input value,
2960// coming from the remainder loop. We need those PHIs to also have a correct
2961// value for the IV when arriving directly from the middle block.
2962void InnerLoopVectorizer::fixupIVUsers(PHINode *OrigPhi,
2963 const InductionDescriptor &II,
2964 Value *CountRoundDown, Value *EndValue,
2965 BasicBlock *MiddleBlock) {
2966 // There are two kinds of external IV usages - those that use the value
2967 // computed in the last iteration (the PHI) and those that use the penultimate
2968 // value (the value that feeds into the phi from the loop latch).
2969 // We allow both, but they, obviously, have different values.
2970
2971 assert(OrigLoop->getExitBlock() && "Expected a single exit block")((OrigLoop->getExitBlock() && "Expected a single exit block"
) ? static_cast<void> (0) : __assert_fail ("OrigLoop->getExitBlock() && \"Expected a single exit block\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 2971, __PRETTY_FUNCTION__))
;
2972
2973 DenseMap<Value *, Value *> MissingVals;
2974
2975 // An external user of the last iteration's value should see the value that
2976 // the remainder loop uses to initialize its own IV.
2977 Value *PostInc = OrigPhi->getIncomingValueForBlock(OrigLoop->getLoopLatch());
2978 for (User *U : PostInc->users()) {
2979 Instruction *UI = cast<Instruction>(U);
2980 if (!OrigLoop->contains(UI)) {
2981 assert(isa<PHINode>(UI) && "Expected LCSSA form")((isa<PHINode>(UI) && "Expected LCSSA form") ? static_cast
<void> (0) : __assert_fail ("isa<PHINode>(UI) && \"Expected LCSSA form\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 2981, __PRETTY_FUNCTION__))
;
2982 MissingVals[UI] = EndValue;
2983 }
2984 }
2985
2986 // An external user of the penultimate value need to see EndValue - Step.
2987 // The simplest way to get this is to recompute it from the constituent SCEVs,
2988 // that is Start + (Step * (CRD - 1)).
2989 for (User *U : OrigPhi->users()) {
2990 auto *UI = cast<Instruction>(U);
2991 if (!OrigLoop->contains(UI)) {
2992 const DataLayout &DL =
2993 OrigLoop->getHeader()->getModule()->getDataLayout();
2994 assert(isa<PHINode>(UI) && "Expected LCSSA form")((isa<PHINode>(UI) && "Expected LCSSA form") ? static_cast
<void> (0) : __assert_fail ("isa<PHINode>(UI) && \"Expected LCSSA form\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 2994, __PRETTY_FUNCTION__))
;
2995
2996 IRBuilder<> B(MiddleBlock->getTerminator());
2997 Value *CountMinusOne = B.CreateSub(
2998 CountRoundDown, ConstantInt::get(CountRoundDown->getType(), 1));
2999 Value *CMO =
3000 !II.getStep()->getType()->isIntegerTy()
3001 ? B.CreateCast(Instruction::SIToFP, CountMinusOne,
3002 II.getStep()->getType())
3003 : B.CreateSExtOrTrunc(CountMinusOne, II.getStep()->getType());
3004 CMO->setName("cast.cmo");
3005 Value *Escape = emitTransformedIndex(B, CMO, PSE.getSE(), DL, II);
3006 Escape->setName("ind.escape");
3007 MissingVals[UI] = Escape;
3008 }
3009 }
3010
3011 for (auto &I : MissingVals) {
3012 PHINode *PHI = cast<PHINode>(I.first);
3013 // One corner case we have to handle is two IVs "chasing" each-other,
3014 // that is %IV2 = phi [...], [ %IV1, %latch ]
3015 // In this case, if IV1 has an external use, we need to avoid adding both
3016 // "last value of IV1" and "penultimate value of IV2". So, verify that we
3017 // don't already have an incoming value for the middle block.
3018 if (PHI->getBasicBlockIndex(MiddleBlock) == -1)
3019 PHI->addIncoming(I.second, MiddleBlock);
3020 }
3021}
3022
3023namespace {
3024
3025struct CSEDenseMapInfo {
3026 static bool canHandle(const Instruction *I) {
3027 return isa<InsertElementInst>(I) || isa<ExtractElementInst>(I) ||
3028 isa<ShuffleVectorInst>(I) || isa<GetElementPtrInst>(I);
3029 }
3030
3031 static inline Instruction *getEmptyKey() {
3032 return DenseMapInfo<Instruction *>::getEmptyKey();
3033 }
3034
3035 static inline Instruction *getTombstoneKey() {
3036 return DenseMapInfo<Instruction *>::getTombstoneKey();
3037 }
3038
3039 static unsigned getHashValue(const Instruction *I) {
3040 assert(canHandle(I) && "Unknown instruction!")((canHandle(I) && "Unknown instruction!") ? static_cast
<void> (0) : __assert_fail ("canHandle(I) && \"Unknown instruction!\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 3040, __PRETTY_FUNCTION__))
;
3041 return hash_combine(I->getOpcode(), hash_combine_range(I->value_op_begin(),
3042 I->value_op_end()));
3043 }
3044
3045 static bool isEqual(const Instruction *LHS, const Instruction *RHS) {
3046 if (LHS == getEmptyKey() || RHS == getEmptyKey() ||
3047 LHS == getTombstoneKey() || RHS == getTombstoneKey())
3048 return LHS == RHS;
3049 return LHS->isIdenticalTo(RHS);
3050 }
3051};
3052
3053} // end anonymous namespace
3054
3055///Perform cse of induction variable instructions.
3056static void cse(BasicBlock *BB) {
3057 // Perform simple cse.
3058 SmallDenseMap<Instruction *, Instruction *, 4, CSEDenseMapInfo> CSEMap;
3059 for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E;) {
3060 Instruction *In = &*I++;
3061
3062 if (!CSEDenseMapInfo::canHandle(In))
3063 continue;
3064
3065 // Check if we can replace this instruction with any of the
3066 // visited instructions.
3067 if (Instruction *V = CSEMap.lookup(In)) {
3068 In->replaceAllUsesWith(V);
3069 In->eraseFromParent();
3070 continue;
3071 }
3072
3073 CSEMap[In] = In;
3074 }
3075}
3076
3077unsigned LoopVectorizationCostModel::getVectorCallCost(CallInst *CI,
3078 unsigned VF,
3079 bool &NeedToScalarize) {
3080 Function *F = CI->getCalledFunction();
3081 StringRef FnName = CI->getCalledFunction()->getName();
3082 Type *ScalarRetTy = CI->getType();
3083 SmallVector<Type *, 4> Tys, ScalarTys;
3084 for (auto &ArgOp : CI->arg_operands())
3085 ScalarTys.push_back(ArgOp->getType());
3086
3087 // Estimate cost of scalarized vector call. The source operands are assumed
3088 // to be vectors, so we need to extract individual elements from there,
3089 // execute VF scalar calls, and then gather the result into the vector return
3090 // value.
3091 unsigned ScalarCallCost = TTI.getCallInstrCost(F, ScalarRetTy, ScalarTys);
3092 if (VF == 1)
3093 return ScalarCallCost;
3094
3095 // Compute corresponding vector type for return value and arguments.
3096 Type *RetTy = ToVectorTy(ScalarRetTy, VF);
3097 for (Type *ScalarTy : ScalarTys)
3098 Tys.push_back(ToVectorTy(ScalarTy, VF));
3099
3100 // Compute costs of unpacking argument values for the scalar calls and
3101 // packing the return values to a vector.
3102 unsigned ScalarizationCost = getScalarizationOverhead(CI, VF);
3103
3104 unsigned Cost = ScalarCallCost * VF + ScalarizationCost;
3105
3106 // If we can't emit a vector call for this function, then the currently found
3107 // cost is the cost we need to return.
3108 NeedToScalarize = true;
3109 if (!TLI || !TLI->isFunctionVectorizable(FnName, VF) || CI->isNoBuiltin())
3110 return Cost;
3111
3112 // If the corresponding vector cost is cheaper, return its cost.
3113 unsigned VectorCallCost = TTI.getCallInstrCost(nullptr, RetTy, Tys);
3114 if (VectorCallCost < Cost) {
3115 NeedToScalarize = false;
3116 return VectorCallCost;
3117 }
3118 return Cost;
3119}
3120
3121unsigned LoopVectorizationCostModel::getVectorIntrinsicCost(CallInst *CI,
3122 unsigned VF) {
3123 Intrinsic::ID ID = getVectorIntrinsicIDForCall(CI, TLI);
3124 assert(ID && "Expected intrinsic call!")((ID && "Expected intrinsic call!") ? static_cast<
void> (0) : __assert_fail ("ID && \"Expected intrinsic call!\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 3124, __PRETTY_FUNCTION__))
;
3125
3126 FastMathFlags FMF;
3127 if (auto *FPMO = dyn_cast<FPMathOperator>(CI))
3128 FMF = FPMO->getFastMathFlags();
3129
3130 SmallVector<Value *, 4> Operands(CI->arg_operands());
3131 return TTI.getIntrinsicInstrCost(ID, CI->getType(), Operands, FMF, VF);
3132}
3133
3134static Type *smallestIntegerVectorType(Type *T1, Type *T2) {
3135 auto *I1 = cast<IntegerType>(T1->getVectorElementType());
3136 auto *I2 = cast<IntegerType>(T2->getVectorElementType());
3137 return I1->getBitWidth() < I2->getBitWidth() ? T1 : T2;
3138}
3139static Type *largestIntegerVectorType(Type *T1, Type *T2) {
3140 auto *I1 = cast<IntegerType>(T1->getVectorElementType());
3141 auto *I2 = cast<IntegerType>(T2->getVectorElementType());
3142 return I1->getBitWidth() > I2->getBitWidth() ? T1 : T2;
3143}
3144
3145void InnerLoopVectorizer::truncateToMinimalBitwidths() {
3146 // For every instruction `I` in MinBWs, truncate the operands, create a
3147 // truncated version of `I` and reextend its result. InstCombine runs
3148 // later and will remove any ext/trunc pairs.
3149 SmallPtrSet<Value *, 4> Erased;
3150 for (const auto &KV : Cost->getMinimalBitwidths()) {
3151 // If the value wasn't vectorized, we must maintain the original scalar
3152 // type. The absence of the value from VectorLoopValueMap indicates that it
3153 // wasn't vectorized.
3154 if (!VectorLoopValueMap.hasAnyVectorValue(KV.first))
3155 continue;
3156 for (unsigned Part = 0; Part < UF; ++Part) {
3157 Value *I = getOrCreateVectorValue(KV.first, Part);
3158 if (Erased.find(I) != Erased.end() || I->use_empty() ||
3159 !isa<Instruction>(I))
3160 continue;
3161 Type *OriginalTy = I->getType();
3162 Type *ScalarTruncatedTy =
3163 IntegerType::get(OriginalTy->getContext(), KV.second);
3164 Type *TruncatedTy = VectorType::get(ScalarTruncatedTy,
3165 OriginalTy->getVectorNumElements());
3166 if (TruncatedTy == OriginalTy)
3167 continue;
3168
3169 IRBuilder<> B(cast<Instruction>(I));
3170 auto ShrinkOperand = [&](Value *V) -> Value * {
3171 if (auto *ZI = dyn_cast<ZExtInst>(V))
3172 if (ZI->getSrcTy() == TruncatedTy)
3173 return ZI->getOperand(0);
3174 return B.CreateZExtOrTrunc(V, TruncatedTy);
3175 };
3176
3177 // The actual instruction modification depends on the instruction type,
3178 // unfortunately.
3179 Value *NewI = nullptr;
3180 if (auto *BO = dyn_cast<BinaryOperator>(I)) {
3181 NewI = B.CreateBinOp(BO->getOpcode(), ShrinkOperand(BO->getOperand(0)),
3182 ShrinkOperand(BO->getOperand(1)));
3183
3184 // Any wrapping introduced by shrinking this operation shouldn't be
3185 // considered undefined behavior. So, we can't unconditionally copy
3186 // arithmetic wrapping flags to NewI.
3187 cast<BinaryOperator>(NewI)->copyIRFlags(I, /*IncludeWrapFlags=*/false);
3188 } else if (auto *CI = dyn_cast<ICmpInst>(I)) {
3189 NewI =
3190 B.CreateICmp(CI->getPredicate(), ShrinkOperand(CI->getOperand(0)),
3191 ShrinkOperand(CI->getOperand(1)));
3192 } else if (auto *SI = dyn_cast<SelectInst>(I)) {
3193 NewI = B.CreateSelect(SI->getCondition(),
3194 ShrinkOperand(SI->getTrueValue()),
3195 ShrinkOperand(SI->getFalseValue()));
3196 } else if (auto *CI = dyn_cast<CastInst>(I)) {
3197 switch (CI->getOpcode()) {
3198 default:
3199 llvm_unreachable("Unhandled cast!")::llvm::llvm_unreachable_internal("Unhandled cast!", "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 3199)
;
3200 case Instruction::Trunc:
3201 NewI = ShrinkOperand(CI->getOperand(0));
3202 break;
3203 case Instruction::SExt:
3204 NewI = B.CreateSExtOrTrunc(
3205 CI->getOperand(0),
3206 smallestIntegerVectorType(OriginalTy, TruncatedTy));
3207 break;
3208 case Instruction::ZExt:
3209 NewI = B.CreateZExtOrTrunc(
3210 CI->getOperand(0),
3211 smallestIntegerVectorType(OriginalTy, TruncatedTy));
3212 break;
3213 }
3214 } else if (auto *SI = dyn_cast<ShuffleVectorInst>(I)) {
3215 auto Elements0 = SI->getOperand(0)->getType()->getVectorNumElements();
3216 auto *O0 = B.CreateZExtOrTrunc(
3217 SI->getOperand(0), VectorType::get(ScalarTruncatedTy, Elements0));
3218 auto Elements1 = SI->getOperand(1)->getType()->getVectorNumElements();
3219 auto *O1 = B.CreateZExtOrTrunc(
3220 SI->getOperand(1), VectorType::get(ScalarTruncatedTy, Elements1));
3221
3222 NewI = B.CreateShuffleVector(O0, O1, SI->getMask());
3223 } else if (isa<LoadInst>(I) || isa<PHINode>(I)) {
3224 // Don't do anything with the operands, just extend the result.
3225 continue;
3226 } else if (auto *IE = dyn_cast<InsertElementInst>(I)) {
3227 auto Elements = IE->getOperand(0)->getType()->getVectorNumElements();
3228 auto *O0 = B.CreateZExtOrTrunc(
3229 IE->getOperand(0), VectorType::get(ScalarTruncatedTy, Elements));
3230 auto *O1 = B.CreateZExtOrTrunc(IE->getOperand(1), ScalarTruncatedTy);
3231 NewI = B.CreateInsertElement(O0, O1, IE->getOperand(2));
3232 } else if (auto *EE = dyn_cast<ExtractElementInst>(I)) {
3233 auto Elements = EE->getOperand(0)->getType()->getVectorNumElements();
3234 auto *O0 = B.CreateZExtOrTrunc(
3235 EE->getOperand(0), VectorType::get(ScalarTruncatedTy, Elements));
3236 NewI = B.CreateExtractElement(O0, EE->getOperand(2));
3237 } else {
3238 // If we don't know what to do, be conservative and don't do anything.
3239 continue;
3240 }
3241
3242 // Lastly, extend the result.
3243 NewI->takeName(cast<Instruction>(I));
3244 Value *Res = B.CreateZExtOrTrunc(NewI, OriginalTy);
3245 I->replaceAllUsesWith(Res);
3246 cast<Instruction>(I)->eraseFromParent();
3247 Erased.insert(I);
3248 VectorLoopValueMap.resetVectorValue(KV.first, Part, Res);
3249 }
3250 }
3251
3252 // We'll have created a bunch of ZExts that are now parentless. Clean up.
3253 for (const auto &KV : Cost->getMinimalBitwidths()) {
3254 // If the value wasn't vectorized, we must maintain the original scalar
3255 // type. The absence of the value from VectorLoopValueMap indicates that it
3256 // wasn't vectorized.
3257 if (!VectorLoopValueMap.hasAnyVectorValue(KV.first))
3258 continue;
3259 for (unsigned Part = 0; Part < UF; ++Part) {
3260 Value *I = getOrCreateVectorValue(KV.first, Part);
3261 ZExtInst *Inst = dyn_cast<ZExtInst>(I);
3262 if (Inst && Inst->use_empty()) {
3263 Value *NewI = Inst->getOperand(0);
3264 Inst->eraseFromParent();
3265 VectorLoopValueMap.resetVectorValue(KV.first, Part, NewI);
3266 }
3267 }
3268 }
3269}
3270
3271void InnerLoopVectorizer::fixVectorizedLoop() {
3272 // Insert truncates and extends for any truncated instructions as hints to
3273 // InstCombine.
3274 if (VF > 1)
3275 truncateToMinimalBitwidths();
3276
3277 // Fix widened non-induction PHIs by setting up the PHI operands.
3278 if (OrigPHIsToFix.size()) {
3279 assert(EnableVPlanNativePath &&((EnableVPlanNativePath && "Unexpected non-induction PHIs for fixup in non VPlan-native path"
) ? static_cast<void> (0) : __assert_fail ("EnableVPlanNativePath && \"Unexpected non-induction PHIs for fixup in non VPlan-native path\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 3280, __PRETTY_FUNCTION__))
3280 "Unexpected non-induction PHIs for fixup in non VPlan-native path")((EnableVPlanNativePath && "Unexpected non-induction PHIs for fixup in non VPlan-native path"
) ? static_cast<void> (0) : __assert_fail ("EnableVPlanNativePath && \"Unexpected non-induction PHIs for fixup in non VPlan-native path\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 3280, __PRETTY_FUNCTION__))
;
3281 fixNonInductionPHIs();
3282 }
3283
3284 // At this point every instruction in the original loop is widened to a
3285 // vector form. Now we need to fix the recurrences in the loop. These PHI
3286 // nodes are currently empty because we did not want to introduce cycles.
3287 // This is the second stage of vectorizing recurrences.
3288 fixCrossIterationPHIs();
3289
3290 // Update the dominator tree.
3291 //
3292 // FIXME: After creating the structure of the new loop, the dominator tree is
3293 // no longer up-to-date, and it remains that way until we update it
3294 // here. An out-of-date dominator tree is problematic for SCEV,
3295 // because SCEVExpander uses it to guide code generation. The
3296 // vectorizer use SCEVExpanders in several places. Instead, we should
3297 // keep the dominator tree up-to-date as we go.
3298 updateAnalysis();
3299
3300 // Fix-up external users of the induction variables.
3301 for (auto &Entry : *Legal->getInductionVars())
3302 fixupIVUsers(Entry.first, Entry.second,
3303 getOrCreateVectorTripCount(LI->getLoopFor(LoopVectorBody)),
3304 IVEndValues[Entry.first], LoopMiddleBlock);
3305
3306 fixLCSSAPHIs();
3307 for (Instruction *PI : PredicatedInstructions)
3308 sinkScalarOperands(&*PI);
3309
3310 // Remove redundant induction instructions.
3311 cse(LoopVectorBody);
3312}
3313
3314void InnerLoopVectorizer::fixCrossIterationPHIs() {
3315 // In order to support recurrences we need to be able to vectorize Phi nodes.
3316 // Phi nodes have cycles, so we need to vectorize them in two stages. This is
3317 // stage #2: We now need to fix the recurrences by adding incoming edges to
3318 // the currently empty PHI nodes. At this point every instruction in the
3319 // original loop is widened to a vector form so we can use them to construct
3320 // the incoming edges.
3321 for (PHINode &Phi : OrigLoop->getHeader()->phis()) {
3322 // Handle first-order recurrences and reductions that need to be fixed.
3323 if (Legal->isFirstOrderRecurrence(&Phi))
3324 fixFirstOrderRecurrence(&Phi);
3325 else if (Legal->isReductionVariable(&Phi))
3326 fixReduction(&Phi);
3327 }
3328}
3329
3330void InnerLoopVectorizer::fixFirstOrderRecurrence(PHINode *Phi) {
3331 // This is the second phase of vectorizing first-order recurrences. An
3332 // overview of the transformation is described below. Suppose we have the
3333 // following loop.
3334 //
3335 // for (int i = 0; i < n; ++i)
3336 // b[i] = a[i] - a[i - 1];
3337 //
3338 // There is a first-order recurrence on "a". For this loop, the shorthand
3339 // scalar IR looks like:
3340 //
3341 // scalar.ph:
3342 // s_init = a[-1]
3343 // br scalar.body
3344 //
3345 // scalar.body:
3346 // i = phi [0, scalar.ph], [i+1, scalar.body]
3347 // s1 = phi [s_init, scalar.ph], [s2, scalar.body]
3348 // s2 = a[i]
3349 // b[i] = s2 - s1
3350 // br cond, scalar.body, ...
3351 //
3352 // In this example, s1 is a recurrence because it's value depends on the
3353 // previous iteration. In the first phase of vectorization, we created a
3354 // temporary value for s1. We now complete the vectorization and produce the
3355 // shorthand vector IR shown below (for VF = 4, UF = 1).
3356 //
3357 // vector.ph:
3358 // v_init = vector(..., ..., ..., a[-1])
3359 // br vector.body
3360 //
3361 // vector.body
3362 // i = phi [0, vector.ph], [i+4, vector.body]
3363 // v1 = phi [v_init, vector.ph], [v2, vector.body]
3364 // v2 = a[i, i+1, i+2, i+3];
3365 // v3 = vector(v1(3), v2(0, 1, 2))
3366 // b[i, i+1, i+2, i+3] = v2 - v3
3367 // br cond, vector.body, middle.block
3368 //
3369 // middle.block:
3370 // x = v2(3)
3371 // br scalar.ph
3372 //
3373 // scalar.ph:
3374 // s_init = phi [x, middle.block], [a[-1], otherwise]
3375 // br scalar.body
3376 //
3377 // After execution completes the vector loop, we extract the next value of
3378 // the recurrence (x) to use as the initial value in the scalar loop.
3379
3380 // Get the original loop preheader and single loop latch.
3381 auto *Preheader = OrigLoop->getLoopPreheader();
3382 auto *Latch = OrigLoop->getLoopLatch();
3383
3384 // Get the initial and previous values of the scalar recurrence.
3385 auto *ScalarInit = Phi->getIncomingValueForBlock(Preheader);
3386 auto *Previous = Phi->getIncomingValueForBlock(Latch);
3387
3388 // Create a vector from the initial value.
3389 auto *VectorInit = ScalarInit;
3390 if (VF > 1) {
3391 Builder.SetInsertPoint(LoopVectorPreHeader->getTerminator());
3392 VectorInit = Builder.CreateInsertElement(
3393 UndefValue::get(VectorType::get(VectorInit->getType(), VF)), VectorInit,
3394 Builder.getInt32(VF - 1), "vector.recur.init");
3395 }
3396
3397 // We constructed a temporary phi node in the first phase of vectorization.
3398 // This phi node will eventually be deleted.
3399 Builder.SetInsertPoint(
3400 cast<Instruction>(VectorLoopValueMap.getVectorValue(Phi, 0)));
3401
3402 // Create a phi node for the new recurrence. The current value will either be
3403 // the initial value inserted into a vector or loop-varying vector value.
3404 auto *VecPhi = Builder.CreatePHI(VectorInit->getType(), 2, "vector.recur");
3405 VecPhi->addIncoming(VectorInit, LoopVectorPreHeader);
3406
3407 // Get the vectorized previous value of the last part UF - 1. It appears last
3408 // among all unrolled iterations, due to the order of their construction.
3409 Value *PreviousLastPart = getOrCreateVectorValue(Previous, UF - 1);
3410
3411 // Set the insertion point after the previous value if it is an instruction.
3412 // Note that the previous value may have been constant-folded so it is not
3413 // guaranteed to be an instruction in the vector loop. Also, if the previous
3414 // value is a phi node, we should insert after all the phi nodes to avoid
3415 // breaking basic block verification.
3416 if (LI->getLoopFor(LoopVectorBody)->isLoopInvariant(PreviousLastPart) ||
3417 isa<PHINode>(PreviousLastPart))
3418 Builder.SetInsertPoint(&*LoopVectorBody->getFirstInsertionPt());
3419 else
3420 Builder.SetInsertPoint(
3421 &*++BasicBlock::iterator(cast<Instruction>(PreviousLastPart)));
3422
3423 // We will construct a vector for the recurrence by combining the values for
3424 // the current and previous iterations. This is the required shuffle mask.
3425 SmallVector<Constant *, 8> ShuffleMask(VF);
3426 ShuffleMask[0] = Builder.getInt32(VF - 1);
3427 for (unsigned I = 1; I < VF; ++I)
3428 ShuffleMask[I] = Builder.getInt32(I + VF - 1);
3429
3430 // The vector from which to take the initial value for the current iteration
3431 // (actual or unrolled). Initially, this is the vector phi node.
3432 Value *Incoming = VecPhi;
3433
3434 // Shuffle the current and previous vector and update the vector parts.
3435 for (unsigned Part = 0; Part < UF; ++Part) {
3436 Value *PreviousPart = getOrCreateVectorValue(Previous, Part);
3437 Value *PhiPart = VectorLoopValueMap.getVectorValue(Phi, Part);
3438 auto *Shuffle =
3439 VF > 1 ? Builder.CreateShuffleVector(Incoming, PreviousPart,
3440 ConstantVector::get(ShuffleMask))
3441 : Incoming;
3442 PhiPart->replaceAllUsesWith(Shuffle);
3443 cast<Instruction>(PhiPart)->eraseFromParent();
3444 VectorLoopValueMap.resetVectorValue(Phi, Part, Shuffle);
3445 Incoming = PreviousPart;
3446 }
3447
3448 // Fix the latch value of the new recurrence in the vector loop.
3449 VecPhi->addIncoming(Incoming, LI->getLoopFor(LoopVectorBody)->getLoopLatch());
3450
3451 // Extract the last vector element in the middle block. This will be the
3452 // initial value for the recurrence when jumping to the scalar loop.
3453 auto *ExtractForScalar = Incoming;
3454 if (VF > 1) {
3455 Builder.SetInsertPoint(LoopMiddleBlock->getTerminator());
3456 ExtractForScalar = Builder.CreateExtractElement(
3457 ExtractForScalar, Builder.getInt32(VF - 1), "vector.recur.extract");
3458 }
3459 // Extract the second last element in the middle block if the
3460 // Phi is used outside the loop. We need to extract the phi itself
3461 // and not the last element (the phi update in the current iteration). This
3462 // will be the value when jumping to the exit block from the LoopMiddleBlock,
3463 // when the scalar loop is not run at all.
3464 Value *ExtractForPhiUsedOutsideLoop = nullptr;
3465 if (VF > 1)
3466 ExtractForPhiUsedOutsideLoop = Builder.CreateExtractElement(
3467 Incoming, Builder.getInt32(VF - 2), "vector.recur.extract.for.phi");
3468 // When loop is unrolled without vectorizing, initialize
3469 // ExtractForPhiUsedOutsideLoop with the value just prior to unrolled value of
3470 // `Incoming`. This is analogous to the vectorized case above: extracting the
3471 // second last element when VF > 1.
3472 else if (UF > 1)
3473 ExtractForPhiUsedOutsideLoop = getOrCreateVectorValue(Previous, UF - 2);
3474
3475 // Fix the initial value of the original recurrence in the scalar loop.
3476 Builder.SetInsertPoint(&*LoopScalarPreHeader->begin());
3477 auto *Start = Builder.CreatePHI(Phi->getType(), 2, "scalar.recur.init");
3478 for (auto *BB : predecessors(LoopScalarPreHeader)) {
3479 auto *Incoming = BB == LoopMiddleBlock ? ExtractForScalar : ScalarInit;
3480 Start->addIncoming(Incoming, BB);
3481 }
3482
3483 Phi->setIncomingValue(Phi->getBasicBlockIndex(LoopScalarPreHeader), Start);
3484 Phi->setName("scalar.recur");
3485
3486 // Finally, fix users of the recurrence outside the loop. The users will need
3487 // either the last value of the scalar recurrence or the last value of the
3488 // vector recurrence we extracted in the middle block. Since the loop is in
3489 // LCSSA form, we just need to find all the phi nodes for the original scalar
3490 // recurrence in the exit block, and then add an edge for the middle block.
3491 for (PHINode &LCSSAPhi : LoopExitBlock->phis()) {
3492 if (LCSSAPhi.getIncomingValue(0) == Phi) {
3493 LCSSAPhi.addIncoming(ExtractForPhiUsedOutsideLoop, LoopMiddleBlock);
3494 }
3495 }
3496}
3497
3498void InnerLoopVectorizer::fixReduction(PHINode *Phi) {
3499 Constant *Zero = Builder.getInt32(0);
3500
3501 // Get it's reduction variable descriptor.
3502 assert(Legal->isReductionVariable(Phi) &&((Legal->isReductionVariable(Phi) && "Unable to find the reduction variable"
) ? static_cast<void> (0) : __assert_fail ("Legal->isReductionVariable(Phi) && \"Unable to find the reduction variable\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 3503, __PRETTY_FUNCTION__))
3503 "Unable to find the reduction variable")((Legal->isReductionVariable(Phi) && "Unable to find the reduction variable"
) ? static_cast<void> (0) : __assert_fail ("Legal->isReductionVariable(Phi) && \"Unable to find the reduction variable\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 3503, __PRETTY_FUNCTION__))
;
3504 RecurrenceDescriptor RdxDesc = (*Legal->getReductionVars())[Phi];
3505
3506 RecurrenceDescriptor::RecurrenceKind RK = RdxDesc.getRecurrenceKind();
3507 TrackingVH<Value> ReductionStartValue = RdxDesc.getRecurrenceStartValue();
3508 Instruction *LoopExitInst = RdxDesc.getLoopExitInstr();
3509 RecurrenceDescriptor::MinMaxRecurrenceKind MinMaxKind =
3510 RdxDesc.getMinMaxRecurrenceKind();
3511 setDebugLocFromInst(Builder, ReductionStartValue);
3512
3513 // We need to generate a reduction vector from the incoming scalar.
3514 // To do so, we need to generate the 'identity' vector and override
3515 // one of the elements with the incoming scalar reduction. We need
3516 // to do it in the vector-loop preheader.
3517 Builder.SetInsertPoint(LoopVectorPreHeader->getTerminator());
3518
3519 // This is the vector-clone of the value that leaves the loop.
3520 Type *VecTy = getOrCreateVectorValue(LoopExitInst, 0)->getType();
3521
3522 // Find the reduction identity variable. Zero for addition, or, xor,
3523 // one for multiplication, -1 for And.
3524 Value *Identity;
3525 Value *VectorStart;
3526 if (RK == RecurrenceDescriptor::RK_IntegerMinMax ||
3527 RK == RecurrenceDescriptor::RK_FloatMinMax) {
3528 // MinMax reduction have the start value as their identify.
3529 if (VF == 1) {
3530 VectorStart = Identity = ReductionStartValue;
3531 } else {
3532 VectorStart = Identity =
3533 Builder.CreateVectorSplat(VF, ReductionStartValue, "minmax.ident");
3534 }
3535 } else {
3536 // Handle other reduction kinds:
3537 Constant *Iden = RecurrenceDescriptor::getRecurrenceIdentity(
3538 RK, VecTy->getScalarType());
3539 if (VF == 1) {
3540 Identity = Iden;
3541 // This vector is the Identity vector where the first element is the
3542 // incoming scalar reduction.
3543 VectorStart = ReductionStartValue;
3544 } else {
3545 Identity = ConstantVector::getSplat(VF, Iden);
3546
3547 // This vector is the Identity vector where the first element is the
3548 // incoming scalar reduction.
3549 VectorStart =
3550 Builder.CreateInsertElement(Identity, ReductionStartValue, Zero);
3551 }
3552 }
3553
3554 // Fix the vector-loop phi.
3555
3556 // Reductions do not have to start at zero. They can start with
3557 // any loop invariant values.
3558 BasicBlock *Latch = OrigLoop->getLoopLatch();
3559 Value *LoopVal = Phi->getIncomingValueForBlock(Latch);
3560 for (unsigned Part = 0; Part < UF; ++Part) {
3561 Value *VecRdxPhi = getOrCreateVectorValue(Phi, Part);
3562 Value *Val = getOrCreateVectorValue(LoopVal, Part);
3563 // Make sure to add the reduction stat value only to the
3564 // first unroll part.
3565 Value *StartVal = (Part == 0) ? VectorStart : Identity;
3566 cast<PHINode>(VecRdxPhi)->addIncoming(StartVal, LoopVectorPreHeader);
3567 cast<PHINode>(VecRdxPhi)
3568 ->addIncoming(Val, LI->getLoopFor(LoopVectorBody)->getLoopLatch());
3569 }
3570
3571 // Before each round, move the insertion point right between
3572 // the PHIs and the values we are going to write.
3573 // This allows us to write both PHINodes and the extractelement
3574 // instructions.
3575 Builder.SetInsertPoint(&*LoopMiddleBlock->getFirstInsertionPt());
3576
3577 setDebugLocFromInst(Builder, LoopExitInst);
3578
3579 // If the vector reduction can be performed in a smaller type, we truncate
3580 // then extend the loop exit value to enable InstCombine to evaluate the
3581 // entire expression in the smaller type.
3582 if (VF > 1 && Phi->getType() != RdxDesc.getRecurrenceType()) {
3583 Type *RdxVecTy = VectorType::get(RdxDesc.getRecurrenceType(), VF);
3584 Builder.SetInsertPoint(
3585 LI->getLoopFor(LoopVectorBody)->getLoopLatch()->getTerminator());
3586 VectorParts RdxParts(UF);
3587 for (unsigned Part = 0; Part < UF; ++Part) {
3588 RdxParts[Part] = VectorLoopValueMap.getVectorValue(LoopExitInst, Part);
3589 Value *Trunc = Builder.CreateTrunc(RdxParts[Part], RdxVecTy);
3590 Value *Extnd = RdxDesc.isSigned() ? Builder.CreateSExt(Trunc, VecTy)
3591 : Builder.CreateZExt(Trunc, VecTy);
3592 for (Value::user_iterator UI = RdxParts[Part]->user_begin();
3593 UI != RdxParts[Part]->user_end();)
3594 if (*UI != Trunc) {
3595 (*UI++)->replaceUsesOfWith(RdxParts[Part], Extnd);
3596 RdxParts[Part] = Extnd;
3597 } else {
3598 ++UI;
3599 }
3600 }
3601 Builder.SetInsertPoint(&*LoopMiddleBlock->getFirstInsertionPt());
3602 for (unsigned Part = 0; Part < UF; ++Part) {
3603 RdxParts[Part] = Builder.CreateTrunc(RdxParts[Part], RdxVecTy);
3604 VectorLoopValueMap.resetVectorValue(LoopExitInst, Part, RdxParts[Part]);
3605 }
3606 }
3607
3608 // Reduce all of the unrolled parts into a single vector.
3609 Value *ReducedPartRdx = VectorLoopValueMap.getVectorValue(LoopExitInst, 0);
3610 unsigned Op = RecurrenceDescriptor::getRecurrenceBinOp(RK);
3611 setDebugLocFromInst(Builder, ReducedPartRdx);
3612 for (unsigned Part = 1; Part < UF; ++Part) {
3613 Value *RdxPart = VectorLoopValueMap.getVectorValue(LoopExitInst, Part);
3614 if (Op != Instruction::ICmp && Op != Instruction::FCmp)
3615 // Floating point operations had to be 'fast' to enable the reduction.
3616 ReducedPartRdx = addFastMathFlag(
3617 Builder.CreateBinOp((Instruction::BinaryOps)Op, RdxPart,
3618 ReducedPartRdx, "bin.rdx"),
3619 RdxDesc.getFastMathFlags());
3620 else
3621 ReducedPartRdx = createMinMaxOp(Builder, MinMaxKind, ReducedPartRdx,
3622 RdxPart);
3623 }
3624
3625 if (VF > 1) {
3626 bool NoNaN = Legal->hasFunNoNaNAttr();
3627 ReducedPartRdx =
3628 createTargetReduction(Builder, TTI, RdxDesc, ReducedPartRdx, NoNaN);
3629 // If the reduction can be performed in a smaller type, we need to extend
3630 // the reduction to the wider type before we branch to the original loop.
3631 if (Phi->getType() != RdxDesc.getRecurrenceType())
3632 ReducedPartRdx =
3633 RdxDesc.isSigned()
3634 ? Builder.CreateSExt(ReducedPartRdx, Phi->getType())
3635 : Builder.CreateZExt(ReducedPartRdx, Phi->getType());
3636 }
3637
3638 // Create a phi node that merges control-flow from the backedge-taken check
3639 // block and the middle block.
3640 PHINode *BCBlockPhi = PHINode::Create(Phi->getType(), 2, "bc.merge.rdx",
3641 LoopScalarPreHeader->getTerminator());
3642 for (unsigned I = 0, E = LoopBypassBlocks.size(); I != E; ++I)
3643 BCBlockPhi->addIncoming(ReductionStartValue, LoopBypassBlocks[I]);
3644 BCBlockPhi->addIncoming(ReducedPartRdx, LoopMiddleBlock);
3645
3646 // Now, we need to fix the users of the reduction variable
3647 // inside and outside of the scalar remainder loop.
3648 // We know that the loop is in LCSSA form. We need to update the
3649 // PHI nodes in the exit blocks.
3650 for (PHINode &LCSSAPhi : LoopExitBlock->phis()) {
3651 // All PHINodes need to have a single entry edge, or two if
3652 // we already fixed them.
3653 assert(LCSSAPhi.getNumIncomingValues() < 3 && "Invalid LCSSA PHI")((LCSSAPhi.getNumIncomingValues() < 3 && "Invalid LCSSA PHI"
) ? static_cast<void> (0) : __assert_fail ("LCSSAPhi.getNumIncomingValues() < 3 && \"Invalid LCSSA PHI\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 3653, __PRETTY_FUNCTION__))
;
3654
3655 // We found a reduction value exit-PHI. Update it with the
3656 // incoming bypass edge.
3657 if (LCSSAPhi.getIncomingValue(0) == LoopExitInst)
3658 LCSSAPhi.addIncoming(ReducedPartRdx, LoopMiddleBlock);
3659 } // end of the LCSSA phi scan.
3660
3661 // Fix the scalar loop reduction variable with the incoming reduction sum
3662 // from the vector body and from the backedge value.
3663 int IncomingEdgeBlockIdx =
3664 Phi->getBasicBlockIndex(OrigLoop->getLoopLatch());
3665 assert(IncomingEdgeBlockIdx >= 0 && "Invalid block index")((IncomingEdgeBlockIdx >= 0 && "Invalid block index"
) ? static_cast<void> (0) : __assert_fail ("IncomingEdgeBlockIdx >= 0 && \"Invalid block index\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 3665, __PRETTY_FUNCTION__))
;
3666 // Pick the other block.
3667 int SelfEdgeBlockIdx = (IncomingEdgeBlockIdx ? 0 : 1);
3668 Phi->setIncomingValue(SelfEdgeBlockIdx, BCBlockPhi);
3669 Phi->setIncomingValue(IncomingEdgeBlockIdx, LoopExitInst);
3670}
3671
3672void InnerLoopVectorizer::fixLCSSAPHIs() {
3673 for (PHINode &LCSSAPhi : LoopExitBlock->phis()) {
3674 if (LCSSAPhi.getNumIncomingValues() == 1) {
3675 auto *IncomingValue = LCSSAPhi.getIncomingValue(0);
3676 // Non-instruction incoming values will have only one value.
3677 unsigned LastLane = 0;
3678 if (isa<Instruction>(IncomingValue))
3679 LastLane = Cost->isUniformAfterVectorization(
3680 cast<Instruction>(IncomingValue), VF)
3681 ? 0
3682 : VF - 1;
3683 // Can be a loop invariant incoming value or the last scalar value to be
3684 // extracted from the vectorized loop.
3685 Builder.SetInsertPoint(LoopMiddleBlock->getTerminator());
3686 Value *lastIncomingValue =
3687 getOrCreateScalarValue(IncomingValue, { UF - 1, LastLane });
3688 LCSSAPhi.addIncoming(lastIncomingValue, LoopMiddleBlock);
3689 }
3690 }
3691}
3692
3693void InnerLoopVectorizer::sinkScalarOperands(Instruction *PredInst) {
3694 // The basic block and loop containing the predicated instruction.
3695 auto *PredBB = PredInst->getParent();
3696 auto *VectorLoop = LI->getLoopFor(PredBB);
3697
3698 // Initialize a worklist with the operands of the predicated instruction.
3699 SetVector<Value *> Worklist(PredInst->op_begin(), PredInst->op_end());
3700
3701 // Holds instructions that we need to analyze again. An instruction may be
3702 // reanalyzed if we don't yet know if we can sink it or not.
3703 SmallVector<Instruction *, 8> InstsToReanalyze;
3704
3705 // Returns true if a given use occurs in the predicated block. Phi nodes use
3706 // their operands in their corresponding predecessor blocks.
3707 auto isBlockOfUsePredicated = [&](Use &U) -> bool {
3708 auto *I = cast<Instruction>(U.getUser());
3709 BasicBlock *BB = I->getParent();
3710 if (auto *Phi = dyn_cast<PHINode>(I))
3711 BB = Phi->getIncomingBlock(
3712 PHINode::getIncomingValueNumForOperand(U.getOperandNo()));
3713 return BB == PredBB;
3714 };
3715
3716 // Iteratively sink the scalarized operands of the predicated instruction
3717 // into the block we created for it. When an instruction is sunk, it's
3718 // operands are then added to the worklist. The algorithm ends after one pass
3719 // through the worklist doesn't sink a single instruction.
3720 bool Changed;
3721 do {
3722 // Add the instructions that need to be reanalyzed to the worklist, and
3723 // reset the changed indicator.
3724 Worklist.insert(InstsToReanalyze.begin(), InstsToReanalyze.end());
3725 InstsToReanalyze.clear();
3726 Changed = false;
3727
3728 while (!Worklist.empty()) {
3729 auto *I = dyn_cast<Instruction>(Worklist.pop_back_val());
3730
3731 // We can't sink an instruction if it is a phi node, is already in the
3732 // predicated block, is not in the loop, or may have side effects.
3733 if (!I || isa<PHINode>(I) || I->getParent() == PredBB ||
3734 !VectorLoop->contains(I) || I->mayHaveSideEffects())
3735 continue;
3736
3737 // It's legal to sink the instruction if all its uses occur in the
3738 // predicated block. Otherwise, there's nothing to do yet, and we may
3739 // need to reanalyze the instruction.
3740 if (!llvm::all_of(I->uses(), isBlockOfUsePredicated)) {
3741 InstsToReanalyze.push_back(I);
3742 continue;
3743 }
3744
3745 // Move the instruction to the beginning of the predicated block, and add
3746 // it's operands to the worklist.
3747 I->moveBefore(&*PredBB->getFirstInsertionPt());
3748 Worklist.insert(I->op_begin(), I->op_end());
3749
3750 // The sinking may have enabled other instructions to be sunk, so we will
3751 // need to iterate.
3752 Changed = true;
3753 }
3754 } while (Changed);
3755}
3756
3757void InnerLoopVectorizer::fixNonInductionPHIs() {
3758 for (PHINode *OrigPhi : OrigPHIsToFix) {
3759 PHINode *NewPhi =
3760 cast<PHINode>(VectorLoopValueMap.getVectorValue(OrigPhi, 0));
3761 unsigned NumIncomingValues = OrigPhi->getNumIncomingValues();
3762
3763 SmallVector<BasicBlock *, 2> ScalarBBPredecessors(
3764 predecessors(OrigPhi->getParent()));
3765 SmallVector<BasicBlock *, 2> VectorBBPredecessors(
3766 predecessors(NewPhi->getParent()));
3767 assert(ScalarBBPredecessors.size() == VectorBBPredecessors.size() &&((ScalarBBPredecessors.size() == VectorBBPredecessors.size() &&
"Scalar and Vector BB should have the same number of predecessors"
) ? static_cast<void> (0) : __assert_fail ("ScalarBBPredecessors.size() == VectorBBPredecessors.size() && \"Scalar and Vector BB should have the same number of predecessors\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 3768, __PRETTY_FUNCTION__))
3768 "Scalar and Vector BB should have the same number of predecessors")((ScalarBBPredecessors.size() == VectorBBPredecessors.size() &&
"Scalar and Vector BB should have the same number of predecessors"
) ? static_cast<void> (0) : __assert_fail ("ScalarBBPredecessors.size() == VectorBBPredecessors.size() && \"Scalar and Vector BB should have the same number of predecessors\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 3768, __PRETTY_FUNCTION__))
;
3769
3770 // The insertion point in Builder may be invalidated by the time we get
3771 // here. Force the Builder insertion point to something valid so that we do
3772 // not run into issues during insertion point restore in
3773 // getOrCreateVectorValue calls below.
3774 Builder.SetInsertPoint(NewPhi);
3775
3776 // The predecessor order is preserved and we can rely on mapping between
3777 // scalar and vector block predecessors.
3778 for (unsigned i = 0; i < NumIncomingValues; ++i) {
3779 BasicBlock *NewPredBB = VectorBBPredecessors[i];
3780
3781 // When looking up the new scalar/vector values to fix up, use incoming
3782 // values from original phi.
3783 Value *ScIncV =
3784 OrigPhi->getIncomingValueForBlock(ScalarBBPredecessors[i]);
3785
3786 // Scalar incoming value may need a broadcast
3787 Value *NewIncV = getOrCreateVectorValue(ScIncV, 0);
3788 NewPhi->addIncoming(NewIncV, NewPredBB);
3789 }
3790 }
3791}
3792
3793void InnerLoopVectorizer::widenPHIInstruction(Instruction *PN, unsigned UF,
3794 unsigned VF) {
3795 PHINode *P = cast<PHINode>(PN);
3796 if (EnableVPlanNativePath) {
3797 // Currently we enter here in the VPlan-native path for non-induction
3798 // PHIs where all control flow is uniform. We simply widen these PHIs.
3799 // Create a vector phi with no operands - the vector phi operands will be
3800 // set at the end of vector code generation.
3801 Type *VecTy =
3802 (VF == 1) ? PN->getType() : VectorType::get(PN->getType(), VF);
3803 Value *VecPhi = Builder.CreatePHI(VecTy, PN->getNumOperands(), "vec.phi");
3804 VectorLoopValueMap.setVectorValue(P, 0, VecPhi);
3805 OrigPHIsToFix.push_back(P);
3806
3807 return;
3808 }
3809
3810 assert(PN->getParent() == OrigLoop->getHeader() &&((PN->getParent() == OrigLoop->getHeader() && "Non-header phis should have been handled elsewhere"
) ? static_cast<void> (0) : __assert_fail ("PN->getParent() == OrigLoop->getHeader() && \"Non-header phis should have been handled elsewhere\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 3811, __PRETTY_FUNCTION__))
3811 "Non-header phis should have been handled elsewhere")((PN->getParent() == OrigLoop->getHeader() && "Non-header phis should have been handled elsewhere"
) ? static_cast<void> (0) : __assert_fail ("PN->getParent() == OrigLoop->getHeader() && \"Non-header phis should have been handled elsewhere\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 3811, __PRETTY_FUNCTION__))
;
3812
3813 // In order to support recurrences we need to be able to vectorize Phi nodes.
3814 // Phi nodes have cycles, so we need to vectorize them in two stages. This is
3815 // stage #1: We create a new vector PHI node with no incoming edges. We'll use
3816 // this value when we vectorize all of the instructions that use the PHI.
3817 if (Legal->isReductionVariable(P) || Legal->isFirstOrderRecurrence(P)) {
3818 for (unsigned Part = 0; Part < UF; ++Part) {
3819 // This is phase one of vectorizing PHIs.
3820 Type *VecTy =
3821 (VF == 1) ? PN->getType() : VectorType::get(PN->getType(), VF);
3822 Value *EntryPart = PHINode::Create(
3823 VecTy, 2, "vec.phi", &*LoopVectorBody->getFirstInsertionPt());
3824 VectorLoopValueMap.setVectorValue(P, Part, EntryPart);
3825 }
3826 return;
3827 }
3828
3829 setDebugLocFromInst(Builder, P);
3830
3831 // This PHINode must be an induction variable.
3832 // Make sure that we know about it.
3833 assert(Legal->getInductionVars()->count(P) && "Not an induction variable")((Legal->getInductionVars()->count(P) && "Not an induction variable"
) ? static_cast<void> (0) : __assert_fail ("Legal->getInductionVars()->count(P) && \"Not an induction variable\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 3833, __PRETTY_FUNCTION__))
;
3834
3835 InductionDescriptor II = Legal->getInductionVars()->lookup(P);
3836 const DataLayout &DL = OrigLoop->getHeader()->getModule()->getDataLayout();
3837
3838 // FIXME: The newly created binary instructions should contain nsw/nuw flags,
3839 // which can be found from the original scalar operations.
3840 switch (II.getKind()) {
3841 case InductionDescriptor::IK_NoInduction:
3842 llvm_unreachable("Unknown induction")::llvm::llvm_unreachable_internal("Unknown induction", "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 3842)
;
3843 case InductionDescriptor::IK_IntInduction:
3844 case InductionDescriptor::IK_FpInduction:
3845 llvm_unreachable("Integer/fp induction is handled elsewhere.")::llvm::llvm_unreachable_internal("Integer/fp induction is handled elsewhere."
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 3845)
;
3846 case InductionDescriptor::IK_PtrInduction: {
3847 // Handle the pointer induction variable case.
3848 assert(P->getType()->isPointerTy() && "Unexpected type.")((P->getType()->isPointerTy() && "Unexpected type."
) ? static_cast<void> (0) : __assert_fail ("P->getType()->isPointerTy() && \"Unexpected type.\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 3848, __PRETTY_FUNCTION__))
;
3849 // This is the normalized GEP that starts counting at zero.
3850 Value *PtrInd = Induction;
3851 PtrInd = Builder.CreateSExtOrTrunc(PtrInd, II.getStep()->getType());
3852 // Determine the number of scalars we need to generate for each unroll
3853 // iteration. If the instruction is uniform, we only need to generate the
3854 // first lane. Otherwise, we generate all VF values.
3855 unsigned Lanes = Cost->isUniformAfterVectorization(P, VF) ? 1 : VF;
3856 // These are the scalar results. Notice that we don't generate vector GEPs
3857 // because scalar GEPs result in better code.
3858 for (unsigned Part = 0; Part < UF; ++Part) {
3859 for (unsigned Lane = 0; Lane < Lanes; ++Lane) {
3860 Constant *Idx = ConstantInt::get(PtrInd->getType(), Lane + Part * VF);
3861 Value *GlobalIdx = Builder.CreateAdd(PtrInd, Idx);
3862 Value *SclrGep =
3863 emitTransformedIndex(Builder, GlobalIdx, PSE.getSE(), DL, II);
3864 SclrGep->setName("next.gep");
3865 VectorLoopValueMap.setScalarValue(P, {Part, Lane}, SclrGep);
3866 }
3867 }
3868 return;
3869 }
3870 }
3871}
3872
3873/// A helper function for checking whether an integer division-related
3874/// instruction may divide by zero (in which case it must be predicated if
3875/// executed conditionally in the scalar code).
3876/// TODO: It may be worthwhile to generalize and check isKnownNonZero().
3877/// Non-zero divisors that are non compile-time constants will not be
3878/// converted into multiplication, so we will still end up scalarizing
3879/// the division, but can do so w/o predication.
3880static bool mayDivideByZero(Instruction &I) {
3881 assert((I.getOpcode() == Instruction::UDiv ||(((I.getOpcode() == Instruction::UDiv || I.getOpcode() == Instruction
::SDiv || I.getOpcode() == Instruction::URem || I.getOpcode()
== Instruction::SRem) && "Unexpected instruction") ?
static_cast<void> (0) : __assert_fail ("(I.getOpcode() == Instruction::UDiv || I.getOpcode() == Instruction::SDiv || I.getOpcode() == Instruction::URem || I.getOpcode() == Instruction::SRem) && \"Unexpected instruction\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 3885, __PRETTY_FUNCTION__))
3882 I.getOpcode() == Instruction::SDiv ||(((I.getOpcode() == Instruction::UDiv || I.getOpcode() == Instruction
::SDiv || I.getOpcode() == Instruction::URem || I.getOpcode()
== Instruction::SRem) && "Unexpected instruction") ?
static_cast<void> (0) : __assert_fail ("(I.getOpcode() == Instruction::UDiv || I.getOpcode() == Instruction::SDiv || I.getOpcode() == Instruction::URem || I.getOpcode() == Instruction::SRem) && \"Unexpected instruction\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 3885, __PRETTY_FUNCTION__))
3883 I.getOpcode() == Instruction::URem ||(((I.getOpcode() == Instruction::UDiv || I.getOpcode() == Instruction
::SDiv || I.getOpcode() == Instruction::URem || I.getOpcode()
== Instruction::SRem) && "Unexpected instruction") ?
static_cast<void> (0) : __assert_fail ("(I.getOpcode() == Instruction::UDiv || I.getOpcode() == Instruction::SDiv || I.getOpcode() == Instruction::URem || I.getOpcode() == Instruction::SRem) && \"Unexpected instruction\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 3885, __PRETTY_FUNCTION__))
3884 I.getOpcode() == Instruction::SRem) &&(((I.getOpcode() == Instruction::UDiv || I.getOpcode() == Instruction
::SDiv || I.getOpcode() == Instruction::URem || I.getOpcode()
== Instruction::SRem) && "Unexpected instruction") ?
static_cast<void> (0) : __assert_fail ("(I.getOpcode() == Instruction::UDiv || I.getOpcode() == Instruction::SDiv || I.getOpcode() == Instruction::URem || I.getOpcode() == Instruction::SRem) && \"Unexpected instruction\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 3885, __PRETTY_FUNCTION__))
3885 "Unexpected instruction")(((I.getOpcode() == Instruction::UDiv || I.getOpcode() == Instruction
::SDiv || I.getOpcode() == Instruction::URem || I.getOpcode()
== Instruction::SRem) && "Unexpected instruction") ?
static_cast<void> (0) : __assert_fail ("(I.getOpcode() == Instruction::UDiv || I.getOpcode() == Instruction::SDiv || I.getOpcode() == Instruction::URem || I.getOpcode() == Instruction::SRem) && \"Unexpected instruction\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 3885, __PRETTY_FUNCTION__))
;
3886 Value *Divisor = I.getOperand(1);
3887 auto *CInt = dyn_cast<ConstantInt>(Divisor);
3888 return !CInt || CInt->isZero();
3889}
3890
3891void InnerLoopVectorizer::widenInstruction(Instruction &I) {
3892 switch (I.getOpcode()) {
3893 case Instruction::Br:
3894 case Instruction::PHI:
3895 llvm_unreachable("This instruction is handled by a different recipe.")::llvm::llvm_unreachable_internal("This instruction is handled by a different recipe."
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 3895)
;
3896 case Instruction::GetElementPtr: {
3897 // Construct a vector GEP by widening the operands of the scalar GEP as
3898 // necessary. We mark the vector GEP 'inbounds' if appropriate. A GEP
3899 // results in a vector of pointers when at least one operand of the GEP
3900 // is vector-typed. Thus, to keep the representation compact, we only use
3901 // vector-typed operands for loop-varying values.
3902 auto *GEP = cast<GetElementPtrInst>(&I);
3903
3904 if (VF > 1 && OrigLoop->hasLoopInvariantOperands(GEP)) {
3905 // If we are vectorizing, but the GEP has only loop-invariant operands,
3906 // the GEP we build (by only using vector-typed operands for
3907 // loop-varying values) would be a scalar pointer. Thus, to ensure we
3908 // produce a vector of pointers, we need to either arbitrarily pick an
3909 // operand to broadcast, or broadcast a clone of the original GEP.
3910 // Here, we broadcast a clone of the original.
3911 //
3912 // TODO: If at some point we decide to scalarize instructions having
3913 // loop-invariant operands, this special case will no longer be
3914 // required. We would add the scalarization decision to
3915 // collectLoopScalars() and teach getVectorValue() to broadcast
3916 // the lane-zero scalar value.
3917 auto *Clone = Builder.Insert(GEP->clone());
3918 for (unsigned Part = 0; Part < UF; ++Part) {
3919 Value *EntryPart = Builder.CreateVectorSplat(VF, Clone);
3920 VectorLoopValueMap.setVectorValue(&I, Part, EntryPart);
3921 addMetadata(EntryPart, GEP);
3922 }
3923 } else {
3924 // If the GEP has at least one loop-varying operand, we are sure to
3925 // produce a vector of pointers. But if we are only unrolling, we want
3926 // to produce a scalar GEP for each unroll part. Thus, the GEP we
3927 // produce with the code below will be scalar (if VF == 1) or vector
3928 // (otherwise). Note that for the unroll-only case, we still maintain
3929 // values in the vector mapping with initVector, as we do for other
3930 // instructions.
3931 for (unsigned Part = 0; Part < UF; ++Part) {
3932 // The pointer operand of the new GEP. If it's loop-invariant, we
3933 // won't broadcast it.
3934 auto *Ptr =
3935 OrigLoop->isLoopInvariant(GEP->getPointerOperand())
3936 ? GEP->getPointerOperand()
3937 : getOrCreateVectorValue(GEP->getPointerOperand(), Part);
3938
3939 // Collect all the indices for the new GEP. If any index is
3940 // loop-invariant, we won't broadcast it.
3941 SmallVector<Value *, 4> Indices;
3942 for (auto &U : make_range(GEP->idx_begin(), GEP->idx_end())) {
3943 if (OrigLoop->isLoopInvariant(U.get()))
3944 Indices.push_back(U.get());
3945 else
3946 Indices.push_back(getOrCreateVectorValue(U.get(), Part));
3947 }
3948
3949 // Create the new GEP. Note that this GEP may be a scalar if VF == 1,
3950 // but it should be a vector, otherwise.
3951 auto *NewGEP =
3952 GEP->isInBounds()
3953 ? Builder.CreateInBoundsGEP(GEP->getSourceElementType(), Ptr,
3954 Indices)
3955 : Builder.CreateGEP(GEP->getSourceElementType(), Ptr, Indices);
3956 assert((VF == 1 || NewGEP->getType()->isVectorTy()) &&(((VF == 1 || NewGEP->getType()->isVectorTy()) &&
"NewGEP is not a pointer vector") ? static_cast<void> (
0) : __assert_fail ("(VF == 1 || NewGEP->getType()->isVectorTy()) && \"NewGEP is not a pointer vector\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 3957, __PRETTY_FUNCTION__))
3957 "NewGEP is not a pointer vector")(((VF == 1 || NewGEP->getType()->isVectorTy()) &&
"NewGEP is not a pointer vector") ? static_cast<void> (
0) : __assert_fail ("(VF == 1 || NewGEP->getType()->isVectorTy()) && \"NewGEP is not a pointer vector\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 3957, __PRETTY_FUNCTION__))
;
3958 VectorLoopValueMap.setVectorValue(&I, Part, NewGEP);
3959 addMetadata(NewGEP, GEP);
3960 }
3961 }
3962
3963 break;
3964 }
3965 case Instruction::UDiv:
3966 case Instruction::SDiv:
3967 case Instruction::SRem:
3968 case Instruction::URem:
3969 case Instruction::Add:
3970 case Instruction::FAdd:
3971 case Instruction::Sub:
3972 case Instruction::FSub:
3973 case Instruction::FNeg:
3974 case Instruction::Mul:
3975 case Instruction::FMul:
3976 case Instruction::FDiv:
3977 case Instruction::FRem:
3978 case Instruction::Shl:
3979 case Instruction::LShr:
3980 case Instruction::AShr:
3981 case Instruction::And:
3982 case Instruction::Or:
3983 case Instruction::Xor: {
3984 // Just widen unops and binops.
3985 setDebugLocFromInst(Builder, &I);
3986
3987 for (unsigned Part = 0; Part < UF; ++Part) {
3988 SmallVector<Value *, 2> Ops;
3989 for (Value *Op : I.operands())
3990 Ops.push_back(getOrCreateVectorValue(Op, Part));
3991
3992 Value *V = Builder.CreateNAryOp(I.getOpcode(), Ops);
3993
3994 if (auto *VecOp = dyn_cast<Instruction>(V))
3995 VecOp->copyIRFlags(&I);
3996
3997 // Use this vector value for all users of the original instruction.
3998 VectorLoopValueMap.setVectorValue(&I, Part, V);
3999 addMetadata(V, &I);
4000 }
4001
4002 break;
4003 }
4004 case Instruction::Select: {
4005 // Widen selects.
4006 // If the selector is loop invariant we can create a select
4007 // instruction with a scalar condition. Otherwise, use vector-select.
4008 auto *SE = PSE.getSE();
4009 bool InvariantCond =
4010 SE->isLoopInvariant(PSE.getSCEV(I.getOperand(0)), OrigLoop);
4011 setDebugLocFromInst(Builder, &I);
4012
4013 // The condition can be loop invariant but still defined inside the
4014 // loop. This means that we can't just use the original 'cond' value.
4015 // We have to take the 'vectorized' value and pick the first lane.
4016 // Instcombine will make this a no-op.
4017
4018 auto *ScalarCond = getOrCreateScalarValue(I.getOperand(0), {0, 0});
4019
4020 for (unsigned Part = 0; Part < UF; ++Part) {
4021 Value *Cond = getOrCreateVectorValue(I.getOperand(0), Part);
4022 Value *Op0 = getOrCreateVectorValue(I.getOperand(1), Part);
4023 Value *Op1 = getOrCreateVectorValue(I.getOperand(2), Part);
4024 Value *Sel =
4025 Builder.CreateSelect(InvariantCond ? ScalarCond : Cond, Op0, Op1);
4026 VectorLoopValueMap.setVectorValue(&I, Part, Sel);
4027 addMetadata(Sel, &I);
4028 }
4029
4030 break;
4031 }
4032
4033 case Instruction::ICmp:
4034 case Instruction::FCmp: {
4035 // Widen compares. Generate vector compares.
4036 bool FCmp = (I.getOpcode() == Instruction::FCmp);
4037 auto *Cmp = dyn_cast<CmpInst>(&I);
4038 setDebugLocFromInst(Builder, Cmp);
4039 for (unsigned Part = 0; Part < UF; ++Part) {
4040 Value *A = getOrCreateVectorValue(Cmp->getOperand(0), Part);
4041 Value *B = getOrCreateVectorValue(Cmp->getOperand(1), Part);
4042 Value *C = nullptr;
4043 if (FCmp) {
4044 // Propagate fast math flags.
4045 IRBuilder<>::FastMathFlagGuard FMFG(Builder);
4046 Builder.setFastMathFlags(Cmp->getFastMathFlags());
4047 C = Builder.CreateFCmp(Cmp->getPredicate(), A, B);
4048 } else {
4049 C = Builder.CreateICmp(Cmp->getPredicate(), A, B);
4050 }
4051 VectorLoopValueMap.setVectorValue(&I, Part, C);
4052 addMetadata(C, &I);
4053 }
4054
4055 break;
4056 }
4057
4058 case Instruction::ZExt:
4059 case Instruction::SExt:
4060 case Instruction::FPToUI:
4061 case Instruction::FPToSI:
4062 case Instruction::FPExt:
4063 case Instruction::PtrToInt:
4064 case Instruction::IntToPtr:
4065 case Instruction::SIToFP:
4066 case Instruction::UIToFP:
4067 case Instruction::Trunc:
4068 case Instruction::FPTrunc:
4069 case Instruction::BitCast: {
4070 auto *CI = dyn_cast<CastInst>(&I);
4071 setDebugLocFromInst(Builder, CI);
4072
4073 /// Vectorize casts.
4074 Type *DestTy =
4075 (VF == 1) ? CI->getType() : VectorType::get(CI->getType(), VF);
4076
4077 for (unsigned Part = 0; Part < UF; ++Part) {
4078 Value *A = getOrCreateVectorValue(CI->getOperand(0), Part);
4079 Value *Cast = Builder.CreateCast(CI->getOpcode(), A, DestTy);
4080 VectorLoopValueMap.setVectorValue(&I, Part, Cast);
4081 addMetadata(Cast, &I);
4082 }
4083 break;
4084 }
4085
4086 case Instruction::Call: {
4087 // Ignore dbg intrinsics.
4088 if (isa<DbgInfoIntrinsic>(I))
4089 break;
4090 setDebugLocFromInst(Builder, &I);
4091
4092 Module *M = I.getParent()->getParent()->getParent();
4093 auto *CI = cast<CallInst>(&I);
4094
4095 StringRef FnName = CI->getCalledFunction()->getName();
4096 Function *F = CI->getCalledFunction();
4097 Type *RetTy = ToVectorTy(CI->getType(), VF);
4098 SmallVector<Type *, 4> Tys;
4099 for (Value *ArgOperand : CI->arg_operands())
4100 Tys.push_back(ToVectorTy(ArgOperand->getType(), VF));
4101
4102 Intrinsic::ID ID = getVectorIntrinsicIDForCall(CI, TLI);
4103
4104 // The flag shows whether we use Intrinsic or a usual Call for vectorized
4105 // version of the instruction.
4106 // Is it beneficial to perform intrinsic call compared to lib call?
4107 bool NeedToScalarize;
4108 unsigned CallCost = Cost->getVectorCallCost(CI, VF, NeedToScalarize);
4109 bool UseVectorIntrinsic =
4110 ID && Cost->getVectorIntrinsicCost(CI, VF) <= CallCost;
4111 assert((UseVectorIntrinsic || !NeedToScalarize) &&(((UseVectorIntrinsic || !NeedToScalarize) && "Instruction should be scalarized elsewhere."
) ? static_cast<void> (0) : __assert_fail ("(UseVectorIntrinsic || !NeedToScalarize) && \"Instruction should be scalarized elsewhere.\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 4112, __PRETTY_FUNCTION__))
4112 "Instruction should be scalarized elsewhere.")(((UseVectorIntrinsic || !NeedToScalarize) && "Instruction should be scalarized elsewhere."
) ? static_cast<void> (0) : __assert_fail ("(UseVectorIntrinsic || !NeedToScalarize) && \"Instruction should be scalarized elsewhere.\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 4112, __PRETTY_FUNCTION__))
;
4113
4114 for (unsigned Part = 0; Part < UF; ++Part) {
4115 SmallVector<Value *, 4> Args;
4116 for (unsigned i = 0, ie = CI->getNumArgOperands(); i != ie; ++i) {
4117 Value *Arg = CI->getArgOperand(i);
4118 // Some intrinsics have a scalar argument - don't replace it with a
4119 // vector.
4120 if (!UseVectorIntrinsic || !hasVectorInstrinsicScalarOpd(ID, i))
4121 Arg = getOrCreateVectorValue(CI->getArgOperand(i), Part);
4122 Args.push_back(Arg);
4123 }
4124
4125 Function *VectorF;
4126 if (UseVectorIntrinsic) {
4127 // Use vector version of the intrinsic.
4128 Type *TysForDecl[] = {CI->getType()};
4129 if (VF > 1)
4130 TysForDecl[0] = VectorType::get(CI->getType()->getScalarType(), VF);
4131 VectorF = Intrinsic::getDeclaration(M, ID, TysForDecl);
4132 } else {
4133 // Use vector version of the library call.
4134 StringRef VFnName = TLI->getVectorizedFunction(FnName, VF);
4135 assert(!VFnName.empty() && "Vector function name is empty.")((!VFnName.empty() && "Vector function name is empty."
) ? static_cast<void> (0) : __assert_fail ("!VFnName.empty() && \"Vector function name is empty.\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 4135, __PRETTY_FUNCTION__))
;
4136 VectorF = M->getFunction(VFnName);
4137 if (!VectorF) {
4138 // Generate a declaration
4139 FunctionType *FTy = FunctionType::get(RetTy, Tys, false);
4140 VectorF =
4141 Function::Create(FTy, Function::ExternalLinkage, VFnName, M);
4142 VectorF->copyAttributesFrom(F);
4143 }
4144 }
4145 assert(VectorF && "Can't create vector function.")((VectorF && "Can't create vector function.") ? static_cast
<void> (0) : __assert_fail ("VectorF && \"Can't create vector function.\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 4145, __PRETTY_FUNCTION__))
;
4146
4147 SmallVector<OperandBundleDef, 1> OpBundles;
4148 CI->getOperandBundlesAsDefs(OpBundles);
4149 CallInst *V = Builder.CreateCall(VectorF, Args, OpBundles);
4150
4151 if (isa<FPMathOperator>(V))
4152 V->copyFastMathFlags(CI);
4153
4154 VectorLoopValueMap.setVectorValue(&I, Part, V);
4155 addMetadata(V, &I);
4156 }
4157
4158 break;
4159 }
4160
4161 default:
4162 // This instruction is not vectorized by simple widening.
4163 LLVM_DEBUG(dbgs() << "LV: Found an unhandled instruction: " << I)do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("loop-vectorize")) { dbgs() << "LV: Found an unhandled instruction: "
<< I; } } while (false)
;
4164 llvm_unreachable("Unhandled instruction!")::llvm::llvm_unreachable_internal("Unhandled instruction!", "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 4164)
;
4165 } // end of switch.
4166}
4167
4168void InnerLoopVectorizer::updateAnalysis() {
4169 // Forget the original basic block.
4170 PSE.getSE()->forgetLoop(OrigLoop);
4171
4172 // DT is not kept up-to-date for outer loop vectorization
4173 if (EnableVPlanNativePath)
4174 return;
4175
4176 // Update the dominator tree information.
4177 assert(DT->properlyDominates(LoopBypassBlocks.front(), LoopExitBlock) &&((DT->properlyDominates(LoopBypassBlocks.front(), LoopExitBlock
) && "Entry does not dominate exit.") ? static_cast<
void> (0) : __assert_fail ("DT->properlyDominates(LoopBypassBlocks.front(), LoopExitBlock) && \"Entry does not dominate exit.\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 4178, __PRETTY_FUNCTION__))
4178 "Entry does not dominate exit.")((DT->properlyDominates(LoopBypassBlocks.front(), LoopExitBlock
) && "Entry does not dominate exit.") ? static_cast<
void> (0) : __assert_fail ("DT->properlyDominates(LoopBypassBlocks.front(), LoopExitBlock) && \"Entry does not dominate exit.\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 4178, __PRETTY_FUNCTION__))
;
4179
4180 DT->addNewBlock(LoopMiddleBlock,
4181 LI->getLoopFor(LoopVectorBody)->getLoopLatch());
4182 DT->addNewBlock(LoopScalarPreHeader, LoopBypassBlocks[0]);
4183 DT->changeImmediateDominator(LoopScalarBody, LoopScalarPreHeader);
4184 DT->changeImmediateDominator(LoopExitBlock, LoopBypassBlocks[0]);
4185 assert(DT->verify(DominatorTree::VerificationLevel::Fast))((DT->verify(DominatorTree::VerificationLevel::Fast)) ? static_cast
<void> (0) : __assert_fail ("DT->verify(DominatorTree::VerificationLevel::Fast)"
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 4185, __PRETTY_FUNCTION__))
;
4186}
4187
4188void LoopVectorizationCostModel::collectLoopScalars(unsigned VF) {
4189 // We should not collect Scalars more than once per VF. Right now, this
4190 // function is called from collectUniformsAndScalars(), which already does
4191 // this check. Collecting Scalars for VF=1 does not make any sense.
4192 assert(VF >= 2 && Scalars.find(VF) == Scalars.end() &&((VF >= 2 && Scalars.find(VF) == Scalars.end() &&
"This function should not be visited twice for the same VF")
? static_cast<void> (0) : __assert_fail ("VF >= 2 && Scalars.find(VF) == Scalars.end() && \"This function should not be visited twice for the same VF\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 4193, __PRETTY_FUNCTION__))
4193 "This function should not be visited twice for the same VF")((VF >= 2 && Scalars.find(VF) == Scalars.end() &&
"This function should not be visited twice for the same VF")
? static_cast<void> (0) : __assert_fail ("VF >= 2 && Scalars.find(VF) == Scalars.end() && \"This function should not be visited twice for the same VF\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 4193, __PRETTY_FUNCTION__))
;
4194
4195 SmallSetVector<Instruction *, 8> Worklist;
4196
4197 // These sets are used to seed the analysis with pointers used by memory
4198 // accesses that will remain scalar.
4199 SmallSetVector<Instruction *, 8> ScalarPtrs;
4200 SmallPtrSet<Instruction *, 8> PossibleNonScalarPtrs;
4201
4202 // A helper that returns true if the use of Ptr by MemAccess will be scalar.
4203 // The pointer operands of loads and stores will be scalar as long as the
4204 // memory access is not a gather or scatter operation. The value operand of a
4205 // store will remain scalar if the store is scalarized.
4206 auto isScalarUse = [&](Instruction *MemAccess, Value *Ptr) {
4207 InstWidening WideningDecision = getWideningDecision(MemAccess, VF);
4208 assert(WideningDecision != CM_Unknown &&((WideningDecision != CM_Unknown && "Widening decision should be ready at this moment"
) ? static_cast<void> (0) : __assert_fail ("WideningDecision != CM_Unknown && \"Widening decision should be ready at this moment\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 4209, __PRETTY_FUNCTION__))
4209 "Widening decision should be ready at this moment")((WideningDecision != CM_Unknown && "Widening decision should be ready at this moment"
) ? static_cast<void> (0) : __assert_fail ("WideningDecision != CM_Unknown && \"Widening decision should be ready at this moment\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 4209, __PRETTY_FUNCTION__))
;
4210 if (auto *Store = dyn_cast<StoreInst>(MemAccess))
4211 if (Ptr == Store->getValueOperand())
4212 return WideningDecision == CM_Scalarize;
4213 assert(Ptr == getLoadStorePointerOperand(MemAccess) &&((Ptr == getLoadStorePointerOperand(MemAccess) && "Ptr is neither a value or pointer operand"
) ? static_cast<void> (0) : __assert_fail ("Ptr == getLoadStorePointerOperand(MemAccess) && \"Ptr is neither a value or pointer operand\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 4214, __PRETTY_FUNCTION__))
4214 "Ptr is neither a value or pointer operand")((Ptr == getLoadStorePointerOperand(MemAccess) && "Ptr is neither a value or pointer operand"
) ? static_cast<void> (0) : __assert_fail ("Ptr == getLoadStorePointerOperand(MemAccess) && \"Ptr is neither a value or pointer operand\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 4214, __PRETTY_FUNCTION__))
;
4215 return WideningDecision != CM_GatherScatter;
4216 };
4217
4218 // A helper that returns true if the given value is a bitcast or
4219 // getelementptr instruction contained in the loop.
4220 auto isLoopVaryingBitCastOrGEP = [&](Value *V) {
4221 return ((isa<BitCastInst>(V) && V->getType()->isPointerTy()) ||
4222 isa<GetElementPtrInst>(V)) &&
4223 !TheLoop->isLoopInvariant(V);
4224 };
4225
4226 // A helper that evaluates a memory access's use of a pointer. If the use
4227 // will be a scalar use, and the pointer is only used by memory accesses, we
4228 // place the pointer in ScalarPtrs. Otherwise, the pointer is placed in
4229 // PossibleNonScalarPtrs.
4230 auto evaluatePtrUse = [&](Instruction *MemAccess, Value *Ptr) {
4231 // We only care about bitcast and getelementptr instructions contained in
4232 // the loop.
4233 if (!isLoopVaryingBitCastOrGEP(Ptr))
4234 return;
4235
4236 // If the pointer has already been identified as scalar (e.g., if it was
4237 // also identified as uniform), there's nothing to do.
4238 auto *I = cast<Instruction>(Ptr);
4239 if (Worklist.count(I))
4240 return;
4241
4242 // If the use of the pointer will be a scalar use, and all users of the
4243 // pointer are memory accesses, place the pointer in ScalarPtrs. Otherwise,
4244 // place the pointer in PossibleNonScalarPtrs.
4245 if (isScalarUse(MemAccess, Ptr) && llvm::all_of(I->users(), [&](User *U) {
4246 return isa<LoadInst>(U) || isa<StoreInst>(U);
4247 }))
4248 ScalarPtrs.insert(I);
4249 else
4250 PossibleNonScalarPtrs.insert(I);
4251 };
4252
4253 // We seed the scalars analysis with three classes of instructions: (1)
4254 // instructions marked uniform-after-vectorization, (2) bitcast and
4255 // getelementptr instructions used by memory accesses requiring a scalar use,
4256 // and (3) pointer induction variables and their update instructions (we
4257 // currently only scalarize these).
4258 //
4259 // (1) Add to the worklist all instructions that have been identified as
4260 // uniform-after-vectorization.
4261 Worklist.insert(Uniforms[VF].begin(), Uniforms[VF].end());
4262
4263 // (2) Add to the worklist all bitcast and getelementptr instructions used by
4264 // memory accesses requiring a scalar use. The pointer operands of loads and
4265 // stores will be scalar as long as the memory accesses is not a gather or
4266 // scatter operation. The value operand of a store will remain scalar if the
4267 // store is scalarized.
4268 for (auto *BB : TheLoop->blocks())
4269 for (auto &I : *BB) {
4270 if (auto *Load = dyn_cast<LoadInst>(&I)) {
4271 evaluatePtrUse(Load, Load->getPointerOperand());
4272 } else if (auto *Store = dyn_cast<StoreInst>(&I)) {
4273 evaluatePtrUse(Store, Store->getPointerOperand());
4274 evaluatePtrUse(Store, Store->getValueOperand());
4275 }
4276 }
4277 for (auto *I : ScalarPtrs)
4278 if (PossibleNonScalarPtrs.find(I) == PossibleNonScalarPtrs.end()) {
4279 LLVM_DEBUG(dbgs() << "LV: Found scalar instruction: " << *I << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("loop-vectorize")) { dbgs() << "LV: Found scalar instruction: "
<< *I << "\n"; } } while (false)
;
4280 Worklist.insert(I);
4281 }
4282
4283 // (3) Add to the worklist all pointer induction variables and their update
4284 // instructions.
4285 //
4286 // TODO: Once we are able to vectorize pointer induction variables we should
4287 // no longer insert them into the worklist here.
4288 auto *Latch = TheLoop->getLoopLatch();
4289 for (auto &Induction : *Legal->getInductionVars()) {
4290 auto *Ind = Induction.first;
4291 auto *IndUpdate = cast<Instruction>(Ind->getIncomingValueForBlock(Latch));
4292 if (Induction.second.getKind() != InductionDescriptor::IK_PtrInduction)
4293 continue;
4294 Worklist.insert(Ind);
4295 Worklist.insert(IndUpdate);
4296 LLVM_DEBUG(dbgs() << "LV: Found scalar instruction: " << *Ind << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("loop-vectorize")) { dbgs() << "LV: Found scalar instruction: "
<< *Ind << "\n"; } } while (false)
;
4297 LLVM_DEBUG(dbgs() << "LV: Found scalar instruction: " << *IndUpdatedo { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("loop-vectorize")) { dbgs() << "LV: Found scalar instruction: "
<< *IndUpdate << "\n"; } } while (false)
4298 << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("loop-vectorize")) { dbgs() << "LV: Found scalar instruction: "
<< *IndUpdate << "\n"; } } while (false)
;
4299 }
4300
4301 // Insert the forced scalars.
4302 // FIXME: Currently widenPHIInstruction() often creates a dead vector
4303 // induction variable when the PHI user is scalarized.
4304 auto ForcedScalar = ForcedScalars.find(VF);
4305 if (ForcedScalar != ForcedScalars.end())
4306 for (auto *I : ForcedScalar->second)
4307 Worklist.insert(I);
4308
4309 // Expand the worklist by looking through any bitcasts and getelementptr
4310 // instructions we've already identified as scalar. This is similar to the
4311 // expansion step in collectLoopUniforms(); however, here we're only
4312 // expanding to include additional bitcasts and getelementptr instructions.
4313 unsigned Idx = 0;
4314 while (Idx != Worklist.size()) {
4315 Instruction *Dst = Worklist[Idx++];
4316 if (!isLoopVaryingBitCastOrGEP(Dst->getOperand(0)))
4317 continue;
4318 auto *Src = cast<Instruction>(Dst->getOperand(0));
4319 if (llvm::all_of(Src->users(), [&](User *U) -> bool {
4320 auto *J = cast<Instruction>(U);
4321 return !TheLoop->contains(J) || Worklist.count(J) ||
4322 ((isa<LoadInst>(J) || isa<StoreInst>(J)) &&
4323 isScalarUse(J, Src));
4324 })) {
4325 Worklist.insert(Src);
4326 LLVM_DEBUG(dbgs() << "LV: Found scalar instruction: " << *Src << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("loop-vectorize")) { dbgs() << "LV: Found scalar instruction: "
<< *Src << "\n"; } } while (false)
;
4327 }
4328 }
4329
4330 // An induction variable will remain scalar if all users of the induction
4331 // variable and induction variable update remain scalar.
4332 for (auto &Induction : *Legal->getInductionVars()) {
4333 auto *Ind = Induction.first;
4334 auto *IndUpdate = cast<Instruction>(Ind->getIncomingValueForBlock(Latch));
4335
4336 // We already considered pointer induction variables, so there's no reason
4337 // to look at their users again.
4338 //
4339 // TODO: Once we are able to vectorize pointer induction variables we
4340 // should no longer skip over them here.
4341 if (Induction.second.getKind() == InductionDescriptor::IK_PtrInduction)
4342 continue;
4343
4344 // Determine if all users of the induction variable are scalar after
4345 // vectorization.
4346 auto ScalarInd = llvm::all_of(Ind->users(), [&](User *U) -> bool {
4347 auto *I = cast<Instruction>(U);
4348 return I == IndUpdate || !TheLoop->contains(I) || Worklist.count(I);
4349 });
4350 if (!ScalarInd)
4351 continue;
4352
4353 // Determine if all users of the induction variable update instruction are
4354 // scalar after vectorization.
4355 auto ScalarIndUpdate =
4356 llvm::all_of(IndUpdate->users(), [&](User *U) -> bool {
4357 auto *I = cast<Instruction>(U);
4358 return I == Ind || !TheLoop->contains(I) || Worklist.count(I);
4359 });
4360 if (!ScalarIndUpdate)
4361 continue;
4362
4363 // The induction variable and its update instruction will remain scalar.
4364 Worklist.insert(Ind);
4365 Worklist.insert(IndUpdate);
4366 LLVM_DEBUG(dbgs() << "LV: Found scalar instruction: " << *Ind << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("loop-vectorize")) { dbgs() << "LV: Found scalar instruction: "
<< *Ind << "\n"; } } while (false)
;
4367 LLVM_DEBUG(dbgs() << "LV: Found scalar instruction: " << *IndUpdatedo { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("loop-vectorize")) { dbgs() << "LV: Found scalar instruction: "
<< *IndUpdate << "\n"; } } while (false)
4368 << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("loop-vectorize")) { dbgs() << "LV: Found scalar instruction: "
<< *IndUpdate << "\n"; } } while (false)
;
4369 }
4370
4371 Scalars[VF].insert(Worklist.begin(), Worklist.end());
4372}
4373
4374bool LoopVectorizationCostModel::isScalarWithPredication(Instruction *I, unsigned VF) {
4375 if (!blockNeedsPredication(I->getParent()))
4376 return false;
4377 switch(I->getOpcode()) {
4378 default:
4379 break;
4380 case Instruction::Load:
4381 case Instruction::Store: {
4382 if (!Legal->isMaskRequired(I))
4383 return false;
4384 auto *Ptr = getLoadStorePointerOperand(I);
4385 auto *Ty = getMemInstValueType(I);
4386 // We have already decided how to vectorize this instruction, get that
4387 // result.
4388 if (VF > 1) {
4389 InstWidening WideningDecision = getWideningDecision(I, VF);
4390 assert(WideningDecision != CM_Unknown &&((WideningDecision != CM_Unknown && "Widening decision should be ready at this moment"
) ? static_cast<void> (0) : __assert_fail ("WideningDecision != CM_Unknown && \"Widening decision should be ready at this moment\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 4391, __PRETTY_FUNCTION__))
4391 "Widening decision should be ready at this moment")((WideningDecision != CM_Unknown && "Widening decision should be ready at this moment"
) ? static_cast<void> (0) : __assert_fail ("WideningDecision != CM_Unknown && \"Widening decision should be ready at this moment\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 4391, __PRETTY_FUNCTION__))
;
4392 return WideningDecision == CM_Scalarize;
4393 }
4394 return isa<LoadInst>(I) ?
4395 !(isLegalMaskedLoad(Ty, Ptr) || isLegalMaskedGather(Ty))
4396 : !(isLegalMaskedStore(Ty, Ptr) || isLegalMaskedScatter(Ty));
4397 }
4398 case Instruction::UDiv:
4399 case Instruction::SDiv:
4400 case Instruction::SRem:
4401 case Instruction::URem:
4402 return mayDivideByZero(*I);
4403 }
4404 return false;
4405}
4406
4407bool LoopVectorizationCostModel::interleavedAccessCanBeWidened(Instruction *I,
4408 unsigned VF) {
4409 assert(isAccessInterleaved(I) && "Expecting interleaved access.")((isAccessInterleaved(I) && "Expecting interleaved access."
) ? static_cast<void> (0) : __assert_fail ("isAccessInterleaved(I) && \"Expecting interleaved access.\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 4409, __PRETTY_FUNCTION__))
;
4410 assert(getWideningDecision(I, VF) == CM_Unknown &&((getWideningDecision(I, VF) == CM_Unknown && "Decision should not be set yet."
) ? static_cast<void> (0) : __assert_fail ("getWideningDecision(I, VF) == CM_Unknown && \"Decision should not be set yet.\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 4411, __PRETTY_FUNCTION__))
4411 "Decision should not be set yet.")((getWideningDecision(I, VF) == CM_Unknown && "Decision should not be set yet."
) ? static_cast<void> (0) : __assert_fail ("getWideningDecision(I, VF) == CM_Unknown && \"Decision should not be set yet.\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 4411, __PRETTY_FUNCTION__))
;
4412 auto *Group = getInterleavedAccessGroup(I);
4413 assert(Group && "Must have a group.")((Group && "Must have a group.") ? static_cast<void
> (0) : __assert_fail ("Group && \"Must have a group.\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 4413, __PRETTY_FUNCTION__))
;
4414
4415 // Check if masking is required.
4416 // A Group may need masking for one of two reasons: it resides in a block that
4417 // needs predication, or it was decided to use masking to deal with gaps.
4418 bool PredicatedAccessRequiresMasking =
4419 Legal->blockNeedsPredication(I->getParent()) && Legal->isMaskRequired(I);
4420 bool AccessWithGapsRequiresMasking =
4421 Group->requiresScalarEpilogue() && !IsScalarEpilogueAllowed;
4422 if (!PredicatedAccessRequiresMasking && !AccessWithGapsRequiresMasking)
4423 return true;
4424
4425 // If masked interleaving is required, we expect that the user/target had
4426 // enabled it, because otherwise it either wouldn't have been created or
4427 // it should have been invalidated by the CostModel.
4428 assert(useMaskedInterleavedAccesses(TTI) &&((useMaskedInterleavedAccesses(TTI) && "Masked interleave-groups for predicated accesses are not enabled."
) ? static_cast<void> (0) : __assert_fail ("useMaskedInterleavedAccesses(TTI) && \"Masked interleave-groups for predicated accesses are not enabled.\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 4429, __PRETTY_FUNCTION__))
4429 "Masked interleave-groups for predicated accesses are not enabled.")((useMaskedInterleavedAccesses(TTI) && "Masked interleave-groups for predicated accesses are not enabled."
) ? static_cast<void> (0) : __assert_fail ("useMaskedInterleavedAccesses(TTI) && \"Masked interleave-groups for predicated accesses are not enabled.\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 4429, __PRETTY_FUNCTION__))
;
4430
4431 auto *Ty = getMemInstValueType(I);
4432 return isa<LoadInst>(I) ? TTI.isLegalMaskedLoad(Ty)
4433 : TTI.isLegalMaskedStore(Ty);
4434}
4435
4436bool LoopVectorizationCostModel::memoryInstructionCanBeWidened(Instruction *I,
4437 unsigned VF) {
4438 // Get and ensure we have a valid memory instruction.
4439 LoadInst *LI = dyn_cast<LoadInst>(I);
4440 StoreInst *SI = dyn_cast<StoreInst>(I);
4441 assert((LI || SI) && "Invalid memory instruction")(((LI || SI) && "Invalid memory instruction") ? static_cast
<void> (0) : __assert_fail ("(LI || SI) && \"Invalid memory instruction\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 4441, __PRETTY_FUNCTION__))
;
4442
4443 auto *Ptr = getLoadStorePointerOperand(I);
4444
4445 // In order to be widened, the pointer should be consecutive, first of all.
4446 if (!Legal->isConsecutivePtr(Ptr))
4447 return false;
4448
4449 // If the instruction is a store located in a predicated block, it will be
4450 // scalarized.
4451 if (isScalarWithPredication(I))
4452 return false;
4453
4454 // If the instruction's allocated size doesn't equal it's type size, it
4455 // requires padding and will be scalarized.
4456 auto &DL = I->getModule()->getDataLayout();
4457 auto *ScalarTy = LI ? LI->getType() : SI->getValueOperand()->getType();
4458 if (hasIrregularType(ScalarTy, DL, VF))
4459 return false;
4460
4461 return true;
4462}
4463
4464void LoopVectorizationCostModel::collectLoopUniforms(unsigned VF) {
4465 // We should not collect Uniforms more than once per VF. Right now,
4466 // this function is called from collectUniformsAndScalars(), which
4467 // already does this check. Collecting Uniforms for VF=1 does not make any
4468 // sense.
4469
4470 assert(VF >= 2 && Uniforms.find(VF) == Uniforms.end() &&((VF >= 2 && Uniforms.find(VF) == Uniforms.end() &&
"This function should not be visited twice for the same VF")
? static_cast<void> (0) : __assert_fail ("VF >= 2 && Uniforms.find(VF) == Uniforms.end() && \"This function should not be visited twice for the same VF\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 4471, __PRETTY_FUNCTION__))
4471 "This function should not be visited twice for the same VF")((VF >= 2 && Uniforms.find(VF) == Uniforms.end() &&
"This function should not be visited twice for the same VF")
? static_cast<void> (0) : __assert_fail ("VF >= 2 && Uniforms.find(VF) == Uniforms.end() && \"This function should not be visited twice for the same VF\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 4471, __PRETTY_FUNCTION__))
;
4472
4473 // Visit the list of Uniforms. If we'll not find any uniform value, we'll
4474 // not analyze again. Uniforms.count(VF) will return 1.
4475 Uniforms[VF].clear();
4476
4477 // We now know that the loop is vectorizable!
4478 // Collect instructions inside the loop that will remain uniform after
4479 // vectorization.
4480
4481 // Global values, params and instructions outside of current loop are out of
4482 // scope.
4483 auto isOutOfScope = [&](Value *V) -> bool {
4484 Instruction *I = dyn_cast<Instruction>(V);
4485 return (!I || !TheLoop->contains(I));
4486 };
4487
4488 SetVector<Instruction *> Worklist;
4489 BasicBlock *Latch = TheLoop->getLoopLatch();
4490
4491 // Start with the conditional branch. If the branch condition is an
4492 // instruction contained in the loop that is only used by the branch, it is
4493 // uniform.
4494 auto *Cmp = dyn_cast<Instruction>(Latch->getTerminator()->getOperand(0));
4495 if (Cmp && TheLoop->contains(Cmp) && Cmp->hasOneUse()) {
4496 Worklist.insert(Cmp);
4497 LLVM_DEBUG(dbgs() << "LV: Found uniform instruction: " << *Cmp << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("loop-vectorize")) { dbgs() << "LV: Found uniform instruction: "
<< *Cmp << "\n"; } } while (false)
;
4498 }
4499
4500 // Holds consecutive and consecutive-like pointers. Consecutive-like pointers
4501 // are pointers that are treated like consecutive pointers during
4502 // vectorization. The pointer operands of interleaved accesses are an
4503 // example.
4504 SmallSetVector<Instruction *, 8> ConsecutiveLikePtrs;
4505
4506 // Holds pointer operands of instructions that are possibly non-uniform.
4507 SmallPtrSet<Instruction *, 8> PossibleNonUniformPtrs;
4508
4509 auto isUniformDecision = [&](Instruction *I, unsigned VF) {
4510 InstWidening WideningDecision = getWideningDecision(I, VF);
4511 assert(WideningDecision != CM_Unknown &&((WideningDecision != CM_Unknown && "Widening decision should be ready at this moment"
) ? static_cast<void> (0) : __assert_fail ("WideningDecision != CM_Unknown && \"Widening decision should be ready at this moment\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 4512, __PRETTY_FUNCTION__))
4512 "Widening decision should be ready at this moment")((WideningDecision != CM_Unknown && "Widening decision should be ready at this moment"
) ? static_cast<void> (0) : __assert_fail ("WideningDecision != CM_Unknown && \"Widening decision should be ready at this moment\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 4512, __PRETTY_FUNCTION__))
;
4513
4514 return (WideningDecision == CM_Widen ||
4515 WideningDecision == CM_Widen_Reverse ||
4516 WideningDecision == CM_Interleave);
4517 };
4518 // Iterate over the instructions in the loop, and collect all
4519 // consecutive-like pointer operands in ConsecutiveLikePtrs. If it's possible
4520 // that a consecutive-like pointer operand will be scalarized, we collect it
4521 // in PossibleNonUniformPtrs instead. We use two sets here because a single
4522 // getelementptr instruction can be used by both vectorized and scalarized
4523 // memory instructions. For example, if a loop loads and stores from the same
4524 // location, but the store is conditional, the store will be scalarized, and
4525 // the getelementptr won't remain uniform.
4526 for (auto *BB : TheLoop->blocks())
4527 for (auto &I : *BB) {
4528 // If there's no pointer operand, there's nothing to do.
4529 auto *Ptr = dyn_cast_or_null<Instruction>(getLoadStorePointerOperand(&I));
4530 if (!Ptr)
4531 continue;
4532
4533 // True if all users of Ptr are memory accesses that have Ptr as their
4534 // pointer operand.
4535 auto UsersAreMemAccesses =
4536 llvm::all_of(Ptr->users(), [&](User *U) -> bool {
4537 return getLoadStorePointerOperand(U) == Ptr;
4538 });
4539
4540 // Ensure the memory instruction will not be scalarized or used by
4541 // gather/scatter, making its pointer operand non-uniform. If the pointer
4542 // operand is used by any instruction other than a memory access, we
4543 // conservatively assume the pointer operand may be non-uniform.
4544 if (!UsersAreMemAccesses || !isUniformDecision(&I, VF))
4545 PossibleNonUniformPtrs.insert(Ptr);
4546
4547 // If the memory instruction will be vectorized and its pointer operand
4548 // is consecutive-like, or interleaving - the pointer operand should
4549 // remain uniform.
4550 else
4551 ConsecutiveLikePtrs.insert(Ptr);
4552 }
4553
4554 // Add to the Worklist all consecutive and consecutive-like pointers that
4555 // aren't also identified as possibly non-uniform.
4556 for (auto *V : ConsecutiveLikePtrs)
4557 if (PossibleNonUniformPtrs.find(V) == PossibleNonUniformPtrs.end()) {
4558 LLVM_DEBUG(dbgs() << "LV: Found uniform instruction: " << *V << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("loop-vectorize")) { dbgs() << "LV: Found uniform instruction: "
<< *V << "\n"; } } while (false)
;
4559 Worklist.insert(V);
4560 }
4561
4562 // Expand Worklist in topological order: whenever a new instruction
4563 // is added , its users should be already inside Worklist. It ensures
4564 // a uniform instruction will only be used by uniform instructions.
4565 unsigned idx = 0;
4566 while (idx != Worklist.size()) {
4567 Instruction *I = Worklist[idx++];
4568
4569 for (auto OV : I->operand_values()) {
4570 // isOutOfScope operands cannot be uniform instructions.
4571 if (isOutOfScope(OV))
4572 continue;
4573 // First order recurrence Phi's should typically be considered
4574 // non-uniform.
4575 auto *OP = dyn_cast<PHINode>(OV);
4576 if (OP && Legal->isFirstOrderRecurrence(OP))
4577 continue;
4578 // If all the users of the operand are uniform, then add the
4579 // operand into the uniform worklist.
4580 auto *OI = cast<Instruction>(OV);
4581 if (llvm::all_of(OI->users(), [&](User *U) -> bool {
4582 auto *J = cast<Instruction>(U);
4583 return Worklist.count(J) ||
4584 (OI == getLoadStorePointerOperand(J) &&
4585 isUniformDecision(J, VF));
4586 })) {
4587 Worklist.insert(OI);
4588 LLVM_DEBUG(dbgs() << "LV: Found uniform instruction: " << *OI << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("loop-vectorize")) { dbgs() << "LV: Found uniform instruction: "
<< *OI << "\n"; } } while (false)
;
4589 }
4590 }
4591 }
4592
4593 // Returns true if Ptr is the pointer operand of a memory access instruction
4594 // I, and I is known to not require scalarization.
4595 auto isVectorizedMemAccessUse = [&](Instruction *I, Value *Ptr) -> bool {
4596 return getLoadStorePointerOperand(I) == Ptr && isUniformDecision(I, VF);
4597 };
4598
4599 // For an instruction to be added into Worklist above, all its users inside
4600 // the loop should also be in Worklist. However, this condition cannot be
4601 // true for phi nodes that form a cyclic dependence. We must process phi
4602 // nodes separately. An induction variable will remain uniform if all users
4603 // of the induction variable and induction variable update remain uniform.
4604 // The code below handles both pointer and non-pointer induction variables.
4605 for (auto &Induction : *Legal->getInductionVars()) {
4606 auto *Ind = Induction.first;
4607 auto *IndUpdate = cast<Instruction>(Ind->getIncomingValueForBlock(Latch));
4608
4609 // Determine if all users of the induction variable are uniform after
4610 // vectorization.
4611 auto UniformInd = llvm::all_of(Ind->users(), [&](User *U) -> bool {
4612 auto *I = cast<Instruction>(U);
4613 return I == IndUpdate || !TheLoop->contains(I) || Worklist.count(I) ||
4614 isVectorizedMemAccessUse(I, Ind);
4615 });
4616 if (!UniformInd)
4617 continue;
4618
4619 // Determine if all users of the induction variable update instruction are
4620 // uniform after vectorization.
4621 auto UniformIndUpdate =
4622 llvm::all_of(IndUpdate->users(), [&](User *U) -> bool {
4623 auto *I = cast<Instruction>(U);
4624 return I == Ind || !TheLoop->contains(I) || Worklist.count(I) ||
4625 isVectorizedMemAccessUse(I, IndUpdate);
4626 });
4627 if (!UniformIndUpdate)
4628 continue;
4629
4630 // The induction variable and its update instruction will remain uniform.
4631 Worklist.insert(Ind);
4632 Worklist.insert(IndUpdate);
4633 LLVM_DEBUG(dbgs() << "LV: Found uniform instruction: " << *Ind << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("loop-vectorize")) { dbgs() << "LV: Found uniform instruction: "
<< *Ind << "\n"; } } while (false)
;
4634 LLVM_DEBUG(dbgs() << "LV: Found uniform instruction: " << *IndUpdatedo { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("loop-vectorize")) { dbgs() << "LV: Found uniform instruction: "
<< *IndUpdate << "\n"; } } while (false)
4635 << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("loop-vectorize")) { dbgs() << "LV: Found uniform instruction: "
<< *IndUpdate << "\n"; } } while (false)
;
4636 }
4637
4638 Uniforms[VF].insert(Worklist.begin(), Worklist.end());
4639}
4640
4641Optional<unsigned> LoopVectorizationCostModel::computeMaxVF(bool OptForSize) {
4642 if (Legal->getRuntimePointerChecking()->Need && TTI.hasBranchDivergence()) {
4643 // TODO: It may by useful to do since it's still likely to be dynamically
4644 // uniform if the target can skip.
4645 LLVM_DEBUG(do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("loop-vectorize")) { dbgs() << "LV: Not inserting runtime ptr check for divergent target"
; } } while (false)
4646 dbgs() << "LV: Not inserting runtime ptr check for divergent target")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("loop-vectorize")) { dbgs() << "LV: Not inserting runtime ptr check for divergent target"
; } } while (false)
;
4647
4648 ORE->emit(
4649 createMissedAnalysis("CantVersionLoopWithDivergentTarget")
4650 << "runtime pointer checks needed. Not enabled for divergent target");
4651
4652 return None;
4653 }
4654
4655 unsigned TC = PSE.getSE()->getSmallConstantTripCount(TheLoop);
4656 if (!OptForSize) // Remaining checks deal with scalar loop when OptForSize.
4657 return computeFeasibleMaxVF(OptForSize, TC);
4658
4659 if (Legal->getRuntimePointerChecking()->Need) {
4660 ORE->emit(createMissedAnalysis("CantVersionLoopWithOptForSize")
4661 << "runtime pointer checks needed. Enable vectorization of this "
4662 "loop with '#pragma clang loop vectorize(enable)' when "
4663 "compiling with -Os/-Oz");
4664 LLVM_DEBUG(do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("loop-vectorize")) { dbgs() << "LV: Aborting. Runtime ptr check is required with -Os/-Oz.\n"
; } } while (false)
4665 dbgs()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("loop-vectorize")) { dbgs() << "LV: Aborting. Runtime ptr check is required with -Os/-Oz.\n"
; } } while (false)
4666 << "LV: Aborting. Runtime ptr check is required with -Os/-Oz.\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("loop-vectorize")) { dbgs() << "LV: Aborting. Runtime ptr check is required with -Os/-Oz.\n"
; } } while (false)
;
4667 return None;
4668 }
4669
4670 if (!PSE.getUnionPredicate().getPredicates().empty()) {
4671 ORE->emit(createMissedAnalysis("CantVersionLoopWithOptForSize")
4672 << "runtime SCEV checks needed. Enable vectorization of this "
4673 "loop with '#pragma clang loop vectorize(enable)' when "
4674 "compiling with -Os/-Oz");
4675 LLVM_DEBUG(do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("loop-vectorize")) { dbgs() << "LV: Aborting. Runtime SCEV check is required with -Os/-Oz.\n"
; } } while (false)
4676 dbgs()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("loop-vectorize")) { dbgs() << "LV: Aborting. Runtime SCEV check is required with -Os/-Oz.\n"
; } } while (false)
4677 << "LV: Aborting. Runtime SCEV check is required with -Os/-Oz.\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("loop-vectorize")) { dbgs() << "LV: Aborting. Runtime SCEV check is required with -Os/-Oz.\n"
; } } while (false)
;
4678 return None;
4679 }
4680
4681 // FIXME: Avoid specializing for stride==1 instead of bailing out.
4682 if (!Legal->getLAI()->getSymbolicStrides().empty()) {
4683 ORE->emit(createMissedAnalysis("CantVersionLoopWithOptForSize")
4684 << "runtime stride == 1 checks needed. Enable vectorization of "
4685 "this loop with '#pragma clang loop vectorize(enable)' when "
4686 "compiling with -Os/-Oz");
4687 LLVM_DEBUG(do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("loop-vectorize")) { dbgs() << "LV: Aborting. Runtime stride check is required with -Os/-Oz.\n"
; } } while (false)
4688 dbgs()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("loop-vectorize")) { dbgs() << "LV: Aborting. Runtime stride check is required with -Os/-Oz.\n"
; } } while (false)
4689 << "LV: Aborting. Runtime stride check is required with -Os/-Oz.\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("loop-vectorize")) { dbgs() << "LV: Aborting. Runtime stride check is required with -Os/-Oz.\n"
; } } while (false)
;
4690 return None;
4691 }
4692
4693 // If we optimize the program for size, avoid creating the tail loop.
4694 LLVM_DEBUG(dbgs() << "LV: Found trip count: " << TC << '\n')do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("loop-vectorize")) { dbgs() << "LV: Found trip count: "
<< TC << '\n'; } } while (false)
;
4695
4696 if (TC == 1) {
4697 ORE->emit(createMissedAnalysis("SingleIterationLoop")
4698 << "loop trip count is one, irrelevant for vectorization");
4699 LLVM_DEBUG(dbgs() << "LV: Aborting, single iteration (non) loop.\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("loop-vectorize")) { dbgs() << "LV: Aborting, single iteration (non) loop.\n"
; } } while (false)
;
4700 return None;
4701 }
4702
4703 // Record that scalar epilogue is not allowed.
4704 LLVM_DEBUG(dbgs() << "LV: Not allowing scalar epilogue due to -Os/-Oz.\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("loop-vectorize")) { dbgs() << "LV: Not allowing scalar epilogue due to -Os/-Oz.\n"
; } } while (false)
;
4705
4706 IsScalarEpilogueAllowed = !OptForSize;
4707
4708 // We don't create an epilogue when optimizing for size.
4709 // Invalidate interleave groups that require an epilogue if we can't mask
4710 // the interleave-group.
4711 if (!useMaskedInterleavedAccesses(TTI))
4712 InterleaveInfo.invalidateGroupsRequiringScalarEpilogue();
4713
4714 unsigned MaxVF = computeFeasibleMaxVF(OptForSize, TC);
4715
4716 if (TC > 0 && TC % MaxVF == 0) {
4717 LLVM_DEBUG(dbgs() << "LV: No tail will remain for any chosen VF.\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("loop-vectorize")) { dbgs() << "LV: No tail will remain for any chosen VF.\n"
; } } while (false)
;
4718 return MaxVF;
4719 }
4720
4721 // If we don't know the precise trip count, or if the trip count that we
4722 // found modulo the vectorization factor is not zero, try to fold the tail
4723 // by masking.
4724 // FIXME: look for a smaller MaxVF that does divide TC rather than masking.
4725 if (Legal->canFoldTailByMasking()) {
4726 FoldTailByMasking = true;
4727 return MaxVF;
4728 }
4729
4730 if (TC == 0) {
4731 ORE->emit(
4732 createMissedAnalysis("UnknownLoopCountComplexCFG")
4733 << "unable to calculate the loop count due to complex control flow");
4734 return None;
4735 }
4736
4737 ORE->emit(createMissedAnalysis("NoTailLoopWithOptForSize")
4738 << "cannot optimize for size and vectorize at the same time. "
4739 "Enable vectorization of this loop with '#pragma clang loop "
4740 "vectorize(enable)' when compiling with -Os/-Oz");
4741 return None;
4742}
4743
4744unsigned
4745LoopVectorizationCostModel::computeFeasibleMaxVF(bool OptForSize,
4746 unsigned ConstTripCount) {
4747 MinBWs = computeMinimumValueSizes(TheLoop->getBlocks(), *DB, &TTI);
4748 unsigned SmallestType, WidestType;
4749 std::tie(SmallestType, WidestType) = getSmallestAndWidestTypes();
4750 unsigned WidestRegister = TTI.getRegisterBitWidth(true);
4751
4752 // Get the maximum safe dependence distance in bits computed by LAA.
4753 // It is computed by MaxVF * sizeOf(type) * 8, where type is taken from
4754 // the memory accesses that is most restrictive (involved in the smallest
4755 // dependence distance).
4756 unsigned MaxSafeRegisterWidth = Legal->getMaxSafeRegisterWidth();
4757
4758 WidestRegister = std::min(WidestRegister, MaxSafeRegisterWidth);
4759
4760 unsigned MaxVectorSize = WidestRegister / WidestType;
4761
4762 LLVM_DEBUG(dbgs() << "LV: The Smallest and Widest types: " << SmallestTypedo { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("loop-vectorize")) { dbgs() << "LV: The Smallest and Widest types: "
<< SmallestType << " / " << WidestType <<
" bits.\n"; } } while (false)
4763 << " / " << WidestType << " bits.\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("loop-vectorize")) { dbgs() << "LV: The Smallest and Widest types: "
<< SmallestType << " / " << WidestType <<
" bits.\n"; } } while (false)
;
4764 LLVM_DEBUG(dbgs() << "LV: The Widest register safe to use is: "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("loop-vectorize")) { dbgs() << "LV: The Widest register safe to use is: "
<< WidestRegister << " bits.\n"; } } while (false
)
4765 << WidestRegister << " bits.\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("loop-vectorize")) { dbgs() << "LV: The Widest register safe to use is: "
<< WidestRegister << " bits.\n"; } } while (false
)
;
4766
4767 assert(MaxVectorSize <= 256 && "Did not expect to pack so many elements"((MaxVectorSize <= 256 && "Did not expect to pack so many elements"
" into one vector!") ? static_cast<void> (0) : __assert_fail
("MaxVectorSize <= 256 && \"Did not expect to pack so many elements\" \" into one vector!\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 4768, __PRETTY_FUNCTION__))
4768 " into one vector!")((MaxVectorSize <= 256 && "Did not expect to pack so many elements"
" into one vector!") ? static_cast<void> (0) : __assert_fail
("MaxVectorSize <= 256 && \"Did not expect to pack so many elements\" \" into one vector!\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 4768, __PRETTY_FUNCTION__))
;
4769 if (MaxVectorSize == 0) {
4770 LLVM_DEBUG(dbgs() << "LV: The target has no vector registers.\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("loop-vectorize")) { dbgs() << "LV: The target has no vector registers.\n"
; } } while (false)
;
4771 MaxVectorSize = 1;
4772 return MaxVectorSize;
4773 } else if (ConstTripCount && ConstTripCount < MaxVectorSize &&
4774 isPowerOf2_32(ConstTripCount)) {
4775 // We need to clamp the VF to be the ConstTripCount. There is no point in
4776 // choosing a higher viable VF as done in the loop below.
4777 LLVM_DEBUG(dbgs() << "LV: Clamping the MaxVF to the constant trip count: "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("loop-vectorize")) { dbgs() << "LV: Clamping the MaxVF to the constant trip count: "
<< ConstTripCount << "\n"; } } while (false)
4778 << ConstTripCount << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("loop-vectorize")) { dbgs() << "LV: Clamping the MaxVF to the constant trip count: "
<< ConstTripCount << "\n"; } } while (false)
;
4779 MaxVectorSize = ConstTripCount;
4780 return MaxVectorSize;
4781 }
4782
4783 unsigned MaxVF = MaxVectorSize;
4784 if (TTI.shouldMaximizeVectorBandwidth(OptForSize) ||
4785 (MaximizeBandwidth && !OptForSize)) {
4786 // Collect all viable vectorization factors larger than the default MaxVF
4787 // (i.e. MaxVectorSize).
4788 SmallVector<unsigned, 8> VFs;
4789 unsigned NewMaxVectorSize = WidestRegister / SmallestType;
4790 for (unsigned VS = MaxVectorSize * 2; VS <= NewMaxVectorSize; VS *= 2)
4791 VFs.push_back(VS);
4792
4793 // For each VF calculate its register usage.
4794 auto RUs = calculateRegisterUsage(VFs);
4795
4796 // Select the largest VF which doesn't require more registers than existing
4797 // ones.
4798 unsigned TargetNumRegisters = TTI.getNumberOfRegisters(true);
4799 for (int i = RUs.size() - 1; i >= 0; --i) {
4800 if (RUs[i].MaxLocalUsers <= TargetNumRegisters) {
4801 MaxVF = VFs[i];
4802 break;
4803 }
4804 }
4805 if (unsigned MinVF = TTI.getMinimumVF(SmallestType)) {
4806 if (MaxVF < MinVF) {
4807 LLVM_DEBUG(dbgs() << "LV: Overriding calculated MaxVF(" << MaxVFdo { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("loop-vectorize")) { dbgs() << "LV: Overriding calculated MaxVF("
<< MaxVF << ") with target's minimum: " <<
MinVF << '\n'; } } while (false)
4808 << ") with target's minimum: " << MinVF << '\n')do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("loop-vectorize")) { dbgs() << "LV: Overriding calculated MaxVF("
<< MaxVF << ") with target's minimum: " <<
MinVF << '\n'; } } while (false)
;
4809 MaxVF = MinVF;
4810 }
4811 }
4812 }
4813 return MaxVF;
4814}
4815
4816VectorizationFactor
4817LoopVectorizationCostModel::selectVectorizationFactor(unsigned MaxVF) {
4818 float Cost = expectedCost(1).first;
4819 const float ScalarCost = Cost;
4820 unsigned Width = 1;
4821 LLVM_DEBUG(dbgs() << "LV: Scalar loop costs: " << (int)ScalarCost << ".\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("loop-vectorize")) { dbgs() << "LV: Scalar loop costs: "
<< (int)ScalarCost << ".\n"; } } while (false)
;
4822
4823 bool ForceVectorization = Hints->getForce() == LoopVectorizeHints::FK_Enabled;
4824 if (ForceVectorization && MaxVF > 1) {
4825 // Ignore scalar width, because the user explicitly wants vectorization.
4826 // Initialize cost to max so that VF = 2 is, at least, chosen during cost
4827 // evaluation.
4828 Cost = std::numeric_limits<float>::max();
4829 }
4830
4831 for (unsigned i = 2; i <= MaxVF; i *= 2) {
4832 // Notice that the vector loop needs to be executed less times, so
4833 // we need to divide the cost of the vector loops by the width of
4834 // the vector elements.
4835 VectorizationCostTy C = expectedCost(i);
4836 float VectorCost = C.first / (float)i;
4837 LLVM_DEBUG(dbgs() << "LV: Vector loop of width " << ido { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("loop-vectorize")) { dbgs() << "LV: Vector loop of width "
<< i << " costs: " << (int)VectorCost <<
".\n"; } } while (false)
4838 << " costs: " << (int)VectorCost << ".\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("loop-vectorize")) { dbgs() << "LV: Vector loop of width "
<< i << " costs: " << (int)VectorCost <<
".\n"; } } while (false)
;
4839 if (!C.second && !ForceVectorization) {
4840 LLVM_DEBUG(do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("loop-vectorize")) { dbgs() << "LV: Not considering vector loop of width "
<< i << " because it will not generate any vector instructions.\n"
; } } while (false)
4841 dbgs() << "LV: Not considering vector loop of width " << ido { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("loop-vectorize")) { dbgs() << "LV: Not considering vector loop of width "
<< i << " because it will not generate any vector instructions.\n"
; } } while (false)
4842 << " because it will not generate any vector instructions.\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("loop-vectorize")) { dbgs() << "LV: Not considering vector loop of width "
<< i << " because it will not generate any vector instructions.\n"
; } } while (false)
;
4843 continue;
4844 }
4845 if (VectorCost < Cost) {
4846 Cost = VectorCost;
4847 Width = i;
4848 }
4849 }
4850
4851 if (!EnableCondStoresVectorization && NumPredStores) {
4852 ORE->emit(createMissedAnalysis("ConditionalStore")
4853 << "store that is conditionally executed prevents vectorization");
4854 LLVM_DEBUG(do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("loop-vectorize")) { dbgs() << "LV: No vectorization. There are conditional stores.\n"
; } } while (false)
4855 dbgs() << "LV: No vectorization. There are conditional stores.\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("loop-vectorize")) { dbgs() << "LV: No vectorization. There are conditional stores.\n"
; } } while (false)
;
4856 Width = 1;
4857 Cost = ScalarCost;
4858 }
4859
4860 LLVM_DEBUG(if (ForceVectorization && Width > 1 && Cost >= ScalarCost) dbgs()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("loop-vectorize")) { if (ForceVectorization && Width
> 1 && Cost >= ScalarCost) dbgs() << "LV: Vectorization seems to be not beneficial, "
<< "but was forced by a user.\n"; } } while (false)
4861 << "LV: Vectorization seems to be not beneficial, "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("loop-vectorize")) { if (ForceVectorization && Width
> 1 && Cost >= ScalarCost) dbgs() << "LV: Vectorization seems to be not beneficial, "
<< "but was forced by a user.\n"; } } while (false)
4862 << "but was forced by a user.\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("loop-vectorize")) { if (ForceVectorization && Width
> 1 && Cost >= ScalarCost) dbgs() << "LV: Vectorization seems to be not beneficial, "
<< "but was forced by a user.\n"; } } while (false)
;
4863 LLVM_DEBUG(dbgs() << "LV: Selecting VF: " << Width << ".\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("loop-vectorize")) { dbgs() << "LV: Selecting VF: " <<
Width << ".\n"; } } while (false)
;
4864 VectorizationFactor Factor = {Width, (unsigned)(Width * Cost)};
4865 return Factor;
4866}
4867
4868std::pair<unsigned, unsigned>
4869LoopVectorizationCostModel::getSmallestAndWidestTypes() {
4870 unsigned MinWidth = -1U;
4871 unsigned MaxWidth = 8;
4872 const DataLayout &DL = TheFunction->getParent()->getDataLayout();
4873
4874 // For each block.
4875 for (BasicBlock *BB : TheLoop->blocks()) {
4876 // For each instruction in the loop.
4877 for (Instruction &I : BB->instructionsWithoutDebug()) {
4878 Type *T = I.getType();
4879
4880 // Skip ignored values.
4881 if (ValuesToIgnore.find(&I) != ValuesToIgnore.end())
4882 continue;
4883
4884 // Only examine Loads, Stores and PHINodes.
4885 if (!isa<LoadInst>(I) && !isa<StoreInst>(I) && !isa<PHINode>(I))
4886 continue;
4887
4888 // Examine PHI nodes that are reduction variables. Update the type to
4889 // account for the recurrence type.
4890 if (auto *PN = dyn_cast<PHINode>(&I)) {
4891 if (!Legal->isReductionVariable(PN))
4892 continue;
4893 RecurrenceDescriptor RdxDesc = (*Legal->getReductionVars())[PN];
4894 T = RdxDesc.getRecurrenceType();
4895 }
4896
4897 // Examine the stored values.
4898 if (auto *ST = dyn_cast<StoreInst>(&I))
4899 T = ST->getValueOperand()->getType();
4900
4901 // Ignore loaded pointer types and stored pointer types that are not
4902 // vectorizable.
4903 //
4904 // FIXME: The check here attempts to predict whether a load or store will
4905 // be vectorized. We only know this for certain after a VF has
4906 // been selected. Here, we assume that if an access can be
4907 // vectorized, it will be. We should also look at extending this
4908 // optimization to non-pointer types.
4909 //
4910 if (T->isPointerTy() && !isConsecutiveLoadOrStore(&I) &&
4911 !isAccessInterleaved(&I) && !isLegalGatherOrScatter(&I))
4912 continue;
4913
4914 MinWidth = std::min(MinWidth,
4915 (unsigned)DL.getTypeSizeInBits(T->getScalarType()));
4916 MaxWidth = std::max(MaxWidth,
4917 (unsigned)DL.getTypeSizeInBits(T->getScalarType()));
4918 }
4919 }
4920
4921 return {MinWidth, MaxWidth};
4922}
4923
4924unsigned LoopVectorizationCostModel::selectInterleaveCount(bool OptForSize,
4925 unsigned VF,
4926 unsigned LoopCost) {
4927 // -- The interleave heuristics --
4928 // We interleave the loop in order to expose ILP and reduce the loop overhead.
4929 // There are many micro-architectural considerations that we can't predict
4930 // at this level. For example, frontend pressure (on decode or fetch) due to
4931 // code size, or the number and capabilities of the execution ports.
4932 //
4933 // We use the following heuristics to select the interleave count:
4934 // 1. If the code has reductions, then we interleave to break the cross
4935 // iteration dependency.
4936 // 2. If the loop is really small, then we interleave to reduce the loop
4937 // overhead.
4938 // 3. We don't interleave if we think that we will spill registers to memory
4939 // due to the increased register pressure.
4940
4941 // When we optimize for size, we don't interleave.
4942 if (OptForSize)
4943 return 1;
4944
4945 // We used the distance for the interleave count.
4946 if (Legal->getMaxSafeDepDistBytes() != -1U)
4947 return 1;
4948
4949 // Do not interleave loops with a relatively small trip count.
4950 unsigned TC = PSE.getSE()->getSmallConstantTripCount(TheLoop);
4951 if (TC > 1 && TC < TinyTripCountInterleaveThreshold)
4952 return 1;
4953
4954 unsigned TargetNumRegisters = TTI.getNumberOfRegisters(VF > 1);
4955 LLVM_DEBUG(dbgs() << "LV: The target has " << TargetNumRegistersdo { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("loop-vectorize")) { dbgs() << "LV: The target has " <<
TargetNumRegisters << " registers\n"; } } while (false
)
4956 << " registers\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("loop-vectorize")) { dbgs() << "LV: The target has " <<
TargetNumRegisters << " registers\n"; } } while (false
)
;
4957
4958 if (VF == 1) {
4959 if (ForceTargetNumScalarRegs.getNumOccurrences() > 0)
4960 TargetNumRegisters = ForceTargetNumScalarRegs;
4961 } else {
4962 if (ForceTargetNumVectorRegs.getNumOccurrences() > 0)
4963 TargetNumRegisters = ForceTargetNumVectorRegs;
4964 }
4965
4966 RegisterUsage R = calculateRegisterUsage({VF})[0];
4967 // We divide by these constants so assume that we have at least one
4968 // instruction that uses at least one register.
4969 R.MaxLocalUsers = std::max(R.MaxLocalUsers, 1U);
4970
4971 // We calculate the interleave count using the following formula.
4972 // Subtract the number of loop invariants from the number of available
4973 // registers. These registers are used by all of the interleaved instances.
4974 // Next, divide the remaining registers by the number of registers that is
4975 // required by the loop, in order to estimate how many parallel instances
4976 // fit without causing spills. All of this is rounded down if necessary to be
4977 // a power of two. We want power of two interleave count to simplify any
4978 // addressing operations or alignment considerations.
4979 // We also want power of two interleave counts to ensure that the induction
4980 // variable of the vector loop wraps to zero, when tail is folded by masking;
4981 // this currently happens when OptForSize, in which case IC is set to 1 above.
4982 unsigned IC = PowerOf2Floor((TargetNumRegisters - R.LoopInvariantRegs) /
4983 R.MaxLocalUsers);
4984
4985 // Don't count the induction variable as interleaved.
4986 if (EnableIndVarRegisterHeur)
4987 IC = PowerOf2Floor((TargetNumRegisters - R.LoopInvariantRegs - 1) /
4988 std::max(1U, (R.MaxLocalUsers - 1)));
4989
4990 // Clamp the interleave ranges to reasonable counts.
4991 unsigned MaxInterleaveCount = TTI.getMaxInterleaveFactor(VF);
4992
4993 // Check if the user has overridden the max.
4994 if (VF == 1) {
4995 if (ForceTargetMaxScalarInterleaveFactor.getNumOccurrences() > 0)
4996 MaxInterleaveCount = ForceTargetMaxScalarInterleaveFactor;
4997 } else {
4998 if (ForceTargetMaxVectorInterleaveFactor.getNumOccurrences() > 0)
4999 MaxInterleaveCount = ForceTargetMaxVectorInterleaveFactor;
5000 }
5001
5002 // If we did not calculate the cost for VF (because the user selected the VF)
5003 // then we calculate the cost of VF here.
5004 if (LoopCost == 0)
5005 LoopCost = expectedCost(VF).first;
5006
5007 assert(LoopCost && "Non-zero loop cost expected")((LoopCost && "Non-zero loop cost expected") ? static_cast
<void> (0) : __assert_fail ("LoopCost && \"Non-zero loop cost expected\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 5007, __PRETTY_FUNCTION__))
;
5008
5009 // Clamp the calculated IC to be between the 1 and the max interleave count
5010 // that the target allows.
5011 if (IC > MaxInterleaveCount)
5012 IC = MaxInterleaveCount;
5013 else if (IC < 1)
5014 IC = 1;
5015
5016 // Interleave if we vectorized this loop and there is a reduction that could
5017 // benefit from interleaving.
5018 if (VF > 1 && !Legal->getReductionVars()->empty()) {
5019 LLVM_DEBUG(dbgs() << "LV: Interleaving because of reductions.\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("loop-vectorize")) { dbgs() << "LV: Interleaving because of reductions.\n"
; } } while (false)
;
5020 return IC;
5021 }
5022
5023 // Note that if we've already vectorized the loop we will have done the
5024 // runtime check and so interleaving won't require further checks.
5025 bool InterleavingRequiresRuntimePointerCheck =
5026 (VF == 1 && Legal->getRuntimePointerChecking()->Need);
5027
5028 // We want to interleave small loops in order to reduce the loop overhead and
5029 // potentially expose ILP opportunities.
5030 LLVM_DEBUG(dbgs() << "LV: Loop cost is " << LoopCost << '\n')do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("loop-vectorize")) { dbgs() << "LV: Loop cost is " <<
LoopCost << '\n'; } } while (false)
;
5031 if (!InterleavingRequiresRuntimePointerCheck && LoopCost < SmallLoopCost) {
5032 // We assume that the cost overhead is 1 and we use the cost model
5033 // to estimate the cost of the loop and interleave until the cost of the
5034 // loop overhead is about 5% of the cost of the loop.
5035 unsigned SmallIC =
5036 std::min(IC, (unsigned)PowerOf2Floor(SmallLoopCost / LoopCost));
5037
5038 // Interleave until store/load ports (estimated by max interleave count) are
5039 // saturated.
5040 unsigned NumStores = Legal->getNumStores();
5041 unsigned NumLoads = Legal->getNumLoads();
5042 unsigned StoresIC = IC / (NumStores ? NumStores : 1);
5043 unsigned LoadsIC = IC / (NumLoads ? NumLoads : 1);
5044
5045 // If we have a scalar reduction (vector reductions are already dealt with
5046 // by this point), we can increase the critical path length if the loop
5047 // we're interleaving is inside another loop. Limit, by default to 2, so the
5048 // critical path only gets increased by one reduction operation.
5049 if (!Legal->getReductionVars()->empty() && TheLoop->getLoopDepth() > 1) {
5050 unsigned F = static_cast<unsigned>(MaxNestedScalarReductionIC);
5051 SmallIC = std::min(SmallIC, F);
5052 StoresIC = std::min(StoresIC, F);
5053 LoadsIC = std::min(LoadsIC, F);
5054 }
5055
5056 if (EnableLoadStoreRuntimeInterleave &&
5057 std::max(StoresIC, LoadsIC) > SmallIC) {
5058 LLVM_DEBUG(do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("loop-vectorize")) { dbgs() << "LV: Interleaving to saturate store or load ports.\n"
; } } while (false)
5059 dbgs() << "LV: Interleaving to saturate store or load ports.\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("loop-vectorize")) { dbgs() << "LV: Interleaving to saturate store or load ports.\n"
; } } while (false)
;
5060 return std::max(StoresIC, LoadsIC);
5061 }
5062
5063 LLVM_DEBUG(dbgs() << "LV: Interleaving to reduce branch cost.\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("loop-vectorize")) { dbgs() << "LV: Interleaving to reduce branch cost.\n"
; } } while (false)
;
5064 return SmallIC;
5065 }
5066
5067 // Interleave if this is a large loop (small loops are already dealt with by
5068 // this point) that could benefit from interleaving.
5069 bool HasReductions = !Legal->getReductionVars()->empty();
5070 if (TTI.enableAggressiveInterleaving(HasReductions)) {
5071 LLVM_DEBUG(dbgs() << "LV: Interleaving to expose ILP.\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("loop-vectorize")) { dbgs() << "LV: Interleaving to expose ILP.\n"
; } } while (false)
;
5072 return IC;
5073 }
5074
5075 LLVM_DEBUG(dbgs() << "LV: Not Interleaving.\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("loop-vectorize")) { dbgs() << "LV: Not Interleaving.\n"
; } } while (false)
;
5076 return 1;
5077}
5078
5079SmallVector<LoopVectorizationCostModel::RegisterUsage, 8>
5080LoopVectorizationCostModel::calculateRegisterUsage(ArrayRef<unsigned> VFs) {
5081 // This function calculates the register usage by measuring the highest number
5082 // of values that are alive at a single location. Obviously, this is a very
5083 // rough estimation. We scan the loop in a topological order in order and
5084 // assign a number to each instruction. We use RPO to ensure that defs are
5085 // met before their users. We assume that each instruction that has in-loop
5086 // users starts an interval. We record every time that an in-loop value is
5087 // used, so we have a list of the first and last occurrences of each
5088 // instruction. Next, we transpose this data structure into a multi map that
5089 // holds the list of intervals that *end* at a specific location. This multi
5090 // map allows us to perform a linear search. We scan the instructions linearly
5091 // and record each time that a new interval starts, by placing it in a set.
5092 // If we find this value in the multi-map then we remove it from the set.
5093 // The max register usage is the maximum size of the set.
5094 // We also search for instructions that are defined outside the loop, but are
5095 // used inside the loop. We need this number separately from the max-interval
5096 // usage number because when we unroll, loop-invariant values do not take
5097 // more register.
5098 LoopBlocksDFS DFS(TheLoop);
5099 DFS.perform(LI);
5100
5101 RegisterUsage RU;
5102
5103 // Each 'key' in the map opens a new interval. The values
5104 // of the map are the index of the 'last seen' usage of the
5105 // instruction that is the key.
5106 using IntervalMap = DenseMap<Instruction *, unsigned>;
5107
5108 // Maps instruction to its index.
5109 SmallVector<Instruction *, 64> IdxToInstr;
5110 // Marks the end of each interval.
5111 IntervalMap EndPoint;
5112 // Saves the list of instruction indices that are used in the loop.
5113 SmallPtrSet<Instruction *, 8> Ends;
5114 // Saves the list of values that are used in the loop but are
5115 // defined outside the loop, such as arguments and constants.
5116 SmallPtrSet<Value *, 8> LoopInvariants;
5117
5118 for (BasicBlock *BB : make_range(DFS.beginRPO(), DFS.endRPO())) {
5119 for (Instruction &I : BB->instructionsWithoutDebug()) {
5120 IdxToInstr.push_back(&I);
5121
5122 // Save the end location of each USE.
5123 for (Value *U : I.operands()) {
5124 auto *Instr = dyn_cast<Instruction>(U);
5125
5126 // Ignore non-instruction values such as arguments, constants, etc.
5127 if (!Instr)
5128 continue;
5129
5130 // If this instruction is outside the loop then record it and continue.
5131 if (!TheLoop->contains(Instr)) {
5132 LoopInvariants.insert(Instr);
5133 continue;
5134 }
5135
5136 // Overwrite previous end points.
5137 EndPoint[Instr] = IdxToInstr.size();
5138 Ends.insert(Instr);
5139 }
5140 }
5141 }
5142
5143 // Saves the list of intervals that end with the index in 'key'.
5144 using InstrList = SmallVector<Instruction *, 2>;
5145 DenseMap<unsigned, InstrList> TransposeEnds;
5146
5147 // Transpose the EndPoints to a list of values that end at each index.
5148 for (auto &Interval : EndPoint)
5149 TransposeEnds[Interval.second].push_back(Interval.first);
5150
5151 SmallPtrSet<Instruction *, 8> OpenIntervals;
5152
5153 // Get the size of the widest register.
5154 unsigned MaxSafeDepDist = -1U;
5155 if (Legal->getMaxSafeDepDistBytes() != -1U)
5156 MaxSafeDepDist = Legal->getMaxSafeDepDistBytes() * 8;
5157 unsigned WidestRegister =
5158 std::min(TTI.getRegisterBitWidth(true), MaxSafeDepDist);
5159 const DataLayout &DL = TheFunction->getParent()->getDataLayout();
5160
5161 SmallVector<RegisterUsage, 8> RUs(VFs.size());
5162 SmallVector<unsigned, 8> MaxUsages(VFs.size(), 0);
5163
5164 LLVM_DEBUG(dbgs() << "LV(REG): Calculating max register usage:\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("loop-vectorize")) { dbgs() << "LV(REG): Calculating max register usage:\n"
; } } while (false)
;
5165
5166 // A lambda that gets the register usage for the given type and VF.
5167 auto GetRegUsage = [&DL, WidestRegister](Type *Ty, unsigned VF) {
5168 if (Ty->isTokenTy())
5169 return 0U;
5170 unsigned TypeSize = DL.getTypeSizeInBits(Ty->getScalarType());
5171 return std::max<unsigned>(1, VF * TypeSize / WidestRegister);
5172 };
5173
5174 for (unsigned int i = 0, s = IdxToInstr.size(); i < s; ++i) {
5175 Instruction *I = IdxToInstr[i];
5176
5177 // Remove all of the instructions that end at this location.
5178 InstrList &List = TransposeEnds[i];
5179 for (Instruction *ToRemove : List)
5180 OpenIntervals.erase(ToRemove);
5181
5182 // Ignore instructions that are never used within the loop.
5183 if (Ends.find(I) == Ends.end())
5184 continue;
5185
5186 // Skip ignored values.
5187 if (ValuesToIgnore.find(I) != ValuesToIgnore.end())
5188 continue;
5189
5190 // For each VF find the maximum usage of registers.
5191 for (unsigned j = 0, e = VFs.size(); j < e; ++j) {
5192 if (VFs[j] == 1) {
5193 MaxUsages[j] = std::max(MaxUsages[j], OpenIntervals.size());
5194 continue;
5195 }
5196 collectUniformsAndScalars(VFs[j]);
5197 // Count the number of live intervals.
5198 unsigned RegUsage = 0;
5199 for (auto Inst : OpenIntervals) {
5200 // Skip ignored values for VF > 1.
5201 if (VecValuesToIgnore.find(Inst) != VecValuesToIgnore.end() ||
5202 isScalarAfterVectorization(Inst, VFs[j]))
5203 continue;
5204 RegUsage += GetRegUsage(Inst->getType(), VFs[j]);
5205 }
5206 MaxUsages[j] = std::max(MaxUsages[j], RegUsage);
5207 }
5208
5209 LLVM_DEBUG(dbgs() << "LV(REG): At #" << i << " Interval # "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("loop-vectorize")) { dbgs() << "LV(REG): At #" <<
i << " Interval # " << OpenIntervals.size() <<
'\n'; } } while (false)
5210 << OpenIntervals.size() << '\n')do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("loop-vectorize")) { dbgs() << "LV(REG): At #" <<
i << " Interval # " << OpenIntervals.size() <<
'\n'; } } while (false)
;
5211
5212 // Add the current instruction to the list of open intervals.
5213 OpenIntervals.insert(I);
5214 }
5215
5216 for (unsigned i = 0, e = VFs.size(); i < e; ++i) {
5217 unsigned Invariant = 0;
5218 if (VFs[i] == 1)
5219 Invariant = LoopInvariants.size();
5220 else {
5221 for (auto Inst : LoopInvariants)
5222 Invariant += GetRegUsage(Inst->getType(), VFs[i]);
5223 }
5224
5225 LLVM_DEBUG(dbgs() << "LV(REG): VF = " << VFs[i] << '\n')do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("loop-vectorize")) { dbgs() << "LV(REG): VF = " <<
VFs[i] << '\n'; } } while (false)
;
5226 LLVM_DEBUG(dbgs() << "LV(REG): Found max usage: " << MaxUsages[i] << '\n')do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("loop-vectorize")) { dbgs() << "LV(REG): Found max usage: "
<< MaxUsages[i] << '\n'; } } while (false)
;
5227 LLVM_DEBUG(dbgs() << "LV(REG): Found invariant usage: " << Invariantdo { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("loop-vectorize")) { dbgs() << "LV(REG): Found invariant usage: "
<< Invariant << '\n'; } } while (false)
5228 << '\n')do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("loop-vectorize")) { dbgs() << "LV(REG): Found invariant usage: "
<< Invariant << '\n'; } } while (false)
;
5229
5230 RU.LoopInvariantRegs = Invariant;
5231 RU.MaxLocalUsers = MaxUsages[i];
5232 RUs[i] = RU;
5233 }
5234
5235 return RUs;
5236}
5237
5238bool LoopVectorizationCostModel::useEmulatedMaskMemRefHack(Instruction *I){
5239 // TODO: Cost model for emulated masked load/store is completely
5240 // broken. This hack guides the cost model to use an artificially
5241 // high enough value to practically disable vectorization with such
5242 // operations, except where previously deployed legality hack allowed
5243 // using very low cost values. This is to avoid regressions coming simply
5244 // from moving "masked load/store" check from legality to cost model.
5245 // Masked Load/Gather emulation was previously never allowed.
5246 // Limited number of Masked Store/Scatter emulation was allowed.
5247 assert(isPredicatedInst(I) && "Expecting a scalar emulated instruction")((isPredicatedInst(I) && "Expecting a scalar emulated instruction"
) ? static_cast<void> (0) : __assert_fail ("isPredicatedInst(I) && \"Expecting a scalar emulated instruction\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 5247, __PRETTY_FUNCTION__))
;
5248 return isa<LoadInst>(I) ||
5249 (isa<StoreInst>(I) &&
5250 NumPredStores > NumberOfStoresToPredicate);
5251}
5252
5253void LoopVectorizationCostModel::collectInstsToScalarize(unsigned VF) {
5254 // If we aren't vectorizing the loop, or if we've already collected the
5255 // instructions to scalarize, there's nothing to do. Collection may already
5256 // have occurred if we have a user-selected VF and are now computing the
5257 // expected cost for interleaving.
5258 if (VF < 2 || InstsToScalarize.find(VF) != InstsToScalarize.end())
5259 return;
5260
5261 // Initialize a mapping for VF in InstsToScalalarize. If we find that it's
5262 // not profitable to scalarize any instructions, the presence of VF in the
5263 // map will indicate that we've analyzed it already.
5264 ScalarCostsTy &ScalarCostsVF = InstsToScalarize[VF];
5265
5266 // Find all the instructions that are scalar with predication in the loop and
5267 // determine if it would be better to not if-convert the blocks they are in.
5268 // If so, we also record the instructions to scalarize.
5269 for (BasicBlock *BB : TheLoop->blocks()) {
5270 if (!blockNeedsPredication(BB))
5271 continue;
5272 for (Instruction &I : *BB)
5273 if (isScalarWithPredication(&I)) {
5274 ScalarCostsTy ScalarCosts;
5275 // Do not apply discount logic if hacked cost is needed
5276 // for emulated masked memrefs.
5277 if (!useEmulatedMaskMemRefHack(&I) &&
5278 computePredInstDiscount(&I, ScalarCosts, VF) >= 0)
5279 ScalarCostsVF.insert(ScalarCosts.begin(), ScalarCosts.end());
5280 // Remember that BB will remain after vectorization.
5281 PredicatedBBsAfterVectorization.insert(BB);
5282 }
5283 }
5284}
5285
5286int LoopVectorizationCostModel::computePredInstDiscount(
5287 Instruction *PredInst, DenseMap<Instruction *, unsigned> &ScalarCosts,
5288 unsigned VF) {
5289 assert(!isUniformAfterVectorization(PredInst, VF) &&((!isUniformAfterVectorization(PredInst, VF) && "Instruction marked uniform-after-vectorization will be predicated"
) ? static_cast<void> (0) : __assert_fail ("!isUniformAfterVectorization(PredInst, VF) && \"Instruction marked uniform-after-vectorization will be predicated\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 5290, __PRETTY_FUNCTION__))
5290 "Instruction marked uniform-after-vectorization will be predicated")((!isUniformAfterVectorization(PredInst, VF) && "Instruction marked uniform-after-vectorization will be predicated"
) ? static_cast<void> (0) : __assert_fail ("!isUniformAfterVectorization(PredInst, VF) && \"Instruction marked uniform-after-vectorization will be predicated\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 5290, __PRETTY_FUNCTION__))
;
5291
5292 // Initialize the discount to zero, meaning that the scalar version and the
5293 // vector version cost the same.
5294 int Discount = 0;
5295
5296 // Holds instructions to analyze. The instructions we visit are mapped in
5297 // ScalarCosts. Those instructions are the ones that would be scalarized if
5298 // we find that the scalar version costs less.
5299 SmallVector<Instruction *, 8> Worklist;
5300
5301 // Returns true if the given instruction can be scalarized.
5302 auto canBeScalarized = [&](Instruction *I) -> bool {
5303 // We only attempt to scalarize instructions forming a single-use chain
5304 // from the original predicated block that would otherwise be vectorized.
5305 // Although not strictly necessary, we give up on instructions we know will
5306 // already be scalar to avoid traversing chains that are unlikely to be
5307 // beneficial.
5308 if (!I->hasOneUse() || PredInst->getParent() != I->getParent() ||
5309 isScalarAfterVectorization(I, VF))
5310 return false;
5311
5312 // If the instruction is scalar with predication, it will be analyzed
5313 // separately. We ignore it within the context of PredInst.
5314 if (isScalarWithPredication(I))
5315 return false;
5316
5317 // If any of the instruction's operands are uniform after vectorization,
5318 // the instruction cannot be scalarized. This prevents, for example, a
5319 // masked load from being scalarized.
5320 //
5321 // We assume we will only emit a value for lane zero of an instruction
5322 // marked uniform after vectorization, rather than VF identical values.
5323 // Thus, if we scalarize an instruction that uses a uniform, we would
5324 // create uses of values corresponding to the lanes we aren't emitting code
5325 // for. This behavior can be changed by allowing getScalarValue to clone
5326 // the lane zero values for uniforms rather than asserting.
5327 for (Use &U : I->operands())
5328 if (auto *J = dyn_cast<Instruction>(U.get()))
5329 if (isUniformAfterVectorization(J, VF))
5330 return false;
5331
5332 // Otherwise, we can scalarize the instruction.
5333 return true;
5334 };
5335
5336 // Returns true if an operand that cannot be scalarized must be extracted
5337 // from a vector. We will account for this scalarization overhead below. Note
5338 // that the non-void predicated instructions are placed in their own blocks,
5339 // and their return values are inserted into vectors. Thus, an extract would
5340 // still be required.
5341 auto needsExtract = [&](Instruction *I) -> bool {
5342 return TheLoop->contains(I) && !isScalarAfterVectorization(I, VF);
5343 };
5344
5345 // Compute the expected cost discount from scalarizing the entire expression
5346 // feeding the predicated instruction. We currently only consider expressions
5347 // that are single-use instruction chains.
5348 Worklist.push_back(PredInst);
5349 while (!Worklist.empty()) {
5350 Instruction *I = Worklist.pop_back_val();
5351
5352 // If we've already analyzed the instruction, there's nothing to do.
5353 if (ScalarCosts.find(I) != ScalarCosts.end())
5354 continue;
5355
5356 // Compute the cost of the vector instruction. Note that this cost already
5357 // includes the scalarization overhead of the predicated instruction.
5358 unsigned VectorCost = getInstructionCost(I, VF).first;
5359
5360 // Compute the cost of the scalarized instruction. This cost is the cost of
5361 // the instruction as if it wasn't if-converted and instead remained in the
5362 // predicated block. We will scale this cost by block probability after
5363 // computing the scalarization overhead.
5364 unsigned ScalarCost = VF * getInstructionCost(I, 1).first;
5365
5366 // Compute the scalarization overhead of needed insertelement instructions
5367 // and phi nodes.
5368 if (isScalarWithPredication(I) && !I->getType()->isVoidTy()) {
5369 ScalarCost += TTI.getScalarizationOverhead(ToVectorTy(I->getType(), VF),
5370 true, false);
5371 ScalarCost += VF * TTI.getCFInstrCost(Instruction::PHI);
5372 }
5373
5374 // Compute the scalarization overhead of needed extractelement
5375 // instructions. For each of the instruction's operands, if the operand can
5376 // be scalarized, add it to the worklist; otherwise, account for the
5377 // overhead.
5378 for (Use &U : I->operands())
5379 if (auto *J = dyn_cast<Instruction>(U.get())) {
5380 assert(VectorType::isValidElementType(J->getType()) &&((VectorType::isValidElementType(J->getType()) && "Instruction has non-scalar type"
) ? static_cast<void> (0) : __assert_fail ("VectorType::isValidElementType(J->getType()) && \"Instruction has non-scalar type\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 5381, __PRETTY_FUNCTION__))
5381 "Instruction has non-scalar type")((VectorType::isValidElementType(J->getType()) && "Instruction has non-scalar type"
) ? static_cast<void> (0) : __assert_fail ("VectorType::isValidElementType(J->getType()) && \"Instruction has non-scalar type\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 5381, __PRETTY_FUNCTION__))
;
5382 if (canBeScalarized(J))
5383 Worklist.push_back(J);
5384 else if (needsExtract(J))
5385 ScalarCost += TTI.getScalarizationOverhead(
5386 ToVectorTy(J->getType(),VF), false, true);
5387 }
5388
5389 // Scale the total scalar cost by block probability.
5390 ScalarCost /= getReciprocalPredBlockProb();
5391
5392 // Compute the discount. A non-negative discount means the vector version
5393 // of the instruction costs more, and scalarizing would be beneficial.
5394 Discount += VectorCost - ScalarCost;
5395 ScalarCosts[I] = ScalarCost;
5396 }
5397
5398 return Discount;
5399}
5400
5401LoopVectorizationCostModel::VectorizationCostTy
5402LoopVectorizationCostModel::expectedCost(unsigned VF) {
5403 VectorizationCostTy Cost;
5404
5405 // For each block.
5406 for (BasicBlock *BB : TheLoop->blocks()) {
5407 VectorizationCostTy BlockCost;
5408
5409 // For each instruction in the old loop.
5410 for (Instruction &I : BB->instructionsWithoutDebug()) {
5411 // Skip ignored values.
5412 if (ValuesToIgnore.find(&I) != ValuesToIgnore.end() ||
5413 (VF > 1 && VecValuesToIgnore.find(&I) != VecValuesToIgnore.end()))
5414 continue;
5415
5416 VectorizationCostTy C = getInstructionCost(&I, VF);
5417
5418 // Check if we should override the cost.
5419 if (ForceTargetInstructionCost.getNumOccurrences() > 0)
5420 C.first = ForceTargetInstructionCost;
5421
5422 BlockCost.first += C.first;
5423 BlockCost.second |= C.second;
5424 LLVM_DEBUG(dbgs() << "LV: Found an estimated cost of " << C.firstdo { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("loop-vectorize")) { dbgs() << "LV: Found an estimated cost of "
<< C.first << " for VF " << VF << " For instruction: "
<< I << '\n'; } } while (false)
5425 << " for VF " << VF << " For instruction: " << Ido { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("loop-vectorize")) { dbgs() << "LV: Found an estimated cost of "
<< C.first << " for VF " << VF << " For instruction: "
<< I << '\n'; } } while (false)
5426 << '\n')do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("loop-vectorize")) { dbgs() << "LV: Found an estimated cost of "
<< C.first << " for VF " << VF << " For instruction: "
<< I << '\n'; } } while (false)
;
5427 }
5428
5429 // If we are vectorizing a predicated block, it will have been
5430 // if-converted. This means that the block's instructions (aside from
5431 // stores and instructions that may divide by zero) will now be
5432 // unconditionally executed. For the scalar case, we may not always execute
5433 // the predicated block. Thus, scale the block's cost by the probability of
5434 // executing it.
5435 if (VF == 1 && blockNeedsPredication(BB))
5436 BlockCost.first /= getReciprocalPredBlockProb();
5437
5438 Cost.first += BlockCost.first;
5439 Cost.second |= BlockCost.second;
5440 }
5441
5442 return Cost;
5443}
5444
5445/// Gets Address Access SCEV after verifying that the access pattern
5446/// is loop invariant except the induction variable dependence.
5447///
5448/// This SCEV can be sent to the Target in order to estimate the address
5449/// calculation cost.
5450static const SCEV *getAddressAccessSCEV(
5451 Value *Ptr,
5452 LoopVectorizationLegality *Legal,
5453 PredicatedScalarEvolution &PSE,
5454 const Loop *TheLoop) {
5455
5456 auto *Gep = dyn_cast<GetElementPtrInst>(Ptr);
5457 if (!Gep)
5458 return nullptr;
5459
5460 // We are looking for a gep with all loop invariant indices except for one
5461 // which should be an induction variable.
5462 auto SE = PSE.getSE();
5463 unsigned NumOperands = Gep->getNumOperands();
5464 for (unsigned i = 1; i < NumOperands; ++i) {
5465 Value *Opd = Gep->getOperand(i);
5466 if (!SE->isLoopInvariant(SE->getSCEV(Opd), TheLoop) &&
5467 !Legal->isInductionVariable(Opd))
5468 return nullptr;
5469 }
5470
5471 // Now we know we have a GEP ptr, %inv, %ind, %inv. return the Ptr SCEV.
5472 return PSE.getSCEV(Ptr);
5473}
5474
5475static bool isStrideMul(Instruction *I, LoopVectorizationLegality *Legal) {
5476 return Legal->hasStride(I->getOperand(0)) ||
5477 Legal->hasStride(I->getOperand(1));
5478}
5479
5480unsigned LoopVectorizationCostModel::getMemInstScalarizationCost(Instruction *I,
5481 unsigned VF) {
5482 assert(VF > 1 && "Scalarization cost of instruction implies vectorization.")((VF > 1 && "Scalarization cost of instruction implies vectorization."
) ? static_cast<void> (0) : __assert_fail ("VF > 1 && \"Scalarization cost of instruction implies vectorization.\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Transforms/Vectorize/LoopVectorize.cpp"
, 5482, __PRETTY_FUNCTION__))
;
5483 Type *ValTy = getMemInstValueType(I);
5484 auto SE = PSE.getSE();
5485
5486 unsigned Alignment = getLoadStoreAlignment(I);
5487 unsigned AS = getLoadStoreAddressSpace(I);
5488 Value *Ptr = getLoadStorePointerOperand(I);
5489 Type *PtrTy = ToVectorTy(Ptr->getType(), VF);
5490
5491 // Figure out whether the access is strided and get the stride value
5492 // if it's known in compile time
5493 const SCEV *PtrSCEV = getAddressAccessSCEV(Ptr, Legal, PSE, TheLoop);
5494
5495 // Get the cost of the scalar memory instruction and address computation.
5496 unsigned Cost = VF * TTI.getAddressComputationCost(PtrTy, SE, PtrSCEV);
5497
5498 // Don't pass *I here, since it is scalar but will actually be part of a
5499 // vectorized loop where the user of it is a vectorized instruction.
5500 Cost += VF *
5501 TTI.getMemoryOpCost(I->getOpcode(), ValTy->getScalarType(), Alignment,
5502 AS);
5503
5504 // Get the overhead of the extractelement and insertelement instructions
5505 // we might create due to scalarization.
5506 Cost += getScalarizationOverhead(I, VF);
5507
5508 // If we have a predicated store, it may not be executed for each vector
5509 // lane. Scale the cost by the probability of executing the predicated
5510 // block.
5511 if (isPredicatedInst(I)) {
5512 Cost /= getReciprocalPredBlockProb();
5513
5514 if (useEmulatedMaskMemRefHack(I))
5515 // Artificially setting to a high enough value to practically disable
5516 // vectorization with such operations.
5517 Cost = 3000000;
5518 }
5519
5520 return Cost;
5521}
5522
5523