LLVM 20.0.0git
LoopVectorizationPlanner.h
Go to the documentation of this file.
1//===- LoopVectorizationPlanner.h - Planner for LoopVectorization ---------===//
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/// \file
10/// This file provides a LoopVectorizationPlanner class.
11/// InnerLoopVectorizer vectorizes loops which contain only one basic
12/// LoopVectorizationPlanner - drives the vectorization process after having
13/// passed Legality checks.
14/// The planner builds and optimizes the Vectorization Plans which record the
15/// decisions how to vectorize the given loop. In particular, represent the
16/// control-flow of the vectorized version, the replication of instructions that
17/// are to be scalarized, and interleave access groups.
18///
19/// Also provides a VPlan-based builder utility analogous to IRBuilder.
20/// It provides an instruction-level API for generating VPInstructions while
21/// abstracting away the Recipe manipulation details.
22//===----------------------------------------------------------------------===//
23
24#ifndef LLVM_TRANSFORMS_VECTORIZE_LOOPVECTORIZATIONPLANNER_H
25#define LLVM_TRANSFORMS_VECTORIZE_LOOPVECTORIZATIONPLANNER_H
26
27#include "VPlan.h"
28#include "llvm/ADT/SmallSet.h"
30
31namespace llvm {
32
33class LoopInfo;
34class DominatorTree;
35class LoopVectorizationLegality;
36class LoopVectorizationCostModel;
37class PredicatedScalarEvolution;
38class LoopVectorizeHints;
39class OptimizationRemarkEmitter;
40class TargetTransformInfo;
41class TargetLibraryInfo;
42class VPRecipeBuilder;
43
44/// VPlan-based builder utility analogous to IRBuilder.
45class VPBuilder {
46 VPBasicBlock *BB = nullptr;
48
49 /// Insert \p VPI in BB at InsertPt if BB is set.
50 VPInstruction *tryInsertInstruction(VPInstruction *VPI) {
51 if (BB)
52 BB->insert(VPI, InsertPt);
53 return VPI;
54 }
55
56 VPInstruction *createInstruction(unsigned Opcode,
58 const Twine &Name = "") {
59 return tryInsertInstruction(new VPInstruction(Opcode, Operands, DL, Name));
60 }
61
62 VPInstruction *createInstruction(unsigned Opcode,
63 std::initializer_list<VPValue *> Operands,
64 DebugLoc DL, const Twine &Name = "") {
65 return createInstruction(Opcode, ArrayRef<VPValue *>(Operands), DL, Name);
66 }
67
68public:
69 VPBuilder() = default;
70 VPBuilder(VPBasicBlock *InsertBB) { setInsertPoint(InsertBB); }
71 VPBuilder(VPRecipeBase *InsertPt) { setInsertPoint(InsertPt); }
72
73 /// Clear the insertion point: created instructions will not be inserted into
74 /// a block.
76 BB = nullptr;
77 InsertPt = VPBasicBlock::iterator();
78 }
79
80 VPBasicBlock *getInsertBlock() const { return BB; }
81 VPBasicBlock::iterator getInsertPoint() const { return InsertPt; }
82
83 /// Create a VPBuilder to insert after \p R.
86 B.setInsertPoint(R->getParent(), std::next(R->getIterator()));
87 return B;
88 }
89
90 /// InsertPoint - A saved insertion point.
92 VPBasicBlock *Block = nullptr;
94
95 public:
96 /// Creates a new insertion point which doesn't point to anything.
97 VPInsertPoint() = default;
98
99 /// Creates a new insertion point at the given location.
101 : Block(InsertBlock), Point(InsertPoint) {}
102
103 /// Returns true if this insert point is set.
104 bool isSet() const { return Block != nullptr; }
105
106 VPBasicBlock *getBlock() const { return Block; }
107 VPBasicBlock::iterator getPoint() const { return Point; }
108 };
109
110 /// Sets the current insert point to a previously-saved location.
112 if (IP.isSet())
113 setInsertPoint(IP.getBlock(), IP.getPoint());
114 else
116 }
117
118 /// This specifies that created VPInstructions should be appended to the end
119 /// of the specified block.
121 assert(TheBB && "Attempting to set a null insert point");
122 BB = TheBB;
123 InsertPt = BB->end();
124 }
125
126 /// This specifies that created instructions should be inserted at the
127 /// specified point.
129 BB = TheBB;
130 InsertPt = IP;
131 }
132
133 /// This specifies that created instructions should be inserted at the
134 /// specified point.
136 BB = IP->getParent();
137 InsertPt = IP->getIterator();
138 }
139
140 /// Create an N-ary operation with \p Opcode, \p Operands and set \p Inst as
141 /// its underlying Instruction.
143 Instruction *Inst = nullptr,
144 const Twine &Name = "") {
145 DebugLoc DL;
146 if (Inst)
147 DL = Inst->getDebugLoc();
148 VPInstruction *NewVPInst = createInstruction(Opcode, Operands, DL, Name);
149 NewVPInst->setUnderlyingValue(Inst);
150 return NewVPInst;
151 }
153 DebugLoc DL, const Twine &Name = "") {
154 return createInstruction(Opcode, Operands, DL, Name);
155 }
156
158 std::initializer_list<VPValue *> Operands,
160 DebugLoc DL = {}, const Twine &Name = "") {
161 return tryInsertInstruction(
162 new VPInstruction(Opcode, Operands, WrapFlags, DL, Name));
163 }
165 const Twine &Name = "") {
166 return createInstruction(VPInstruction::Not, {Operand}, DL, Name);
167 }
168
170 const Twine &Name = "") {
171 return createInstruction(Instruction::BinaryOps::And, {LHS, RHS}, DL, Name);
172 }
173
175 const Twine &Name = "") {
176
177 return tryInsertInstruction(new VPInstruction(
178 Instruction::BinaryOps::Or, {LHS, RHS},
179 VPRecipeWithIRFlags::DisjointFlagsTy(false), DL, Name));
180 }
181
183 const Twine &Name = "") {
184 return tryInsertInstruction(
186 }
187
189 DebugLoc DL = {}, const Twine &Name = "",
190 std::optional<FastMathFlags> FMFs = std::nullopt) {
191 auto *Select =
192 FMFs ? new VPInstruction(Instruction::Select, {Cond, TrueVal, FalseVal},
193 *FMFs, DL, Name)
194 : new VPInstruction(Instruction::Select, {Cond, TrueVal, FalseVal},
195 DL, Name);
196 return tryInsertInstruction(Select);
197 }
198
199 /// Create a new ICmp VPInstruction with predicate \p Pred and operands \p A
200 /// and \p B.
201 /// TODO: add createFCmp when needed.
202 VPValue *createICmp(CmpInst::Predicate Pred, VPValue *A, VPValue *B,
203 DebugLoc DL = {}, const Twine &Name = "");
204
205 //===--------------------------------------------------------------------===//
206 // RAII helpers.
207 //===--------------------------------------------------------------------===//
208
209 /// RAII object that stores the current insertion point and restores it when
210 /// the object is destroyed.
212 VPBuilder &Builder;
213 VPBasicBlock *Block;
215
216 public:
218 : Builder(B), Block(B.getInsertBlock()), Point(B.getInsertPoint()) {}
219
222
223 ~InsertPointGuard() { Builder.restoreIP(VPInsertPoint(Block, Point)); }
224 };
225};
226
227/// TODO: The following VectorizationFactor was pulled out of
228/// LoopVectorizationCostModel class. LV also deals with
229/// VectorizerParams::VectorizationFactor.
230/// We need to streamline them.
231
232/// Information about vectorization costs.
234 /// Vector width with best cost.
236
237 /// Cost of the loop with that width.
239
240 /// Cost of the scalar loop.
242
243 /// The minimum trip count required to make vectorization profitable, e.g. due
244 /// to runtime checks.
246
250
251 /// Width 1 means no vectorization, cost 0 means uncomputed cost.
253 return {ElementCount::getFixed(1), 0, 0};
254 }
255
256 bool operator==(const VectorizationFactor &rhs) const {
257 return Width == rhs.Width && Cost == rhs.Cost;
258 }
259
260 bool operator!=(const VectorizationFactor &rhs) const {
261 return !(*this == rhs);
262 }
263};
264
265/// A class that represents two vectorization factors (initialized with 0 by
266/// default). One for fixed-width vectorization and one for scalable
267/// vectorization. This can be used by the vectorizer to choose from a range of
268/// fixed and/or scalable VFs in order to find the most cost-effective VF to
269/// vectorize with.
273
275 : FixedVF(ElementCount::getFixed(0)),
276 ScalableVF(ElementCount::getScalable(0)) {}
278 *(Max.isScalable() ? &ScalableVF : &FixedVF) = Max;
279 }
284 "Invalid scalable properties");
285 }
286
288
289 /// \return true if either fixed- or scalable VF is non-zero.
290 explicit operator bool() const { return FixedVF || ScalableVF; }
291
292 /// \return true if either fixed- or scalable VF is a valid vector VF.
293 bool hasVector() const { return FixedVF.isVector() || ScalableVF.isVector(); }
294};
295
296/// Planner drives the vectorization process after having passed
297/// Legality checks.
299 /// The loop that we evaluate.
300 Loop *OrigLoop;
301
302 /// Loop Info analysis.
303 LoopInfo *LI;
304
305 /// The dominator tree.
306 DominatorTree *DT;
307
308 /// Target Library Info.
309 const TargetLibraryInfo *TLI;
310
311 /// Target Transform Info.
313
314 /// The legality analysis.
316
317 /// The profitability analysis.
319
320 /// The interleaved access analysis.
322
324
325 const LoopVectorizeHints &Hints;
326
328
330
331 /// Profitable vector factors.
333
334 /// A builder used to construct the current plan.
335 VPBuilder Builder;
336
337 /// Computes the cost of \p Plan for vectorization factor \p VF.
338 ///
339 /// The current implementation requires access to the
340 /// LoopVectorizationLegality to handle inductions and reductions, which is
341 /// why it is kept separate from the VPlan-only cost infrastructure.
342 ///
343 /// TODO: Move to VPlan::cost once the use of LoopVectorizationLegality has
344 /// been retired.
345 InstructionCost cost(VPlan &Plan, ElementCount VF) const;
346
347public:
349 Loop *L, LoopInfo *LI, DominatorTree *DT, const TargetLibraryInfo *TLI,
354 : OrigLoop(L), LI(LI), DT(DT), TLI(TLI), TTI(TTI), Legal(Legal), CM(CM),
355 IAI(IAI), PSE(PSE), Hints(Hints), ORE(ORE) {}
356
357 /// Build VPlans for the specified \p UserVF and \p UserIC if they are
358 /// non-zero or all applicable candidate VFs otherwise. If vectorization and
359 /// interleaving should be avoided up-front, no plans are generated.
360 void plan(ElementCount UserVF, unsigned UserIC);
361
362 /// Use the VPlan-native path to plan how to best vectorize, return the best
363 /// VF and its cost.
365
366 /// Return the VPlan for \p VF. At the moment, there is always a single VPlan
367 /// for each VF.
368 VPlan &getPlanFor(ElementCount VF) const;
369
370 /// Compute and return the most profitable vectorization factor. Also collect
371 /// all profitable VFs in ProfitableVFs.
373
374 /// Generate the IR code for the vectorized loop captured in VPlan \p BestPlan
375 /// according to the best selected \p VF and \p UF.
376 ///
377 /// TODO: \p IsEpilogueVectorization is needed to avoid issues due to epilogue
378 /// vectorization re-using plans for both the main and epilogue vector loops.
379 /// It should be removed once the re-use issue has been fixed.
380 /// \p ExpandedSCEVs is passed during execution of the plan for epilogue loop
381 /// to re-use expansion results generated during main plan execution.
382 ///
383 /// Returns a mapping of SCEVs to their expanded IR values and a mapping for
384 /// the reduction resume values. Note that this is a temporary workaround
385 /// needed due to the current epilogue handling.
386 std::pair<DenseMap<const SCEV *, Value *>,
388 executePlan(ElementCount VF, unsigned UF, VPlan &BestPlan,
390 bool IsEpilogueVectorization,
391 const DenseMap<const SCEV *, Value *> *ExpandedSCEVs = nullptr);
392
393#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
394 void printPlans(raw_ostream &O);
395#endif
396
397 /// Look through the existing plans and return true if we have one with
398 /// vectorization factor \p VF.
400 return any_of(VPlans,
401 [&](const VPlanPtr &Plan) { return Plan->hasVF(VF); });
402 }
403
404 /// Test a \p Predicate on a \p Range of VF's. Return the value of applying
405 /// \p Predicate on Range.Start, possibly decreasing Range.End such that the
406 /// returned value holds for the entire \p Range.
407 static bool
408 getDecisionAndClampRange(const std::function<bool(ElementCount)> &Predicate,
409 VFRange &Range);
410
411 /// \return The most profitable vectorization factor and the cost of that VF
412 /// for vectorizing the epilogue. Returns VectorizationFactor::Disabled if
413 /// epilogue vectorization is not supported for the loop.
415 selectEpilogueVectorizationFactor(const ElementCount MaxVF, unsigned IC);
416
417 /// Emit remarks for recipes with invalid costs in the available VPlans.
419
420protected:
421 /// Build VPlans for power-of-2 VF's between \p MinVF and \p MaxVF inclusive,
422 /// according to the information gathered by Legal when it checked if it is
423 /// legal to vectorize the loop.
424 void buildVPlans(ElementCount MinVF, ElementCount MaxVF);
425
426private:
427 /// Build a VPlan according to the information gathered by Legal. \return a
428 /// VPlan for vectorization factors \p Range.Start and up to \p Range.End
429 /// exclusive, possibly decreasing \p Range.End.
430 VPlanPtr buildVPlan(VFRange &Range);
431
432 /// Build a VPlan using VPRecipes according to the information gather by
433 /// Legal. This method is only used for the legacy inner loop vectorizer.
434 /// \p Range's largest included VF is restricted to the maximum VF the
435 /// returned VPlan is valid for. If no VPlan can be built for the input range,
436 /// set the largest included VF to the maximum VF for which no plan could be
437 /// built.
438 VPlanPtr tryToBuildVPlanWithVPRecipes(VFRange &Range);
439
440 /// Build VPlans for power-of-2 VF's between \p MinVF and \p MaxVF inclusive,
441 /// according to the information gathered by Legal when it checked if it is
442 /// legal to vectorize the loop. This method creates VPlans using VPRecipes.
443 void buildVPlansWithVPRecipes(ElementCount MinVF, ElementCount MaxVF);
444
445 // Adjust the recipes for reductions. For in-loop reductions the chain of
446 // instructions leading from the loop exit instr to the phi need to be
447 // converted to reductions, with one operand being vector and the other being
448 // the scalar reduction chain. For other reductions, a select is introduced
449 // between the phi and live-out recipes when folding the tail.
450 void adjustRecipesForReductions(VPlanPtr &Plan,
451 VPRecipeBuilder &RecipeBuilder,
452 ElementCount MinVF);
453
454#ifndef NDEBUG
455 /// \return The most profitable vectorization factor for the available VPlans
456 /// and the cost of that VF.
457 /// This is now only used to verify the decisions by the new VPlan-based
458 /// cost-model and will be retired once the VPlan-based cost-model is
459 /// stabilized.
460 VectorizationFactor selectVectorizationFactor();
461#endif
462
463 /// Returns true if the per-lane cost of VectorizationFactor A is lower than
464 /// that of B.
465 bool isMoreProfitable(const VectorizationFactor &A,
466 const VectorizationFactor &B) const;
467
468 /// Determines if we have the infrastructure to vectorize the loop and its
469 /// epilogue, assuming the main loop is vectorized by \p VF.
470 bool isCandidateForEpilogueVectorization(const ElementCount VF) const;
471};
472
473} // namespace llvm
474
475#endif // LLVM_TRANSFORMS_VECTORIZE_LOOPVECTORIZATIONPLANNER_H
amdgpu AMDGPU Register Bank Select
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
std::string Name
This file defines an InstructionCost class that is used when calculating the cost of an instruction,...
mir Rename Register Operands
ConstantRange Range(APInt(BitWidth, Low), APInt(BitWidth, High))
const SmallVectorImpl< MachineOperand > & Cond
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This file defines the SmallSet class.
This file contains the declarations of the Vectorization Plan base classes:
Value * RHS
Value * LHS
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: ArrayRef.h:41
Predicate
This enumeration lists the possible predicates for CmpInst subclasses.
Definition: InstrTypes.h:757
A debug info location.
Definition: DebugLoc.h:33
Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree.
Definition: Dominators.h:162
constexpr bool isVector() const
One or more elements.
Definition: TypeSize.h:326
static constexpr ElementCount getFixed(ScalarTy MinVal)
Definition: TypeSize.h:311
InnerLoopVectorizer vectorizes loops which contain only one basic block to a specified vectorization ...
Drive the analysis of interleaved memory accesses in the loop.
Definition: VectorUtils.h:610
LoopVectorizationCostModel - estimates the expected speedups due to vectorization.
LoopVectorizationLegality checks if it is legal to vectorize a loop, and to what vectorization factor...
Planner drives the vectorization process after having passed Legality checks.
VectorizationFactor selectEpilogueVectorizationFactor(const ElementCount MaxVF, unsigned IC)
VPlan & getPlanFor(ElementCount VF) const
Return the VPlan for VF.
Definition: VPlan.cpp:1683
LoopVectorizationPlanner(Loop *L, LoopInfo *LI, DominatorTree *DT, const TargetLibraryInfo *TLI, const TargetTransformInfo &TTI, LoopVectorizationLegality *Legal, LoopVectorizationCostModel &CM, InterleavedAccessInfo &IAI, PredicatedScalarEvolution &PSE, const LoopVectorizeHints &Hints, OptimizationRemarkEmitter *ORE)
VectorizationFactor planInVPlanNativePath(ElementCount UserVF)
Use the VPlan-native path to plan how to best vectorize, return the best VF and its cost.
std::pair< DenseMap< const SCEV *, Value * >, DenseMap< const RecurrenceDescriptor *, Value * > > executePlan(ElementCount VF, unsigned UF, VPlan &BestPlan, InnerLoopVectorizer &LB, DominatorTree *DT, bool IsEpilogueVectorization, const DenseMap< const SCEV *, Value * > *ExpandedSCEVs=nullptr)
Generate the IR code for the vectorized loop captured in VPlan BestPlan according to the best selecte...
void buildVPlans(ElementCount MinVF, ElementCount MaxVF)
Build VPlans for power-of-2 VF's between MinVF and MaxVF inclusive, according to the information gath...
Definition: VPlan.cpp:1671
VectorizationFactor computeBestVF()
Compute and return the most profitable vectorization factor.
void emitInvalidCostRemarks(OptimizationRemarkEmitter *ORE)
Emit remarks for recipes with invalid costs in the available VPlans.
static bool getDecisionAndClampRange(const std::function< bool(ElementCount)> &Predicate, VFRange &Range)
Test a Predicate on a Range of VF's.
Definition: VPlan.cpp:1652
void printPlans(raw_ostream &O)
Definition: VPlan.cpp:1697
void plan(ElementCount UserVF, unsigned UserIC)
Build VPlans for the specified UserVF and UserIC if they are non-zero or all applicable candidate VFs...
bool hasPlanWithVF(ElementCount VF) const
Look through the existing plans and return true if we have one with vectorization factor VF.
Utility class for getting and setting loop vectorizer hints in the form of loop metadata.
Represents a single loop in the control flow graph.
Definition: LoopInfo.h:39
The optimization diagnostic interface.
An interface layer with SCEV used to manage how we see SCEV expressions for values in the context of ...
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1209
Provides information about what library functions are available for the current target.
This pass provides access to the codegen interfaces that are needed for IR-level transformations.
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
VPBasicBlock serves as the leaf of the Hierarchical Control-Flow Graph.
Definition: VPlan.h:2992
RecipeListTy::iterator iterator
Instruction iterators...
Definition: VPlan.h:3016
iterator end()
Definition: VPlan.h:3026
void insert(VPRecipeBase *Recipe, iterator InsertPt)
Definition: VPlan.h:3055
RAII object that stores the current insertion point and restores it when the object is destroyed.
InsertPointGuard(const InsertPointGuard &)=delete
InsertPointGuard & operator=(const InsertPointGuard &)=delete
InsertPoint - A saved insertion point.
VPInsertPoint(VPBasicBlock *InsertBlock, VPBasicBlock::iterator InsertPoint)
Creates a new insertion point at the given location.
VPBasicBlock::iterator getPoint() const
VPInsertPoint()=default
Creates a new insertion point which doesn't point to anything.
bool isSet() const
Returns true if this insert point is set.
VPlan-based builder utility analogous to IRBuilder.
void setInsertPoint(VPBasicBlock *TheBB, VPBasicBlock::iterator IP)
This specifies that created instructions should be inserted at the specified point.
void setInsertPoint(VPRecipeBase *IP)
This specifies that created instructions should be inserted at the specified point.
void restoreIP(VPInsertPoint IP)
Sets the current insert point to a previously-saved location.
VPValue * createOr(VPValue *LHS, VPValue *RHS, DebugLoc DL={}, const Twine &Name="")
VPBasicBlock * getInsertBlock() const
VPBasicBlock::iterator getInsertPoint() const
VPBuilder(VPBasicBlock *InsertBB)
static VPBuilder getToInsertAfter(VPRecipeBase *R)
Create a VPBuilder to insert after R.
VPInstruction * createNaryOp(unsigned Opcode, ArrayRef< VPValue * > Operands, DebugLoc DL, const Twine &Name="")
VPValue * createICmp(CmpInst::Predicate Pred, VPValue *A, VPValue *B, DebugLoc DL={}, const Twine &Name="")
Create a new ICmp VPInstruction with predicate Pred and operands A and B.
VPBuilder(VPRecipeBase *InsertPt)
VPInstruction * createOverflowingOp(unsigned Opcode, std::initializer_list< VPValue * > Operands, VPRecipeWithIRFlags::WrapFlagsTy WrapFlags, DebugLoc DL={}, const Twine &Name="")
VPValue * createAnd(VPValue *LHS, VPValue *RHS, DebugLoc DL={}, const Twine &Name="")
void clearInsertionPoint()
Clear the insertion point: created instructions will not be inserted into a block.
VPInstruction * createNaryOp(unsigned Opcode, ArrayRef< VPValue * > Operands, Instruction *Inst=nullptr, const Twine &Name="")
Create an N-ary operation with Opcode, Operands and set Inst as its underlying Instruction.
VPValue * createNot(VPValue *Operand, DebugLoc DL={}, const Twine &Name="")
VPBuilder()=default
VPValue * createLogicalAnd(VPValue *LHS, VPValue *RHS, DebugLoc DL={}, const Twine &Name="")
VPValue * createSelect(VPValue *Cond, VPValue *TrueVal, VPValue *FalseVal, DebugLoc DL={}, const Twine &Name="", std::optional< FastMathFlags > FMFs=std::nullopt)
void setInsertPoint(VPBasicBlock *TheBB)
This specifies that created VPInstructions should be appended to the end of the specified block.
This is a concrete Recipe that models a single VPlan-level instruction.
Definition: VPlan.h:1233
VPRecipeBase is a base class modeling a sequence of one or more output IR instructions.
Definition: VPlan.h:766
VPBasicBlock * getParent()
Definition: VPlan.h:791
Helper class to create VPRecipies from IR instructions.
void setUnderlyingValue(Value *Val)
Definition: VPlanValue.h:189
VPlan models a candidate for vectorization, encoding various decisions take to produce efficient outp...
Definition: VPlan.h:3274
constexpr bool isScalable() const
Returns whether the quantity is scaled by a runtime quantity (vscale).
Definition: TypeSize.h:171
self_iterator getIterator()
Definition: ilist_node.h:132
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:52
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
bool any_of(R &&range, UnaryPredicate P)
Provide wrappers to std::any_of which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1729
std::unique_ptr< VPlan > VPlanPtr
Definition: VPlan.h:147
A class that represents two vectorization factors (initialized with 0 by default).
FixedScalableVFPair(const ElementCount &FixedVF, const ElementCount &ScalableVF)
FixedScalableVFPair(const ElementCount &Max)
static FixedScalableVFPair getNone()
A range of powers-of-2 vectorization factors with fixed start and adjustable end.
Definition: VPlan.h:100
TODO: The following VectorizationFactor was pulled out of LoopVectorizationCostModel class.
InstructionCost Cost
Cost of the loop with that width.
ElementCount MinProfitableTripCount
The minimum trip count required to make vectorization profitable, e.g.
bool operator==(const VectorizationFactor &rhs) const
ElementCount Width
Vector width with best cost.
InstructionCost ScalarCost
Cost of the scalar loop.
bool operator!=(const VectorizationFactor &rhs) const
static VectorizationFactor Disabled()
Width 1 means no vectorization, cost 0 means uncomputed cost.
VectorizationFactor(ElementCount Width, InstructionCost Cost, InstructionCost ScalarCost)