LLVM  16.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.
106  // Header-phi recipes. Need to be kept together.
116  };
117 
118  VPValue(Value *UV = nullptr, VPDef *Def = nullptr)
119  : VPValue(VPValueSC, UV, Def) {}
120  VPValue(const VPValue &) = delete;
121  VPValue &operator=(const VPValue &) = delete;
122 
123  virtual ~VPValue();
124 
125  /// \return an ID for the concrete type of this object.
126  /// This is used to implement the classof checks. This should not be used
127  /// for any other purpose, as the values may change as LLVM evolves.
128  unsigned getVPValueID() const { return SubclassID; }
129 
130 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
131  void printAsOperand(raw_ostream &OS, VPSlotTracker &Tracker) const;
132  void print(raw_ostream &OS, VPSlotTracker &Tracker) const;
133 
134  /// Dump the value to stderr (for debugging).
135  void dump() const;
136 #endif
137 
138  unsigned getNumUsers() const { return Users.size(); }
139  void addUser(VPUser &User) { Users.push_back(&User); }
140 
141  /// Remove a single \p User from the list of users.
143  bool Found = false;
144  // The same user can be added multiple times, e.g. because the same VPValue
145  // is used twice by the same VPUser. Remove a single one.
146  erase_if(Users, [&User, &Found](VPUser *Other) {
147  if (Found)
148  return false;
149  if (Other == &User) {
150  Found = true;
151  return true;
152  }
153  return false;
154  });
155  }
156 
161 
162  user_iterator user_begin() { return Users.begin(); }
163  const_user_iterator user_begin() const { return Users.begin(); }
164  user_iterator user_end() { return Users.end(); }
165  const_user_iterator user_end() const { return Users.end(); }
168  return const_user_range(user_begin(), user_end());
169  }
170 
171  /// Returns true if the value has more than one unique user.
173  if (getNumUsers() == 0)
174  return false;
175 
176  // Check if all users match the first user.
177  auto Current = std::next(user_begin());
178  while (Current != user_end() && *user_begin() == *Current)
179  Current++;
180  return Current != user_end();
181  }
182 
183  void replaceAllUsesWith(VPValue *New);
184 
185  VPDef *getDef() { return Def; }
186  const VPDef *getDef() const { return Def; }
187 
188  /// Returns the underlying IR value, if this VPValue is defined outside the
189  /// scope of VPlan. Returns nullptr if the VPValue is defined by a VPDef
190  /// inside a VPlan.
192  assert(!getDef() &&
193  "VPValue is not a live-in; it is defined by a VPDef inside a VPlan");
194  return getUnderlyingValue();
195  }
196  const Value *getLiveInIRValue() const {
197  assert(!getDef() &&
198  "VPValue is not a live-in; it is defined by a VPDef inside a VPlan");
199  return getUnderlyingValue();
200  }
201 };
202 
205 
206 raw_ostream &operator<<(raw_ostream &OS, const VPValue &V);
207 
208 /// This class augments VPValue with operands which provide the inverse def-use
209 /// edges from VPValue's users to their defs.
210 class VPUser {
211 public:
212  /// Subclass identifier (for isa/dyn_cast).
213  enum class VPUserID {
214  Recipe,
215  LiveOut,
216  };
217 
218 private:
219  SmallVector<VPValue *, 2> Operands;
220 
221  VPUserID ID;
222 
223 protected:
224 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
225  /// Print the operands to \p O.
227 #endif
228 
230  for (VPValue *Operand : Operands)
231  addOperand(Operand);
232  }
233 
234  VPUser(std::initializer_list<VPValue *> Operands, VPUserID ID)
235  : VPUser(ArrayRef<VPValue *>(Operands), ID) {}
236 
237  template <typename IterT>
239  for (VPValue *Operand : Operands)
240  addOperand(Operand);
241  }
242 
243 public:
244  VPUser() = delete;
245  VPUser(const VPUser &) = delete;
246  VPUser &operator=(const VPUser &) = delete;
247  virtual ~VPUser() {
248  for (VPValue *Op : operands())
249  Op->removeUser(*this);
250  }
251 
252  VPUserID getVPUserID() const { return ID; }
253 
254  void addOperand(VPValue *Operand) {
255  Operands.push_back(Operand);
256  Operand->addUser(*this);
257  }
258 
259  unsigned getNumOperands() const { return Operands.size(); }
260  inline VPValue *getOperand(unsigned N) const {
261  assert(N < Operands.size() && "Operand index out of bounds");
262  return Operands[N];
263  }
264 
265  void setOperand(unsigned I, VPValue *New) {
266  Operands[I]->removeUser(*this);
267  Operands[I] = New;
268  New->addUser(*this);
269  }
270 
272  VPValue *Op = Operands.pop_back_val();
273  Op->removeUser(*this);
274  }
275 
280 
281  operand_iterator op_begin() { return Operands.begin(); }
282  const_operand_iterator op_begin() const { return Operands.begin(); }
283  operand_iterator op_end() { return Operands.end(); }
284  const_operand_iterator op_end() const { return Operands.end(); }
287  return const_operand_range(op_begin(), op_end());
288  }
289 
290  /// Method to support type inquiry through isa, cast, and dyn_cast.
291  static inline bool classof(const VPDef *Recipe);
292 
293  /// Returns true if the VPUser uses scalars of operand \p Op. Conservatively
294  /// returns if only first (scalar) lane is used, as default.
295  virtual bool usesScalars(const VPValue *Op) const {
297  "Op must be an operand of the recipe");
298  return onlyFirstLaneUsed(Op);
299  }
300 
301  /// Returns true if the VPUser only uses the first lane of operand \p Op.
302  /// Conservatively returns false.
303  virtual bool onlyFirstLaneUsed(const VPValue *Op) const {
305  "Op must be an operand of the recipe");
306  return false;
307  }
308 };
309 
310 /// This class augments a recipe with a set of VPValues defined by the recipe.
311 /// It allows recipes to define zero, one or multiple VPValues. A VPDef owns
312 /// the VPValues it defines and is responsible for deleting its defined values.
313 /// Single-value VPDefs that also inherit from VPValue must make sure to inherit
314 /// from VPDef before VPValue.
315 class VPDef {
316  friend class VPValue;
317 
318  /// Subclass identifier (for isa/dyn_cast).
319  const unsigned char SubclassID;
320 
321  /// The VPValues defined by this VPDef.
322  TinyPtrVector<VPValue *> DefinedValues;
323 
324  /// Add \p V as a defined value by this VPDef.
325  void addDefinedValue(VPValue *V) {
326  assert(V->getDef() == this &&
327  "can only add VPValue already linked with this VPDef");
328  DefinedValues.push_back(V);
329  }
330 
331  /// Remove \p V from the values defined by this VPDef. \p V must be a defined
332  /// value of this VPDef.
333  void removeDefinedValue(VPValue *V) {
334  assert(V->getDef() == this &&
335  "can only remove VPValue linked with this VPDef");
336  assert(is_contained(DefinedValues, V) &&
337  "VPValue to remove must be in DefinedValues");
338  erase_value(DefinedValues, V);
339  V->Def = nullptr;
340  }
341 
342 public:
343  /// An enumeration for keeping track of the concrete subclass of VPRecipeBase
344  /// that is actually instantiated. Values of this enumeration are kept in the
345  /// SubclassID field of the VPRecipeBase objects. They are used for concrete
346  /// type identification.
347  using VPRecipeTy = enum {
348  VPBranchOnMaskSC,
349  VPExpandSCEVSC,
350  VPInstructionSC,
351  VPInterleaveSC,
352  VPReductionSC,
353  VPReplicateSC,
354  VPScalarIVStepsSC,
355  VPWidenCallSC,
356  VPWidenCanonicalIVSC,
357  VPWidenGEPSC,
358  VPWidenMemoryInstructionSC,
359  VPWidenSC,
360  VPWidenSelectSC,
361 
362  // Phi-like recipes. Need to be kept together.
363  VPBlendSC,
364  VPPredInstPHISC,
365  // Header-phi recipes. Need to be kept together.
366  VPCanonicalIVPHISC,
367  VPActiveLaneMaskPHISC,
368  VPFirstOrderRecurrencePHISC,
369  VPWidenPHISC,
370  VPWidenIntOrFpInductionSC,
371  VPWidenPointerInductionSC,
372  VPReductionPHISC,
373  VPFirstPHISC = VPBlendSC,
374  VPFirstHeaderPHISC = VPCanonicalIVPHISC,
375  VPLastPHISC = VPReductionPHISC,
376  };
377 
378  VPDef(const unsigned char SC) : SubclassID(SC) {}
379 
380  virtual ~VPDef() {
381  for (VPValue *D : make_early_inc_range(DefinedValues)) {
382  assert(D->Def == this &&
383  "all defined VPValues should point to the containing VPDef");
384  assert(D->getNumUsers() == 0 &&
385  "all defined VPValues should have no more users");
386  D->Def = nullptr;
387  delete D;
388  }
389  }
390 
391  /// Returns the only VPValue defined by the VPDef. Can only be called for
392  /// VPDefs with a single defined value.
394  assert(DefinedValues.size() == 1 && "must have exactly one defined value");
395  assert(DefinedValues[0] && "defined value must be non-null");
396  return DefinedValues[0];
397  }
398  const VPValue *getVPSingleValue() const {
399  assert(DefinedValues.size() == 1 && "must have exactly one defined value");
400  assert(DefinedValues[0] && "defined value must be non-null");
401  return DefinedValues[0];
402  }
403 
404  /// Returns the VPValue with index \p I defined by the VPDef.
405  VPValue *getVPValue(unsigned I) {
406  assert(DefinedValues[I] && "defined value must be non-null");
407  return DefinedValues[I];
408  }
409  const VPValue *getVPValue(unsigned I) const {
410  assert(DefinedValues[I] && "defined value must be non-null");
411  return DefinedValues[I];
412  }
413 
414  /// Returns an ArrayRef of the values defined by the VPDef.
415  ArrayRef<VPValue *> definedValues() { return DefinedValues; }
416  /// Returns an ArrayRef of the values defined by the VPDef.
417  ArrayRef<VPValue *> definedValues() const { return DefinedValues; }
418 
419  /// Returns the number of values defined by the VPDef.
420  unsigned getNumDefinedValues() const { return DefinedValues.size(); }
421 
422  /// \return an ID for the concrete type of this object.
423  /// This is used to implement the classof checks. This should not be used
424  /// for any other purpose, as the values may change as LLVM evolves.
425  unsigned getVPDefID() const { return SubclassID; }
426 
427 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
428  /// Dump the VPDef to stderr (for debugging).
429  void dump() const;
430 
431  /// Each concrete VPDef prints itself.
432  virtual void print(raw_ostream &O, const Twine &Indent,
433  VPSlotTracker &SlotTracker) const = 0;
434 #endif
435 };
436 
437 class VPlan;
438 class VPBasicBlock;
439 
440 /// This class can be used to assign consecutive numbers to all VPValues in a
441 /// VPlan and allows querying the numbering for printing, similar to the
442 /// ModuleSlotTracker for IR values.
445  unsigned NextSlot = 0;
446 
447  void assignSlot(const VPValue *V);
448  void assignSlots(const VPlan &Plan);
449 
450 public:
451  VPSlotTracker(const VPlan *Plan = nullptr) {
452  if (Plan)
453  assignSlots(*Plan);
454  }
455 
456  unsigned getSlot(const VPValue *V) const {
457  auto I = Slots.find(V);
458  if (I == Slots.end())
459  return -1;
460  return I->second;
461  }
462 };
463 
464 } // namespace llvm
465 
466 #endif // LLVM_TRANSFORMS_VECTORIZE_VPLAN_VALUE_H
llvm::VPUser::getVPUserID
VPUserID getVPUserID() const
Definition: VPlanValue.h:252
llvm::VPUser::op_end
operand_iterator op_end()
Definition: VPlanValue.h:283
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
llvm::VPDef::VPRecipeTy
enum { VPBranchOnMaskSC, VPExpandSCEVSC, VPInstructionSC, VPInterleaveSC, VPReductionSC, VPReplicateSC, VPScalarIVStepsSC, VPWidenCallSC, VPWidenCanonicalIVSC, VPWidenGEPSC, VPWidenMemoryInstructionSC, VPWidenSC, VPWidenSelectSC, VPBlendSC, VPPredInstPHISC, VPCanonicalIVPHISC, VPActiveLaneMaskPHISC, VPFirstOrderRecurrencePHISC, VPWidenPHISC, VPWidenIntOrFpInductionSC, VPWidenPointerInductionSC, VPReductionPHISC, VPFirstPHISC=VPBlendSC, VPFirstHeaderPHISC=VPCanonicalIVPHISC, VPLastPHISC=VPReductionPHISC, } VPRecipeTy
An enumeration for keeping track of the concrete subclass of VPRecipeBase that is actually instantiat...
Definition: VPlanValue.h:376
llvm::VPUser::VPUser
VPUser(iterator_range< IterT > Operands, VPUserID ID)
Definition: VPlanValue.h:238
llvm::VPValue::user_end
const_user_iterator user_end() const
Definition: VPlanValue.h:165
llvm::VPValue::getDef
const VPDef * getDef() const
Definition: VPlanValue.h:186
llvm::VPUser::removeLastOperand
void removeLastOperand()
Definition: VPlanValue.h:271
llvm::VPBasicBlock
VPBasicBlock serves as the leaf of the Hierarchical Control-Flow Graph.
Definition: VPlan.h:2013
llvm::VPValue::user_iterator
SmallVectorImpl< VPUser * >::iterator user_iterator
Definition: VPlanValue.h:157
llvm::VPValue::getLiveInIRValue
Value * getLiveInIRValue()
Returns the underlying IR value, if this VPValue is defined outside the scope of VPlan.
Definition: VPlanValue.h:191
llvm::SmallVector
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1181
llvm::VPDef::getVPSingleValue
VPValue * getVPSingleValue()
Returns the only VPValue defined by the VPDef.
Definition: VPlanValue.h:393
llvm::VPInterleavedAccessInfo
Definition: VPlan.h:2909
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:159
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:1802
llvm::VPValue::VPVWidenCanonicalIVSC
@ VPVWidenCanonicalIVSC
Definition: VPlanValue.h:99
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:95
llvm::VPUser::op_begin
operand_iterator op_begin()
Definition: VPlanValue.h:281
llvm::VPDef::VPDef
VPDef(const unsigned char SC)
Definition: VPlanValue.h:378
llvm::VPDef::getVPSingleValue
const VPValue * getVPSingleValue() const
Definition: VPlanValue.h:398
llvm::VPValue::print
void print(raw_ostream &OS, VPSlotTracker &Tracker) const
Definition: VPlan.cpp:88
llvm::VPValue::VPVInstructionSC
@ VPVInstructionSC
Definition: VPlanValue.h:93
STLExtras.h
llvm::VPUser::operands
operand_range operands()
Definition: VPlanValue.h:285
llvm::VPUser::VPUserID
VPUserID
Subclass identifier (for isa/dyn_cast).
Definition: VPlanValue.h:213
llvm::VPValue::VPVWidenPointerInductionSC
@ VPVWidenPointerInductionSC
Definition: VPlanValue.h:112
llvm::VPValue::VPVReductionSC
@ VPVReductionSC
Definition: VPlanValue.h:95
llvm::VPValue::VPValue
VPValue(const unsigned char SC, Value *UV=nullptr, VPDef *Def=nullptr)
Definition: VPlan.cpp:75
llvm::VPUser::const_operand_iterator
SmallVectorImpl< VPValue * >::const_iterator const_operand_iterator
Definition: VPlanValue.h:277
llvm::VPValue::users
user_range users()
Definition: VPlanValue.h:166
llvm::VPDef
This class augments a recipe with a set of VPValues defined by the recipe.
Definition: VPlanValue.h:315
llvm::VPUser::VPUser
VPUser(std::initializer_list< VPValue * > Operands, VPUserID ID)
Definition: VPlanValue.h:234
llvm::VPValue::VPVFirstOrderRecurrencePHISC
@ VPVFirstOrderRecurrencePHISC
Definition: VPlanValue.h:109
llvm::VPInstruction
This is a concrete Recipe that models a single VPlan-level instruction.
Definition: VPlan.h:775
llvm::VPUser::op_end
const_operand_iterator op_end() const
Definition: VPlanValue.h:284
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::VPValue::VPVPredInstPHI
@ VPVPredInstPHI
Definition: VPlanValue.h:105
llvm::User
Definition: User.h:44
llvm::VPValue::VPValueSC
@ VPValueSC
Definition: VPlanValue.h:92
llvm::VPValue::addUser
void addUser(VPUser &User)
Definition: VPlanValue.h:139
llvm::VPValue::VPVBlendSC
@ VPVBlendSC
Definition: VPlanValue.h:104
llvm::VPDef::definedValues
ArrayRef< VPValue * > definedValues() const
Returns an ArrayRef of the values defined by the VPDef.
Definition: VPlanValue.h:417
llvm::TinyPtrVector::push_back
void push_back(EltTy NewVal)
Definition: TinyPtrVector.h:244
llvm::VPUser::VPUserID::Recipe
@ Recipe
llvm::VPValue::replaceAllUsesWith
void replaceAllUsesWith(VPValue *New)
Definition: VPlan.cpp:979
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
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:420
llvm::VPValue::VPVActiveLaneMaskPHISC
@ VPVActiveLaneMaskPHISC
Definition: VPlanValue.h:108
llvm::VPValue::VPVCanonicalIVPHISC
@ VPVCanonicalIVPHISC
Definition: VPlanValue.h:107
llvm::VPValue::getUnderlyingValue
const Value * getUnderlyingValue() const
Definition: VPlanValue.h:85
llvm::VPValue::users
const_user_range users() const
Definition: VPlanValue.h:167
llvm::VPUser::getNumOperands
unsigned getNumOperands() const
Definition: VPlanValue.h:259
llvm::CallingConv::ID
unsigned ID
LLVM IR allows to use arbitrary numbers as calling convention identifiers.
Definition: CallingConv.h:24
llvm::erase_value
void erase_value(Container &C, ValueType V)
Wrapper function to remove a value from a container:
Definition: STLExtras.h:1810
llvm::VPValue::getLiveInIRValue
const Value * getLiveInIRValue() const
Definition: VPlanValue.h:196
Operands
mir Rename Register Operands
Definition: MIRNamerPass.cpp:74
llvm::VPUser::setOperand
void setOperand(unsigned I, VPValue *New)
Definition: VPlanValue.h:265
llvm::VPValue::VPVWidenSC
@ VPVWidenSC
Definition: VPlanValue.h:97
llvm::RISCVFenceField::O
@ O
Definition: RISCVBaseInfo.h:264
llvm::VPValue::Def
VPDef * Def
Pointer to the VPDef that defines this VPValue.
Definition: VPlanValue.h:65
llvm::VPSlotTracker::getSlot
unsigned getSlot(const VPValue *V) const
Definition: VPlanValue.h:456
D
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
llvm::VPValue::VPVFirstHeaderPHISC
@ VPVFirstHeaderPHISC
Definition: VPlanValue.h:114
llvm::VPValue::VPVReductionPHISC
@ VPVReductionPHISC
Definition: VPlanValue.h:113
llvm::DenseMap< Value *, VPValue * >
llvm::VPValue::getNumUsers
unsigned getNumUsers() const
Definition: VPlanValue.h:138
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:596
llvm::VPUser::op_begin
const_operand_iterator op_begin() const
Definition: VPlanValue.h:282
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:1673
llvm::VPValue::user_end
user_iterator user_end()
Definition: VPlanValue.h:164
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:564
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::VPValue::user_begin
const_user_iterator user_begin() const
Definition: VPlanValue.h:163
iterator_range.h
llvm::Value2VPValueTy
DenseMap< Value *, VPValue * > Value2VPValueTy
Definition: VPlanValue.h:203
llvm::VPUser::printOperands
void printOperands(raw_ostream &O, VPSlotTracker &SlotTracker) const
Print the operands to O.
Definition: VPlan.cpp:1010
llvm::VPWidenMemoryInstructionRecipe
A Recipe for widening load/store operations.
Definition: VPlan.h:1702
llvm::VPValue::VPVWidenSelectSC
@ VPVWidenSelectSC
Definition: VPlanValue.h:101
TinyPtrVector.h
llvm::VPSlotTracker::VPSlotTracker
VPSlotTracker(const VPlan *Plan=nullptr)
Definition: VPlanValue.h:451
llvm::VPValue::user_begin
user_iterator user_begin()
Definition: VPlanValue.h:162
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:247
llvm::VPUser::addOperand
void addOperand(VPValue *Operand)
Definition: VPlanValue.h:254
llvm::VPUser::onlyFirstLaneUsed
virtual bool onlyFirstLaneUsed(const VPValue *Op) const
Returns true if the VPUser only uses the first lane of operand Op.
Definition: VPlanValue.h:303
llvm::VPDef::getVPValue
const VPValue * getVPValue(unsigned I) const
Definition: VPlanValue.h:409
llvm::VPDef::getVPValue
VPValue * getVPValue(unsigned I)
Returns the VPValue with index I defined by the VPDef.
Definition: VPlanValue.h:405
llvm::VPValue::setUnderlyingValue
void setUnderlyingValue(Value *Val)
Definition: VPlanValue.h:77
llvm::VPUser::operand_range
iterator_range< operand_iterator > operand_range
Definition: VPlanValue.h:278
llvm::VPUser::operand_iterator
SmallVectorImpl< VPValue * >::iterator operand_iterator
Definition: VPlanValue.h:276
llvm::VPUser::classof
static bool classof(const VPDef *Recipe)
Method to support type inquiry through isa, cast, and dyn_cast.
Definition: VPlan.h:757
llvm::VPDef::dump
void dump() const
Dump the VPDef to stderr (for debugging).
Definition: VPlan.cpp:103
llvm::Twine
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
llvm::VPSlotTracker
This class can be used to assign consecutive numbers to all VPValues in a VPlan and allows querying t...
Definition: VPlanValue.h:443
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:84
llvm::AMDGPU::SendMsg::Op
Op
Definition: SIDefines.h:348
llvm::VPValue::getDef
VPDef * getDef()
Definition: VPlanValue.h:185
llvm::VPUser::VPUser
VPUser(ArrayRef< VPValue * > Operands, VPUserID ID)
Definition: VPlanValue.h:229
llvm::VPRecipeBase
VPRecipeBase is a base class modeling a sequence of one or more output IR instructions.
Definition: VPlan.h:663
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:664
llvm::VPValue::const_user_range
iterator_range< const_user_iterator > const_user_range
Definition: VPlanValue.h:160
llvm::VPValue2ValueTy
DenseMap< VPValue *, Value * > VPValue2ValueTy
Definition: VPlanValue.h:204
llvm::VPValue::hasMoreThanOneUniqueUser
bool hasMoreThanOneUniqueUser()
Returns true if the value has more than one unique user.
Definition: VPlanValue.h:172
llvm::VPUser::VPUserID::LiveOut
@ LiveOut
llvm::VPValue::VPVLastPHISC
@ VPVLastPHISC
Definition: VPlanValue.h:115
llvm::VPUser
This class augments VPValue with operands which provide the inverse def-use edges from VPValue's user...
Definition: VPlanValue.h:210
llvm::VPlanTransforms
Definition: VPlanTransforms.h:28
llvm::VPValue::VPVWidenGEPSC
@ VPVWidenGEPSC
Definition: VPlanValue.h:100
SmallVector.h
llvm::VPValue::VPVWidenPHISC
@ VPVWidenPHISC
Definition: VPlanValue.h:110
llvm::SmallVectorImpl::iterator
typename SuperClass::iterator iterator
Definition: SmallVector.h:563
llvm::VPUser::getOperand
VPValue * getOperand(unsigned N) const
Definition: VPlanValue.h:260
N
#define N
llvm::VPValue::VPVWidenIntOrFpInductionSC
@ VPVWidenIntOrFpInductionSC
Definition: VPlanValue.h:111
Users
iv Induction Variable Users
Definition: IVUsers.cpp:48
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:415
llvm::VPUser::usesScalars
virtual bool usesScalars(const VPValue *Op) const
Returns true if the VPUser uses scalars of operand Op.
Definition: VPlanValue.h:295
llvm::VPValue::getVPValueID
unsigned getVPValueID() const
Definition: VPlanValue.h:128
llvm::VPValue::VPVReplicateSC
@ VPVReplicateSC
Definition: VPlanValue.h:96
llvm::VPDef::~VPDef
virtual ~VPDef()
Definition: VPlanValue.h:380
llvm::VPUser::operands
const_operand_range operands() const
Definition: VPlanValue.h:286
llvm::VPValue::removeUser
void removeUser(VPUser &User)
Remove a single User from the list of users.
Definition: VPlanValue.h:142
llvm::VPValue::VPValue
VPValue(Value *UV=nullptr, VPDef *Def=nullptr)
Definition: VPlanValue.h:118
llvm::VPValue::~VPValue
virtual ~VPValue()
Definition: VPlan.cpp:81
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::VPVWidenCallSC
@ VPVWidenCallSC
Definition: VPlanValue.h:98
llvm::VPDef::getVPDefID
unsigned getVPDefID() const
Definition: VPlanValue.h:425
llvm::VPValue::VPVMemoryInstructionSC
@ VPVMemoryInstructionSC
Definition: VPlanValue.h:94
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:158
llvm::VPlan
VPlan models a candidate for vectorization, encoding various decisions take to produce efficient outp...
Definition: VPlan.h:2492
llvm::Value
LLVM Value Representation.
Definition: Value.h:74
llvm::VPValue::printAsOperand
void printAsOperand(raw_ostream &OS, VPSlotTracker &Tracker) const
Definition: VPlan.cpp:995
Other
Optional< std::vector< StOtherPiece > > Other
Definition: ELFYAML.cpp:1247
llvm::VPUser::const_operand_range
iterator_range< const_operand_iterator > const_operand_range
Definition: VPlanValue.h:279