LLVM  16.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"
29 
30 namespace llvm {
31 
32 class LoopInfo;
33 class LoopVectorizationLegality;
34 class LoopVectorizationCostModel;
35 class PredicatedScalarEvolution;
36 class LoopVectorizeHints;
37 class OptimizationRemarkEmitter;
38 class TargetTransformInfo;
39 class TargetLibraryInfo;
40 class VPRecipeBuilder;
41 
42 /// VPlan-based builder utility analogous to IRBuilder.
43 class VPBuilder {
44  VPBasicBlock *BB = nullptr;
46 
47  VPInstruction *createInstruction(unsigned Opcode,
49  const Twine &Name = "") {
50  VPInstruction *Instr = new VPInstruction(Opcode, Operands, DL, Name);
51  if (BB)
52  BB->insert(Instr, InsertPt);
53  return Instr;
54  }
55 
56  VPInstruction *createInstruction(unsigned Opcode,
57  std::initializer_list<VPValue *> Operands,
58  DebugLoc DL, const Twine &Name = "") {
59  return createInstruction(Opcode, ArrayRef<VPValue *>(Operands), DL, Name);
60  }
61 
62 public:
63  VPBuilder() = default;
64 
65  /// Clear the insertion point: created instructions will not be inserted into
66  /// a block.
68  BB = nullptr;
69  InsertPt = VPBasicBlock::iterator();
70  }
71 
72  VPBasicBlock *getInsertBlock() const { return BB; }
73  VPBasicBlock::iterator getInsertPoint() const { return InsertPt; }
74 
75  /// InsertPoint - A saved insertion point.
76  class VPInsertPoint {
77  VPBasicBlock *Block = nullptr;
79 
80  public:
81  /// Creates a new insertion point which doesn't point to anything.
82  VPInsertPoint() = default;
83 
84  /// Creates a new insertion point at the given location.
86  : Block(InsertBlock), Point(InsertPoint) {}
87 
88  /// Returns true if this insert point is set.
89  bool isSet() const { return Block != nullptr; }
90 
91  VPBasicBlock *getBlock() const { return Block; }
92  VPBasicBlock::iterator getPoint() const { return Point; }
93  };
94 
95  /// Sets the current insert point to a previously-saved location.
97  if (IP.isSet())
98  setInsertPoint(IP.getBlock(), IP.getPoint());
99  else
101  }
102 
103  /// This specifies that created VPInstructions should be appended to the end
104  /// of the specified block.
106  assert(TheBB && "Attempting to set a null insert point");
107  BB = TheBB;
108  InsertPt = BB->end();
109  }
110 
111  /// This specifies that created instructions should be inserted at the
112  /// specified point.
114  BB = TheBB;
115  InsertPt = IP;
116  }
117 
118  /// Insert and return the specified instruction.
120  BB->insert(I, InsertPt);
121  return I;
122  }
123 
124  /// Create an N-ary operation with \p Opcode, \p Operands and set \p Inst as
125  /// its underlying Instruction.
127  Instruction *Inst = nullptr, const Twine &Name = "") {
128  DebugLoc DL;
129  if (Inst)
130  DL = Inst->getDebugLoc();
131  VPInstruction *NewVPInst = createInstruction(Opcode, Operands, DL, Name);
132  NewVPInst->setUnderlyingValue(Inst);
133  return NewVPInst;
134  }
136  DebugLoc DL, const Twine &Name = "") {
137  return createInstruction(Opcode, Operands, DL, Name);
138  }
139 
140  VPValue *createNot(VPValue *Operand, DebugLoc DL, const Twine &Name = "") {
141  return createInstruction(VPInstruction::Not, {Operand}, DL, Name);
142  }
143 
145  const Twine &Name = "") {
146  return createInstruction(Instruction::BinaryOps::And, {LHS, RHS}, DL, Name);
147  }
148 
150  const Twine &Name = "") {
151  return createInstruction(Instruction::BinaryOps::Or, {LHS, RHS}, DL, Name);
152  }
153 
155  DebugLoc DL, const Twine &Name = "") {
157  Name);
158  }
159 
160  //===--------------------------------------------------------------------===//
161  // RAII helpers.
162  //===--------------------------------------------------------------------===//
163 
164  /// RAII object that stores the current insertion point and restores it when
165  /// the object is destroyed.
167  VPBuilder &Builder;
168  VPBasicBlock *Block;
170 
171  public:
173  : Builder(B), Block(B.getInsertBlock()), Point(B.getInsertPoint()) {}
174 
175  InsertPointGuard(const InsertPointGuard &) = delete;
176  InsertPointGuard &operator=(const InsertPointGuard &) = delete;
177 
178  ~InsertPointGuard() { Builder.restoreIP(VPInsertPoint(Block, Point)); }
179  };
180 };
181 
182 /// TODO: The following VectorizationFactor was pulled out of
183 /// LoopVectorizationCostModel class. LV also deals with
184 /// VectorizerParams::VectorizationFactor and VectorizationCostTy.
185 /// We need to streamline them.
186 
187 /// Information about vectorization costs.
189  /// Vector width with best cost.
191  /// Cost of the loop with that width.
193 
194  /// Cost of the scalar loop.
196 
197  /// The minimum trip count required to make vectorization profitable, e.g. due
198  /// to runtime checks.
200 
204 
205  /// Width 1 means no vectorization, cost 0 means uncomputed cost.
207  return {ElementCount::getFixed(1), 0, 0};
208  }
209 
210  bool operator==(const VectorizationFactor &rhs) const {
211  return Width == rhs.Width && Cost == rhs.Cost;
212  }
213 
214  bool operator!=(const VectorizationFactor &rhs) const {
215  return !(*this == rhs);
216  }
217 };
218 
219 /// A class that represents two vectorization factors (initialized with 0 by
220 /// default). One for fixed-width vectorization and one for scalable
221 /// vectorization. This can be used by the vectorizer to choose from a range of
222 /// fixed and/or scalable VFs in order to find the most cost-effective VF to
223 /// vectorize with.
227 
229  : FixedVF(ElementCount::getFixed(0)),
230  ScalableVF(ElementCount::getScalable(0)) {}
232  *(Max.isScalable() ? &ScalableVF : &FixedVF) = Max;
233  }
235  const ElementCount &ScalableVF)
238  "Invalid scalable properties");
239  }
240 
242 
243  /// \return true if either fixed- or scalable VF is non-zero.
244  explicit operator bool() const { return FixedVF || ScalableVF; }
245 
246  /// \return true if either fixed- or scalable VF is a valid vector VF.
247  bool hasVector() const { return FixedVF.isVector() || ScalableVF.isVector(); }
248 };
249 
250 /// Planner drives the vectorization process after having passed
251 /// Legality checks.
253  /// The loop that we evaluate.
254  Loop *OrigLoop;
255 
256  /// Loop Info analysis.
257  LoopInfo *LI;
258 
259  /// Target Library Info.
260  const TargetLibraryInfo *TLI;
261 
262  /// Target Transform Info.
263  const TargetTransformInfo *TTI;
264 
265  /// The legality analysis.
267 
268  /// The profitability analysis.
270 
271  /// The interleaved access analysis.
273 
275 
276  const LoopVectorizeHints &Hints;
277 
279 
281 
282  /// A builder used to construct the current plan.
283  VPBuilder Builder;
284 
285 public:
287  const TargetTransformInfo *TTI,
292  const LoopVectorizeHints &Hints,
294  : OrigLoop(L), LI(LI), TLI(TLI), TTI(TTI), Legal(Legal), CM(CM), IAI(IAI),
295  PSE(PSE), Hints(Hints), ORE(ORE) {}
296 
297  /// Plan how to best vectorize, return the best VF and its cost, or None if
298  /// vectorization and interleaving should be avoided up front.
299  Optional<VectorizationFactor> plan(ElementCount UserVF, unsigned UserIC);
300 
301  /// Use the VPlan-native path to plan how to best vectorize, return the best
302  /// VF and its cost.
304 
305  /// Return the best VPlan for \p VF.
306  VPlan &getBestPlanFor(ElementCount VF) const;
307 
308  /// Generate the IR code for the body of the vectorized loop according to the
309  /// best selected \p VF, \p UF and VPlan \p BestPlan.
310  /// TODO: \p IsEpilogueVectorization is needed to avoid issues due to epilogue
311  /// vectorization re-using plans for both the main and epilogue vector loops.
312  /// It should be removed once the re-use issue has been fixed.
313  void executePlan(ElementCount VF, unsigned UF, VPlan &BestPlan,
315  bool IsEpilogueVectorization);
316 
317 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
318  void printPlans(raw_ostream &O);
319 #endif
320 
321  /// Look through the existing plans and return true if we have one with all
322  /// the vectorization factors in question.
323  bool hasPlanWithVF(ElementCount VF) const {
324  return any_of(VPlans,
325  [&](const VPlanPtr &Plan) { return Plan->hasVF(VF); });
326  }
327 
328  /// Test a \p Predicate on a \p Range of VF's. Return the value of applying
329  /// \p Predicate on Range.Start, possibly decreasing Range.End such that the
330  /// returned value holds for the entire \p Range.
331  static bool
333  VFRange &Range);
334 
335  /// Check if the number of runtime checks exceeds the threshold.
336  bool requiresTooManyRuntimeChecks() const;
337 
338 protected:
339  /// Build VPlans for power-of-2 VF's between \p MinVF and \p MaxVF inclusive,
340  /// according to the information gathered by Legal when it checked if it is
341  /// legal to vectorize the loop.
342  void buildVPlans(ElementCount MinVF, ElementCount MaxVF);
343 
344 private:
345  /// Build a VPlan according to the information gathered by Legal. \return a
346  /// VPlan for vectorization factors \p Range.Start and up to \p Range.End
347  /// exclusive, possibly decreasing \p Range.End.
348  VPlanPtr buildVPlan(VFRange &Range);
349 
350  /// Build a VPlan using VPRecipes according to the information gather by
351  /// Legal. This method is only used for the legacy inner loop vectorizer.
352  VPlanPtr buildVPlanWithVPRecipes(
353  VFRange &Range, SmallPtrSetImpl<Instruction *> &DeadInstructions,
354  const MapVector<Instruction *, Instruction *> &SinkAfter);
355 
356  /// Build VPlans for power-of-2 VF's between \p MinVF and \p MaxVF inclusive,
357  /// according to the information gathered by Legal when it checked if it is
358  /// legal to vectorize the loop. This method creates VPlans using VPRecipes.
359  void buildVPlansWithVPRecipes(ElementCount MinVF, ElementCount MaxVF);
360 
361  // Adjust the recipes for reductions. For in-loop reductions the chain of
362  // instructions leading from the loop exit instr to the phi need to be
363  // converted to reductions, with one operand being vector and the other being
364  // the scalar reduction chain. For other reductions, a select is introduced
365  // between the phi and live-out recipes when folding the tail.
366  void adjustRecipesForReductions(VPBasicBlock *LatchVPBB, VPlanPtr &Plan,
367  VPRecipeBuilder &RecipeBuilder,
368  ElementCount MinVF);
369 };
370 
371 } // namespace llvm
372 
373 #endif // LLVM_TRANSFORMS_VECTORIZE_LOOPVECTORIZATIONPLANNER_H
llvm::InstructionCost
Definition: InstructionCost.h:29
llvm::VPBuilder::getInsertBlock
VPBasicBlock * getInsertBlock() const
Definition: LoopVectorizationPlanner.h:72
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
llvm::FixedScalableVFPair
A class that represents two vectorization factors (initialized with 0 by default).
Definition: LoopVectorizationPlanner.h:224
llvm::FixedScalableVFPair::FixedScalableVFPair
FixedScalableVFPair(const ElementCount &Max)
Definition: LoopVectorizationPlanner.h:231
llvm::VPBuilder::VPInsertPoint::VPInsertPoint
VPInsertPoint()=default
Creates a new insertion point which doesn't point to anything.
llvm::ElementCount
Definition: TypeSize.h:404
llvm::VPBasicBlock
VPBasicBlock serves as the leaf of the Hierarchical Control-Flow Graph.
Definition: VPlan.h:2013
llvm::Loop
Represents a single loop in the control flow graph.
Definition: LoopInfo.h:546
llvm::FixedScalableVFPair::getNone
static FixedScalableVFPair getNone()
Definition: LoopVectorizationPlanner.h:241
llvm::VPBuilder::createNaryOp
VPValue * 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.
Definition: LoopVectorizationPlanner.h:126
llvm::VPBuilder::createOr
VPValue * createOr(VPValue *LHS, VPValue *RHS, DebugLoc DL, const Twine &Name="")
Definition: LoopVectorizationPlanner.h:149
llvm::PredicatedScalarEvolution
An interface layer with SCEV used to manage how we see SCEV expressions for values in the context of ...
Definition: ScalarEvolution.h:2197
llvm::SmallVector< VPlanPtr, 4 >
llvm::TargetTransformInfo
This pass provides access to the codegen interfaces that are needed for IR-level transformations.
Definition: TargetTransformInfo.h:172
llvm::LoopVectorizationLegality
LoopVectorizationLegality checks if it is legal to vectorize a loop, and to what vectorization factor...
Definition: LoopVectorizationLegality.h:241
llvm::DominatorTree
Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree.
Definition: Dominators.h:166
llvm::VPBuilder::InsertPointGuard::operator=
InsertPointGuard & operator=(const InsertPointGuard &)=delete
llvm::VPlanPtr
std::unique_ptr< VPlan > VPlanPtr
Definition: VPlan.h:103
llvm::VPBuilder::getInsertPoint
VPBasicBlock::iterator getInsertPoint() const
Definition: LoopVectorizationPlanner.h:73
llvm::Optional
Definition: APInt.h:33
llvm::LoopVectorizationPlanner::plan
Optional< VectorizationFactor > plan(ElementCount UserVF, unsigned UserIC)
Plan how to best vectorize, return the best VF and its cost, or None if vectorization and interleavin...
Definition: LoopVectorize.cpp:7473
llvm::MapVector
This class implements a map that also provides access to all stored values in a deterministic order.
Definition: MapVector.h:37
llvm::tgtok::FalseVal
@ FalseVal
Definition: TGLexer.h:62
llvm::FixedScalableVFPair::FixedScalableVFPair
FixedScalableVFPair(const ElementCount &FixedVF, const ElementCount &ScalableVF)
Definition: LoopVectorizationPlanner.h:234
llvm::VPBuilder::createSelect
VPValue * createSelect(VPValue *Cond, VPValue *TrueVal, VPValue *FalseVal, DebugLoc DL, const Twine &Name="")
Definition: LoopVectorizationPlanner.h:154
llvm::VectorizationFactor::MinProfitableTripCount
ElementCount MinProfitableTripCount
The minimum trip count required to make vectorization profitable, e.g.
Definition: LoopVectorizationPlanner.h:199
llvm::VPRecipeBuilder
Helper class to create VPRecipies from IR instructions.
Definition: VPRecipeBuilder.h:27
RHS
Value * RHS
Definition: X86PartialReduction.cpp:76
llvm::VectorizationFactor::operator==
bool operator==(const VectorizationFactor &rhs) const
Definition: LoopVectorizationPlanner.h:210
llvm::VPBuilder::createNot
VPValue * createNot(VPValue *Operand, DebugLoc DL, const Twine &Name="")
Definition: LoopVectorizationPlanner.h:140
llvm::LinearPolySize::isScalable
bool isScalable() const
Returns whether the size is scaled by a runtime quantity (vscale).
Definition: TypeSize.h:298
llvm::VectorizationFactor::operator!=
bool operator!=(const VectorizationFactor &rhs) const
Definition: LoopVectorizationPlanner.h:214
llvm::VFRange
A range of powers-of-2 vectorization factors with fixed start and adjustable end.
Definition: VPlan.h:83
llvm::LoopVectorizationCostModel
LoopVectorizationCostModel - estimates the expected speedups due to vectorization.
Definition: LoopVectorize.cpp:1134
llvm::VPBasicBlock::iterator
RecipeListTy::iterator iterator
Instruction iterators...
Definition: VPlan.h:2034
LHS
Value * LHS
Definition: X86PartialReduction.cpp:75
llvm::LoopVectorizationPlanner::executePlan
void executePlan(ElementCount VF, unsigned UF, VPlan &BestPlan, InnerLoopVectorizer &LB, DominatorTree *DT, bool IsEpilogueVectorization)
Generate the IR code for the body of the vectorized loop according to the best selected VF,...
Definition: LoopVectorize.cpp:7592
llvm::VPInstruction
This is a concrete Recipe that models a single VPlan-level instruction.
Definition: VPlan.h:775
llvm::VPBuilder
VPlan-based builder utility analogous to IRBuilder.
Definition: LoopVectorizationPlanner.h:43
llvm::FixedScalableVFPair::hasVector
bool hasVector() const
Definition: LoopVectorizationPlanner.h:247
llvm::LoopVectorizationPlanner::buildVPlans
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: LoopVectorize.cpp:7988
IP
Definition: NVPTXLowerArgs.cpp:168
llvm::FixedScalableVFPair::FixedVF
ElementCount FixedVF
Definition: LoopVectorizationPlanner.h:225
B
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
llvm::VectorizationFactor::VectorizationFactor
VectorizationFactor(ElementCount Width, InstructionCost Cost, InstructionCost ScalarCost)
Definition: LoopVectorizationPlanner.h:201
llvm::Instruction
Definition: Instruction.h:42
llvm::InterleavedAccessInfo
Drive the analysis of interleaved memory accesses in the loop.
Definition: VectorUtils.h:751
llvm::raw_ostream
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:52
llvm::VPValue
Definition: VPlanValue.h:44
VPlan.h
llvm::InnerLoopVectorizer
InnerLoopVectorizer vectorizes loops which contain only one basic block to a specified vectorization ...
Definition: LoopVectorize.cpp:442
llvm::VPBuilder::createNaryOp
VPValue * createNaryOp(unsigned Opcode, ArrayRef< VPValue * > Operands, DebugLoc DL, const Twine &Name="")
Definition: LoopVectorizationPlanner.h:135
llvm::LinearPolySize< ElementCount >::getFixed
static ElementCount getFixed(ScalarTy MinVal)
Definition: TypeSize.h:283
llvm::LoopVectorizationPlanner
Planner drives the vectorization process after having passed Legality checks.
Definition: LoopVectorizationPlanner.h:252
llvm::VectorizationFactor::Cost
InstructionCost Cost
Cost of the loop with that width.
Definition: LoopVectorizationPlanner.h:192
llvm::VPBuilder::insert
VPInstruction * insert(VPInstruction *I) const
Insert and return the specified instruction.
Definition: LoopVectorizationPlanner.h:119
Operands
mir Rename Register Operands
Definition: MIRNamerPass.cpp:74
llvm::VectorizationFactor::ScalarCost
InstructionCost ScalarCost
Cost of the scalar loop.
Definition: LoopVectorizationPlanner.h:195
llvm::LoopVectorizationPlanner::requiresTooManyRuntimeChecks
bool requiresTooManyRuntimeChecks() const
Check if the number of runtime checks exceeds the threshold.
llvm::RISCVFenceField::O
@ O
Definition: RISCVBaseInfo.h:264
llvm::PPC::Predicate
Predicate
Predicate - These are "(BI << 5) | BO" for various predicates.
Definition: PPCPredicates.h:26
llvm::LoopVectorizeHints
Utility class for getting and setting loop vectorizer hints in the form of loop metadata.
Definition: LoopVectorizationLegality.h:61
llvm::VPInstruction::Not
@ Not
Definition: VPlan.h:784
llvm::IRSimilarity::Legal
@ Legal
Definition: IRSimilarityIdentifier.h:76
llvm::VPBuilder::VPInsertPoint::getBlock
VPBasicBlock * getBlock() const
Definition: LoopVectorizationPlanner.h:91
llvm::VPBuilder::InsertPointGuard::~InsertPointGuard
~InsertPointGuard()
Definition: LoopVectorizationPlanner.h:178
I
#define I(x, y, z)
Definition: MD5.cpp:58
llvm::LoopVectorizationPlanner::LoopVectorizationPlanner
LoopVectorizationPlanner(Loop *L, LoopInfo *LI, const TargetLibraryInfo *TLI, const TargetTransformInfo *TTI, LoopVectorizationLegality *Legal, LoopVectorizationCostModel &CM, InterleavedAccessInfo &IAI, PredicatedScalarEvolution &PSE, const LoopVectorizeHints &Hints, OptimizationRemarkEmitter *ORE)
Definition: LoopVectorizationPlanner.h:286
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::VPBuilder::InsertPointGuard
RAII object that stores the current insertion point and restores it when the object is destroyed.
Definition: LoopVectorizationPlanner.h:166
function
print Print MemDeps of function
Definition: MemDepPrinter.cpp:82
llvm::ElementCount::isVector
bool isVector() const
One or more elements.
Definition: TypeSize.h:416
Builder
assume Assume Builder
Definition: AssumeBundleBuilder.cpp:651
llvm::VPBuilder::setInsertPoint
void setInsertPoint(VPBasicBlock *TheBB, VPBasicBlock::iterator IP)
This specifies that created instructions should be inserted at the specified point.
Definition: LoopVectorizationPlanner.h:113
InstructionCost.h
llvm::ArrayRef
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: APInt.h:32
llvm::LoopInfo
Definition: LoopInfo.h:1105
llvm::OptimizationRemarkEmitter
The optimization diagnostic interface.
Definition: OptimizationRemarkEmitter.h:33
llvm::any_of
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:1597
Cond
SmallVector< MachineOperand, 4 > Cond
Definition: BasicBlockSections.cpp:137
DL
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
Definition: AArch64SLSHardening.cpp:76
llvm::VPValue::setUnderlyingValue
void setUnderlyingValue(Value *Val)
Definition: VPlanValue.h:77
llvm::MCID::Select
@ Select
Definition: MCInstrDesc.h:164
llvm::Twine
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
llvm::LoopVectorizationPlanner::printPlans
void printPlans(raw_ostream &O)
Definition: LoopVectorize.cpp:7679
llvm::GraphProgram::Name
Name
Definition: GraphWriter.h:50
llvm::VPBuilder::clearInsertionPoint
void clearInsertionPoint()
Clear the insertion point: created instructions will not be inserted into a block.
Definition: LoopVectorizationPlanner.h:67
llvm::VectorizationFactor
TODO: The following VectorizationFactor was pulled out of LoopVectorizationCostModel class.
Definition: LoopVectorizationPlanner.h:188
llvm::FixedScalableVFPair::ScalableVF
ElementCount ScalableVF
Definition: LoopVectorizationPlanner.h:226
llvm::VPBuilder::VPInsertPoint
InsertPoint - A saved insertion point.
Definition: LoopVectorizationPlanner.h:76
llvm::ilist_iterator
Iterator for intrusive lists based on ilist_node.
Definition: ilist_iterator.h:57
llvm::VPBuilder::VPBuilder
VPBuilder()=default
llvm::VPBuilder::restoreIP
void restoreIP(VPInsertPoint IP)
Sets the current insert point to a previously-saved location.
Definition: LoopVectorizationPlanner.h:96
llvm::TargetLibraryInfo
Provides information about what library functions are available for the current target.
Definition: TargetLibraryInfo.h:222
llvm::VPBuilder::VPInsertPoint::VPInsertPoint
VPInsertPoint(VPBasicBlock *InsertBlock, VPBasicBlock::iterator InsertPoint)
Creates a new insertion point at the given location.
Definition: LoopVectorizationPlanner.h:85
llvm::VPBuilder::InsertPointGuard::InsertPointGuard
InsertPointGuard(VPBuilder &B)
Definition: LoopVectorizationPlanner.h:172
llvm::VPBuilder::createAnd
VPValue * createAnd(VPValue *LHS, VPValue *RHS, DebugLoc DL, const Twine &Name="")
Definition: LoopVectorizationPlanner.h:144
llvm::VectorizationFactor::Width
ElementCount Width
Vector width with best cost.
Definition: LoopVectorizationPlanner.h:190
llvm::LoopVectorizationPlanner::planInVPlanNativePath
VectorizationFactor planInVPlanNativePath(ElementCount UserVF)
Use the VPlan-native path to plan how to best vectorize, return the best VF and its cost.
Definition: LoopVectorize.cpp:7428
llvm::VPBuilder::setInsertPoint
void setInsertPoint(VPBasicBlock *TheBB)
This specifies that created VPInstructions should be appended to the end of the specified block.
Definition: LoopVectorizationPlanner.h:105
llvm::FixedScalableVFPair::FixedScalableVFPair
FixedScalableVFPair()
Definition: LoopVectorizationPlanner.h:228
llvm::VPBuilder::VPInsertPoint::getPoint
VPBasicBlock::iterator getPoint() const
Definition: LoopVectorizationPlanner.h:92
llvm::LoopVectorizationPlanner::hasPlanWithVF
bool hasPlanWithVF(ElementCount VF) const
Look through the existing plans and return true if we have one with all the vectorization factors in ...
Definition: LoopVectorizationPlanner.h:323
llvm::SmallPtrSetImpl< Instruction * >
BB
Common register allocation spilling lr str ldr sxth r3 ldr mla r4 can lr mov lr str ldr sxth r3 mla r4 and then merge mul and lr str ldr sxth r3 mla r4 It also increase the likelihood the store may become dead bb27 Successors according to LLVM BB
Definition: README.txt:39
llvm::DebugLoc
A debug info location.
Definition: DebugLoc.h:33
llvm::tgtok::TrueVal
@ TrueVal
Definition: TGLexer.h:62
llvm::VPBuilder::VPInsertPoint::isSet
bool isSet() const
Returns true if this insert point is set.
Definition: LoopVectorizationPlanner.h:89
llvm::VPlan
VPlan models a candidate for vectorization, encoding various decisions take to produce efficient outp...
Definition: VPlan.h:2492
llvm::LoopVectorizationPlanner::getDecisionAndClampRange
static bool getDecisionAndClampRange(const std::function< bool(ElementCount)> &Predicate, VFRange &Range)
Test a Predicate on a Range of VF's.
Definition: LoopVectorize.cpp:7968
llvm::LoopVectorizationPlanner::getBestPlanFor
VPlan & getBestPlanFor(ElementCount VF) const
Return the best VPlan for VF.
Definition: LoopVectorize.cpp:7545
llvm::VectorizationFactor::Disabled
static VectorizationFactor Disabled()
Width 1 means no vectorization, cost 0 means uncomputed cost.
Definition: LoopVectorizationPlanner.h:206