LLVM  14.0.0git
VPlanValue.h
Go to the documentation of this file.
1 //===- VPlanValue.h - Represent Values in Vectorizer Plan -----------------===//
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 contains the declarations of the entities induced by Vectorization
11 /// Plans, e.g. the instructions the VPlan intends to generate if executed.
12 /// VPlan models the following entities:
13 /// VPValue VPUser VPDef
14 /// | |
15 /// VPInstruction
16 /// These are documented in docs/VectorizationPlan.rst.
17 ///
18 //===----------------------------------------------------------------------===//
19 
20 #ifndef LLVM_TRANSFORMS_VECTORIZE_VPLAN_VALUE_H
21 #define LLVM_TRANSFORMS_VECTORIZE_VPLAN_VALUE_H
22 
23 #include "llvm/ADT/DenseMap.h"
24 #include "llvm/ADT/STLExtras.h"
25 #include "llvm/ADT/SmallVector.h"
26 #include "llvm/ADT/TinyPtrVector.h"
28 
29 namespace llvm {
30 
31 // Forward declarations.
32 class raw_ostream;
33 class Value;
34 class VPDef;
35 class VPSlotTracker;
36 class VPUser;
37 class VPRecipeBase;
38 class VPWidenMemoryInstructionRecipe;
39 
40 // This is the base class of the VPlan Def/Use graph, used for modeling the data
41 // flow into, within and out of the VPlan. VPValues can stand for live-ins
42 // coming from the input IR, instructions which VPlan will generate if executed
43 // and live-outs which the VPlan will need to fix accordingly.
44 class VPValue {
45  friend class VPBuilder;
46  friend class VPDef;
47  friend class VPInstruction;
48  friend struct VPlanTransforms;
49  friend class VPBasicBlock;
51  friend class VPSlotTracker;
52  friend class VPRecipeBase;
54 
55  const unsigned char SubclassID; ///< Subclass identifier (for isa/dyn_cast).
56 
58 
59 protected:
60  // Hold the underlying Value, if any, attached to this VPValue.
62 
63  /// Pointer to the VPDef that defines this VPValue. If it is nullptr, the
64  /// VPValue is not defined by any recipe modeled in VPlan.
66 
67  VPValue(const unsigned char SC, Value *UV = nullptr, VPDef *Def = nullptr);
68 
69  // DESIGN PRINCIPLE: Access to the underlying IR must be strictly limited to
70  // the front-end and back-end of VPlan so that the middle-end is as
71  // independent as possible of the underlying IR. We grant access to the
72  // underlying IR using friendship. In that way, we should be able to use VPlan
73  // for multiple underlying IRs (Polly?) by providing a new VPlan front-end,
74  // back-end and analysis information for the new IR.
75 
76  // Set \p Val as the underlying Value of this VPValue.
78  assert(!UnderlyingVal && "Underlying Value is already set.");
79  UnderlyingVal = Val;
80  }
81 
82 public:
83  /// Return the underlying Value attached to this VPValue.
85  const Value *getUnderlyingValue() const { return UnderlyingVal; }
86 
87  /// An enumeration for keeping track of the concrete subclass of VPValue that
88  /// are actually instantiated. Values of this enumeration are kept in the
89  /// SubclassID field of the VPValue objects. They are used for concrete
90  /// type identification.
91  enum {
102 
103  // Phi-like VPValues. Need to be kept together.
111  };
112 
113  VPValue(Value *UV = nullptr, VPDef *Def = nullptr)
114  : VPValue(VPValueSC, UV, Def) {}
115  VPValue(const VPValue &) = delete;
116  VPValue &operator=(const VPValue &) = delete;
117 
118  virtual ~VPValue();
119 
120  /// \return an ID for the concrete type of this object.
121  /// This is used to implement the classof checks. This should not be used
122  /// for any other purpose, as the values may change as LLVM evolves.
123  unsigned getVPValueID() const { return SubclassID; }
124 
125 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
126  void printAsOperand(raw_ostream &OS, VPSlotTracker &Tracker) const;
127  void print(raw_ostream &OS, VPSlotTracker &Tracker) const;
128 
129  /// Dump the value to stderr (for debugging).
130  void dump() const;
131 #endif
132 
133  unsigned getNumUsers() const { return Users.size(); }
134  void addUser(VPUser &User) { Users.push_back(&User); }
135 
136  /// Remove a single \p User from the list of users.
138  bool Found = false;
139  // The same user can be added multiple times, e.g. because the same VPValue
140  // is used twice by the same VPUser. Remove a single one.
141  erase_if(Users, [&User, &Found](VPUser *Other) {
142  if (Found)
143  return false;
144  if (Other == &User) {
145  Found = true;
146  return true;
147  }
148  return false;
149  });
150  }
151 
156 
157  user_iterator user_begin() { return Users.begin(); }
158  const_user_iterator user_begin() const { return Users.begin(); }
159  user_iterator user_end() { return Users.end(); }
160  const_user_iterator user_end() const { return Users.end(); }
163  return const_user_range(user_begin(), user_end());
164  }
165 
166  /// Returns true if the value has more than one unique user.
168  if (getNumUsers() == 0)
169  return false;
170 
171  // Check if all users match the first user.
172  auto Current = std::next(user_begin());
173  while (Current != user_end() && *user_begin() == *Current)
174  Current++;
175  return Current != user_end();
176  }
177 
178  void replaceAllUsesWith(VPValue *New);
179 
180  VPDef *getDef() { return Def; }
181  const VPDef *getDef() const { return Def; }
182 
183  /// Returns the underlying IR value, if this VPValue is defined outside the
184  /// scope of VPlan. Returns nullptr if the VPValue is defined by a VPDef
185  /// inside a VPlan.
187  assert(!getDef() &&
188  "VPValue is not a live-in; it is defined by a VPDef inside a VPlan");
189  return getUnderlyingValue();
190  }
191  const Value *getLiveInIRValue() const {
192  assert(!getDef() &&
193  "VPValue is not a live-in; it is defined by a VPDef inside a VPlan");
194  return getUnderlyingValue();
195  }
196 };
197 
200 
201 raw_ostream &operator<<(raw_ostream &OS, const VPValue &V);
202 
203 /// This class augments VPValue with operands which provide the inverse def-use
204 /// edges from VPValue's users to their defs.
205 class VPUser {
206 public:
207  /// Subclass identifier (for isa/dyn_cast).
208  enum class VPUserID {
209  Recipe,
210  // TODO: Currently VPUsers are used in VPBlockBase, but in the future the
211  // only VPUsers should either be recipes or live-outs.
212  Block
213  };
214 
215 private:
216  SmallVector<VPValue *, 2> Operands;
217 
218  VPUserID ID;
219 
220 protected:
221 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
222  /// Print the operands to \p O.
224 #endif
225 
226  VPUser(ArrayRef<VPValue *> Operands, VPUserID ID) : ID(ID) {
227  for (VPValue *Operand : Operands)
228  addOperand(Operand);
229  }
230 
231  VPUser(std::initializer_list<VPValue *> Operands, VPUserID ID)
232  : VPUser(ArrayRef<VPValue *>(Operands), ID) {}
233 
234  template <typename IterT>
235  VPUser(iterator_range<IterT> Operands, VPUserID ID) : ID(ID) {
236  for (VPValue *Operand : Operands)
237  addOperand(Operand);
238  }
239 
240 public:
241  VPUser() = delete;
242  VPUser(const VPUser &) = delete;
243  VPUser &operator=(const VPUser &) = delete;
244  virtual ~VPUser() {
245  for (VPValue *Op : operands())
246  Op->removeUser(*this);
247  }
248 
249  VPUserID getVPUserID() const { return ID; }
250 
251  void addOperand(VPValue *Operand) {
252  Operands.push_back(Operand);
253  Operand->addUser(*this);
254  }
255 
256  unsigned getNumOperands() const { return Operands.size(); }
257  inline VPValue *getOperand(unsigned N) const {
258  assert(N < Operands.size() && "Operand index out of bounds");
259  return Operands[N];
260  }
261 
262  void setOperand(unsigned I, VPValue *New) {
263  Operands[I]->removeUser(*this);
264  Operands[I] = New;
265  New->addUser(*this);
266  }
267 
269  VPValue *Op = Operands.pop_back_val();
270  Op->removeUser(*this);
271  }
272 
277 
278  operand_iterator op_begin() { return Operands.begin(); }
279  const_operand_iterator op_begin() const { return Operands.begin(); }
280  operand_iterator op_end() { return Operands.end(); }
281  const_operand_iterator op_end() const { return Operands.end(); }
284  return const_operand_range(op_begin(), op_end());
285  }
286 
287  /// Method to support type inquiry through isa, cast, and dyn_cast.
288  static inline bool classof(const VPDef *Recipe);
289 };
290 
291 /// This class augments a recipe with a set of VPValues defined by the recipe.
292 /// It allows recipes to define zero, one or multiple VPValues. A VPDef owns
293 /// the VPValues it defines and is responsible for deleting its defined values.
294 /// Single-value VPDefs that also inherit from VPValue must make sure to inherit
295 /// from VPDef before VPValue.
296 class VPDef {
297  friend class VPValue;
298 
299  /// Subclass identifier (for isa/dyn_cast).
300  const unsigned char SubclassID;
301 
302  /// The VPValues defined by this VPDef.
303  TinyPtrVector<VPValue *> DefinedValues;
304 
305  /// Add \p V as a defined value by this VPDef.
306  void addDefinedValue(VPValue *V) {
307  assert(V->getDef() == this &&
308  "can only add VPValue already linked with this VPDef");
309  DefinedValues.push_back(V);
310  }
311 
312  /// Remove \p V from the values defined by this VPDef. \p V must be a defined
313  /// value of this VPDef.
314  void removeDefinedValue(VPValue *V) {
315  assert(V->getDef() == this &&
316  "can only remove VPValue linked with this VPDef");
317  assert(is_contained(DefinedValues, V) &&
318  "VPValue to remove must be in DefinedValues");
319  erase_value(DefinedValues, V);
320  V->Def = nullptr;
321  }
322 
323 public:
324  /// An enumeration for keeping track of the concrete subclass of VPRecipeBase
325  /// that is actually instantiated. Values of this enumeration are kept in the
326  /// SubclassID field of the VPRecipeBase objects. They are used for concrete
327  /// type identification.
328  using VPRecipeTy = enum {
329  VPBranchOnMaskSC,
330  VPInstructionSC,
331  VPInterleaveSC,
332  VPReductionSC,
333  VPReplicateSC,
334  VPWidenCallSC,
335  VPWidenCanonicalIVSC,
336  VPWidenGEPSC,
337  VPWidenMemoryInstructionSC,
338  VPWidenSC,
339  VPWidenSelectSC,
340 
341  // Phi-like recipes. Need to be kept together.
342  VPBlendSC,
343  VPCanonicalIVPHISC,
344  VPFirstOrderRecurrencePHISC,
345  VPWidenPHISC,
346  VPWidenIntOrFpInductionSC,
347  VPPredInstPHISC,
348  VPReductionPHISC,
349  VPFirstPHISC = VPBlendSC,
350  VPLastPHISC = VPReductionPHISC,
351  };
352 
353  VPDef(const unsigned char SC) : SubclassID(SC) {}
354 
355  virtual ~VPDef() {
356  for (VPValue *D : make_early_inc_range(DefinedValues)) {
357  assert(D->Def == this &&
358  "all defined VPValues should point to the containing VPDef");
359  assert(D->getNumUsers() == 0 &&
360  "all defined VPValues should have no more users");
361  D->Def = nullptr;
362  delete D;
363  }
364  }
365 
366  /// Returns the only VPValue defined by the VPDef. Can only be called for
367  /// VPDefs with a single defined value.
369  assert(DefinedValues.size() == 1 && "must have exactly one defined value");
370  assert(DefinedValues[0] && "defined value must be non-null");
371  return DefinedValues[0];
372  }
373  const VPValue *getVPSingleValue() const {
374  assert(DefinedValues.size() == 1 && "must have exactly one defined value");
375  assert(DefinedValues[0] && "defined value must be non-null");
376  return DefinedValues[0];
377  }
378 
379  /// Returns the VPValue with index \p I defined by the VPDef.
380  VPValue *getVPValue(unsigned I) {
381  assert(DefinedValues[I] && "defined value must be non-null");
382  return DefinedValues[I];
383  }
384  const VPValue *getVPValue(unsigned I) const {
385  assert(DefinedValues[I] && "defined value must be non-null");
386  return DefinedValues[I];
387  }
388 
389  /// Returns an ArrayRef of the values defined by the VPDef.
390  ArrayRef<VPValue *> definedValues() { return DefinedValues; }
391  /// Returns an ArrayRef of the values defined by the VPDef.
392  ArrayRef<VPValue *> definedValues() const { return DefinedValues; }
393 
394  /// Returns the number of values defined by the VPDef.
395  unsigned getNumDefinedValues() const { return DefinedValues.size(); }
396 
397  /// \return an ID for the concrete type of this object.
398  /// This is used to implement the classof checks. This should not be used
399  /// for any other purpose, as the values may change as LLVM evolves.
400  unsigned getVPDefID() const { return SubclassID; }
401 
402 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
403  /// Dump the VPDef to stderr (for debugging).
404  void dump() const;
405 
406  /// Each concrete VPDef prints itself.
407  virtual void print(raw_ostream &O, const Twine &Indent,
408  VPSlotTracker &SlotTracker) const = 0;
409 #endif
410 };
411 
412 class VPlan;
413 class VPBasicBlock;
414 
415 /// This class can be used to assign consecutive numbers to all VPValues in a
416 /// VPlan and allows querying the numbering for printing, similar to the
417 /// ModuleSlotTracker for IR values.
420  unsigned NextSlot = 0;
421 
422  void assignSlot(const VPValue *V);
423  void assignSlots(const VPlan &Plan);
424 
425 public:
426  VPSlotTracker(const VPlan *Plan = nullptr) {
427  if (Plan)
428  assignSlots(*Plan);
429  }
430 
431  unsigned getSlot(const VPValue *V) const {
432  auto I = Slots.find(V);
433  if (I == Slots.end())
434  return -1;
435  return I->second;
436  }
437 };
438 
439 } // namespace llvm
440 
441 #endif // LLVM_TRANSFORMS_VECTORIZE_VPLAN_VALUE_H
llvm::VPUser::getVPUserID
VPUserID getVPUserID() const
Definition: VPlanValue.h:249
llvm::VPUser::op_end
operand_iterator op_end()
Definition: VPlanValue.h:280
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AllocatorList.h:22
llvm::VPValue::VPVBlendSC
@ VPVBlendSC
Definition: VPlanValue.h:104
llvm::VPUser::VPUser
VPUser(iterator_range< IterT > Operands, VPUserID ID)
Definition: VPlanValue.h:235
llvm::VPValue::user_end
const_user_iterator user_end() const
Definition: VPlanValue.h:160
llvm::VPValue::getDef
const VPDef * getDef() const
Definition: VPlanValue.h:181
llvm::VPUser::removeLastOperand
void removeLastOperand()
Definition: VPlanValue.h:268
llvm::VPBasicBlock
VPBasicBlock serves as the leaf of the Hierarchical Control-Flow Graph.
Definition: VPlan.h:1736
llvm::VPValue::user_iterator
SmallVectorImpl< VPUser * >::iterator user_iterator
Definition: VPlanValue.h:152
llvm::VPValue::getLiveInIRValue
Value * getLiveInIRValue()
Returns the underlying IR value, if this VPValue is defined outside the scope of VPlan.
Definition: VPlanValue.h:186
llvm::SmallVector
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1175
llvm::VPValue::VPVWidenIntOrFpInductionSC
@ VPVWidenIntOrFpInductionSC
Definition: VPlanValue.h:108
llvm::VPValue::VPVCanonicalIVPHISC
@ VPVCanonicalIVPHISC
Definition: VPlanValue.h:105
llvm::VPDef::getVPSingleValue
VPValue * getVPSingleValue()
Returns the only VPValue defined by the VPDef.
Definition: VPlanValue.h:368
llvm::VPInterleavedAccessInfo
Definition: VPlan.h:2636
llvm::VPDef::print
virtual void print(raw_ostream &O, const Twine &Indent, VPSlotTracker &SlotTracker) const =0
Each concrete VPDef prints itself.
llvm::VPValue::user_range
iterator_range< user_iterator > user_range
Definition: VPlanValue.h:154
llvm::erase_if
void erase_if(Container &C, UnaryPredicate P)
Provide a container algorithm similar to C++ Library Fundamentals v2's erase_if which is equivalent t...
Definition: STLExtras.h:1773
llvm::VPValue::operator=
VPValue & operator=(const VPValue &)=delete
DenseMap.h
llvm::VPValue::dump
void dump() const
Dump the value to stderr (for debugging).
Definition: VPlan.cpp:96
llvm::VPUser::op_begin
operand_iterator op_begin()
Definition: VPlanValue.h:278
llvm::VPDef::VPDef
VPDef(const unsigned char SC)
Definition: VPlanValue.h:353
llvm::VPDef::getVPSingleValue
const VPValue * getVPSingleValue() const
Definition: VPlanValue.h:373
llvm::VPValue::VPVReductionSC
@ VPVReductionSC
Definition: VPlanValue.h:95
llvm::VPValue::print
void print(raw_ostream &OS, VPSlotTracker &Tracker) const
Definition: VPlan.cpp:89
STLExtras.h
llvm::VPUser::operands
operand_range operands()
Definition: VPlanValue.h:282
llvm::VPUser::VPUserID
VPUserID
Subclass identifier (for isa/dyn_cast).
Definition: VPlanValue.h:208
llvm::VPValue::VPVWidenCanonicalIVSC
@ VPVWidenCanonicalIVSC
Definition: VPlanValue.h:99
llvm::VPValue::VPVPredInstPHI
@ VPVPredInstPHI
Definition: VPlanValue.h:109
llvm::VPValue::VPValue
VPValue(const unsigned char SC, Value *UV=nullptr, VPDef *Def=nullptr)
Definition: VPlan.cpp:76
llvm::VPUser::const_operand_iterator
SmallVectorImpl< VPValue * >::const_iterator const_operand_iterator
Definition: VPlanValue.h:274
llvm::VPValue::users
user_range users()
Definition: VPlanValue.h:161
llvm::VPDef
This class augments a recipe with a set of VPValues defined by the recipe.
Definition: VPlanValue.h:296
llvm::VPValue::VPValueSC
@ VPValueSC
Definition: VPlanValue.h:92
llvm::VPUser::VPUser
VPUser(std::initializer_list< VPValue * > Operands, VPUserID ID)
Definition: VPlanValue.h:231
llvm::VPInstruction
This is a concrete Recipe that models a single VPlan-level instruction.
Definition: VPlan.h:782
llvm::VPUser::op_end
const_operand_iterator op_end() const
Definition: VPlanValue.h:281
llvm::PPCISD::SC
@ SC
CHAIN = SC CHAIN, Imm128 - System call.
Definition: PPCISelLowering.h:418
llvm::VPBuilder
VPlan-based builder utility analogous to IRBuilder.
Definition: LoopVectorizationPlanner.h:43
llvm::User
Definition: User.h:44
llvm::VPValue::addUser
void addUser(VPUser &User)
Definition: VPlanValue.h:134
llvm::VPDef::definedValues
ArrayRef< VPValue * > definedValues() const
Returns an ArrayRef of the values defined by the VPDef.
Definition: VPlanValue.h:392
llvm::TinyPtrVector::push_back
void push_back(EltTy NewVal)
Definition: TinyPtrVector.h:244
llvm::VPUser::VPUserID::Recipe
@ Recipe
llvm::VPValue::VPVWidenCallSC
@ VPVWidenCallSC
Definition: VPlanValue.h:98
llvm::VPValue::replaceAllUsesWith
void replaceAllUsesWith(VPValue *New)
Definition: VPlan.cpp:1542
llvm::VPValue::VPVReplicateSC
@ VPVReplicateSC
Definition: VPlanValue.h:96
llvm::raw_ostream
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:54
llvm::VPValue
Definition: VPlanValue.h:44
llvm::operator<<
raw_ostream & operator<<(raw_ostream &OS, const APFixedPoint &FX)
Definition: APFixedPoint.h:230
llvm::VPDef::getNumDefinedValues
unsigned getNumDefinedValues() const
Returns the number of values defined by the VPDef.
Definition: VPlanValue.h:395
llvm::VPValue::getUnderlyingValue
const Value * getUnderlyingValue() const
Definition: VPlanValue.h:85
llvm::VPValue::users
const_user_range users() const
Definition: VPlanValue.h:162
llvm::VPUser::getNumOperands
unsigned getNumOperands() const
Definition: VPlanValue.h:256
llvm::erase_value
void erase_value(Container &C, ValueType V)
Wrapper function to remove a value from a container:
Definition: STLExtras.h:1781
llvm::VPValue::getLiveInIRValue
const Value * getLiveInIRValue() const
Definition: VPlanValue.h:191
Operands
mir Rename Register Operands
Definition: MIRNamerPass.cpp:78
llvm::VPUser::setOperand
void setOperand(unsigned I, VPValue *New)
Definition: VPlanValue.h:262
llvm::VPValue::VPVWidenSC
@ VPVWidenSC
Definition: VPlanValue.h:97
llvm::VPValue::VPVWidenGEPSC
@ VPVWidenGEPSC
Definition: VPlanValue.h:100
llvm::RISCVFenceField::O
@ O
Definition: RISCVBaseInfo.h:207
llvm::VPValue::Def
VPDef * Def
Pointer to the VPDef that defines this VPValue.
Definition: VPlanValue.h:65
llvm::VPValue::VPVMemoryInstructionSC
@ VPVMemoryInstructionSC
Definition: VPlanValue.h:94
llvm::VPSlotTracker::getSlot
unsigned getSlot(const VPValue *V) const
Definition: VPlanValue.h:431
D
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
llvm::DenseMap< Value *, VPValue * >
llvm::VPValue::getNumUsers
unsigned getNumUsers() const
Definition: VPlanValue.h:133
I
#define I(x, y, z)
Definition: MD5.cpp:58
llvm::make_early_inc_range
iterator_range< early_inc_iterator_impl< detail::IterOfRange< RangeT > > > make_early_inc_range(RangeT &&Range)
Make a range that does early increment to allow mutation of the underlying range without disrupting i...
Definition: STLExtras.h:585
llvm::VPUser::op_begin
const_operand_iterator op_begin() const
Definition: VPlanValue.h:279
llvm::VPValue::VPVWidenSelectSC
@ VPVWidenSelectSC
Definition: VPlanValue.h:101
llvm::is_contained
bool is_contained(R &&Range, const E &Element)
Wrapper function around std::find to detect if an element exists in a container.
Definition: STLExtras.h:1657
llvm::VPValue::user_end
user_iterator user_end()
Definition: VPlanValue.h:159
llvm::DenseMapBase< DenseMap< KeyT, ValueT, DenseMapInfo< KeyT >, llvm::detail::DenseMapPair< KeyT, ValueT > >, KeyT, ValueT, DenseMapInfo< KeyT >, llvm::detail::DenseMapPair< KeyT, ValueT > >::find
iterator find(const_arg_type_t< KeyT > Val)
Definition: DenseMap.h:150
llvm::SmallVectorImpl::const_iterator
typename SuperClass::const_iterator const_iterator
Definition: SmallVector.h:557
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::VPValue::user_begin
const_user_iterator user_begin() const
Definition: VPlanValue.h:158
iterator_range.h
llvm::Value2VPValueTy
DenseMap< Value *, VPValue * > Value2VPValueTy
Definition: VPlanValue.h:198
llvm::VPUser::VPUserID::Block
@ Block
llvm::VPUser::printOperands
void printOperands(raw_ostream &O, VPSlotTracker &SlotTracker) const
Print the operands to O.
Definition: VPlan.cpp:1573
llvm::VPWidenMemoryInstructionRecipe
A Recipe for widening load/store operations.
Definition: VPlan.h:1574
TinyPtrVector.h
llvm::VPSlotTracker::VPSlotTracker
VPSlotTracker(const VPlan *Plan=nullptr)
Definition: VPlanValue.h:426
llvm::VPValue::user_begin
user_iterator user_begin()
Definition: VPlanValue.h:157
llvm::ArrayRef
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: APInt.h:32
llvm::TinyPtrVector::size
unsigned size() const
Definition: TinyPtrVector.h:172
llvm::VPUser::~VPUser
virtual ~VPUser()
Definition: VPlanValue.h:244
llvm::VPUser::addOperand
void addOperand(VPValue *Operand)
Definition: VPlanValue.h:251
llvm::VPDef::getVPValue
const VPValue * getVPValue(unsigned I) const
Definition: VPlanValue.h:384
llvm::VPDef::getVPValue
VPValue * getVPValue(unsigned I)
Returns the VPValue with index I defined by the VPDef.
Definition: VPlanValue.h:380
llvm::VPValue::setUnderlyingValue
void setUnderlyingValue(Value *Val)
Definition: VPlanValue.h:77
llvm::VPUser::operand_range
iterator_range< operand_iterator > operand_range
Definition: VPlanValue.h:275
llvm::VPUser::operand_iterator
SmallVectorImpl< VPValue * >::iterator operand_iterator
Definition: VPlanValue.h:273
llvm::VPUser::classof
static bool classof(const VPDef *Recipe)
Method to support type inquiry through isa, cast, and dyn_cast.
Definition: VPlan.h:764
llvm::VPDef::dump
void dump() const
Dump the VPDef to stderr (for debugging).
Definition: VPlan.cpp:104
llvm::Twine
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:83
llvm::VPSlotTracker
This class can be used to assign consecutive numbers to all VPValues in a VPlan and allows querying t...
Definition: VPlanValue.h:418
llvm::DenseMapBase< DenseMap< KeyT, ValueT, DenseMapInfo< KeyT >, llvm::detail::DenseMapPair< KeyT, ValueT > >, KeyT, ValueT, DenseMapInfo< KeyT >, llvm::detail::DenseMapPair< KeyT, ValueT > >::end
iterator end()
Definition: DenseMap.h:83
llvm::AMDGPU::SendMsg::Op
Op
Definition: SIDefines.h:325
llvm::VPValue::getDef
VPDef * getDef()
Definition: VPlanValue.h:180
llvm::VPUser::VPUser
VPUser(ArrayRef< VPValue * > Operands, VPUserID ID)
Definition: VPlanValue.h:226
llvm::VPRecipeBase
VPRecipeBase is a base class modeling a sequence of one or more output IR instructions.
Definition: VPlan.h:673
llvm::VPUser::operator=
VPUser & operator=(const VPUser &)=delete
llvm::TargetStackID::Value
Value
Definition: TargetFrameLowering.h:27
llvm::VPValue::UnderlyingVal
Value * UnderlyingVal
Definition: VPlanValue.h:61
llvm::SlotTracker
This class provides computation of slot numbers for LLVM Assembly writing.
Definition: AsmWriter.cpp:653
llvm::VPValue::const_user_range
iterator_range< const_user_iterator > const_user_range
Definition: VPlanValue.h:155
llvm::VPValue2ValueTy
DenseMap< VPValue *, Value * > VPValue2ValueTy
Definition: VPlanValue.h:199
llvm::VPValue::hasMoreThanOneUniqueUser
bool hasMoreThanOneUniqueUser()
Returns true if the value has more than one unique user.
Definition: VPlanValue.h:167
llvm::VPDef::VPRecipeTy
enum { VPBranchOnMaskSC, VPInstructionSC, VPInterleaveSC, VPReductionSC, VPReplicateSC, VPWidenCallSC, VPWidenCanonicalIVSC, VPWidenGEPSC, VPWidenMemoryInstructionSC, VPWidenSC, VPWidenSelectSC, VPBlendSC, VPCanonicalIVPHISC, VPFirstOrderRecurrencePHISC, VPWidenPHISC, VPWidenIntOrFpInductionSC, VPPredInstPHISC, VPReductionPHISC, VPFirstPHISC=VPBlendSC, VPLastPHISC=VPReductionPHISC, } VPRecipeTy
An enumeration for keeping track of the concrete subclass of VPRecipeBase that is actually instantiat...
Definition: VPlanValue.h:351
llvm::VPValue::VPVReductionPHISC
@ VPVReductionPHISC
Definition: VPlanValue.h:110
llvm::VPUser
This class augments VPValue with operands which provide the inverse def-use edges from VPValue's user...
Definition: VPlanValue.h:205
llvm::VPValue::VPVFirstOrderRecurrencePHISC
@ VPVFirstOrderRecurrencePHISC
Definition: VPlanValue.h:106
llvm::VPlanTransforms
Definition: VPlanTransforms.h:27
SmallVector.h
llvm::VPValue::VPVWidenPHISC
@ VPVWidenPHISC
Definition: VPlanValue.h:107
llvm::SmallVectorImpl::iterator
typename SuperClass::iterator iterator
Definition: SmallVector.h:556
llvm::VPUser::getOperand
VPValue * getOperand(unsigned N) const
Definition: VPlanValue.h:257
N
#define N
Users
iv Induction Variable Users
Definition: IVUsers.cpp:52
llvm::VPUser::VPUser
VPUser()=delete
llvm::iterator_range
A range adaptor for a pair of iterators.
Definition: iterator_range.h:30
llvm::VPDef::definedValues
ArrayRef< VPValue * > definedValues()
Returns an ArrayRef of the values defined by the VPDef.
Definition: VPlanValue.h:390
llvm::VPValue::getVPValueID
unsigned getVPValueID() const
Definition: VPlanValue.h:123
llvm::VPDef::~VPDef
virtual ~VPDef()
Definition: VPlanValue.h:355
llvm::VPUser::operands
const_operand_range operands() const
Definition: VPlanValue.h:283
llvm::VPValue::removeUser
void removeUser(VPUser &User)
Remove a single User from the list of users.
Definition: VPlanValue.h:137
llvm::VPValue::VPValue
VPValue(Value *UV=nullptr, VPDef *Def=nullptr)
Definition: VPlanValue.h:113
llvm::VPValue::~VPValue
virtual ~VPValue()
Definition: VPlan.cpp:82
llvm::TinyPtrVector
TinyPtrVector - This class is specialized for cases where there are normally 0 or 1 element in a vect...
Definition: TinyPtrVector.h:30
llvm::VPValue::VPVInstructionSC
@ VPVInstructionSC
Definition: VPlanValue.h:93
llvm::VPDef::getVPDefID
unsigned getVPDefID() const
Definition: VPlanValue.h:400
llvm::VPValue::getUnderlyingValue
Value * getUnderlyingValue()
Return the underlying Value attached to this VPValue.
Definition: VPlanValue.h:84
llvm::VPValue::const_user_iterator
SmallVectorImpl< VPUser * >::const_iterator const_user_iterator
Definition: VPlanValue.h:153
llvm::VPlan
VPlan models a candidate for vectorization, encoding various decisions take to produce efficient outp...
Definition: VPlan.h:2198
llvm::Value
LLVM Value Representation.
Definition: Value.h:74
llvm::VPValue::printAsOperand
void printAsOperand(raw_ostream &OS, VPSlotTracker &Tracker) const
Definition: VPlan.cpp:1558
Other
Optional< std::vector< StOtherPiece > > Other
Definition: ELFYAML.cpp:1198
llvm::VPUser::const_operand_range
iterator_range< const_operand_iterator > const_operand_range
Definition: VPlanValue.h:276