MLIR  21.0.0git
Value.h
Go to the documentation of this file.
1 //===- Value.h - Base of the SSA Value hierarchy ----------------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file defines generic Value type and manipulation utilities.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #ifndef MLIR_IR_VALUE_H
14 #define MLIR_IR_VALUE_H
15 
16 #include "mlir/IR/Types.h"
17 #include "mlir/IR/UseDefLists.h"
18 #include "mlir/Support/LLVM.h"
19 #include "llvm/Support/PointerLikeTypeTraits.h"
20 
21 namespace mlir {
22 class AsmState;
23 class Block;
24 class BlockArgument;
25 class Operation;
26 class OpOperand;
27 class OpPrintingFlags;
28 class OpResult;
29 class Region;
30 class Value;
31 
32 //===----------------------------------------------------------------------===//
33 // Value
34 //===----------------------------------------------------------------------===//
35 
36 namespace detail {
37 
38 /// The base class for all derived Value classes. It contains all of the
39 /// components that are shared across Value classes.
40 class alignas(8) ValueImpl : public IRObjectWithUseList<OpOperand> {
41 public:
42  /// The enumeration represents the various different kinds of values the
43  /// internal representation may take. We use all of the bits from Type that we
44  /// can to store indices inline.
45  enum class Kind {
46  /// The first N kinds are all inline operation results. An inline operation
47  /// result means that the kind represents the result number. This removes
48  /// the need to store an additional index value. The derived class here is
49  /// an `OpResultImpl`.
50  InlineOpResult = 0,
51 
52  /// The next kind represents a 'out-of-line' operation result. This is for
53  /// results with numbers larger than we can represent inline. The derived
54  /// class here is an `OpResultImpl`.
56 
57  /// The last kind represents a block argument. The derived class here is an
58  /// `BlockArgumentImpl`.
59  BlockArgument = 7
60  };
61 
62  /// Return the type of this value.
63  Type getType() const { return typeAndKind.getPointer(); }
64 
65  /// Set the type of this value.
66  void setType(Type type) { return typeAndKind.setPointer(type); }
67 
68  /// Return the kind of this value.
69  Kind getKind() const { return typeAndKind.getInt(); }
70 
71 protected:
72  ValueImpl(Type type, Kind kind) : typeAndKind(type, kind) {}
73 
74  /// Expose a few methods explicitly for the debugger to call for
75  /// visualization.
76 #ifndef NDEBUG
77  LLVM_DUMP_METHOD Type debug_getType() const { return getType(); }
78  LLVM_DUMP_METHOD Kind debug_getKind() const { return getKind(); }
79 
80 #endif
81 
82  /// The type of this result and the kind.
83  llvm::PointerIntPair<Type, 3, Kind> typeAndKind;
84 };
85 } // namespace detail
86 
87 /// This class represents an instance of an SSA value in the MLIR system,
88 /// representing a computable value that has a type and a set of users. An SSA
89 /// value is either a BlockArgument or the result of an operation. Note: This
90 /// class has value-type semantics and is just a simple wrapper around a
91 /// ValueImpl that is either owner by a block(in the case of a BlockArgument) or
92 /// an Operation(in the case of an OpResult).
93 /// As most IR constructs, this isn't const-correct, but we keep method
94 /// consistent and as such method that immediately modify this Value aren't
95 /// marked `const` (include modifying the Value use-list).
96 class Value {
97 public:
98  constexpr Value(detail::ValueImpl *impl = nullptr) : impl(impl) {}
99 
100  explicit operator bool() const { return impl; }
101  bool operator==(const Value &other) const { return impl == other.impl; }
102  bool operator!=(const Value &other) const { return !(*this == other); }
103 
104  /// Return the type of this value.
105  Type getType() const { return impl->getType(); }
106 
107  /// Utility to get the associated MLIRContext that this value is defined in.
108  MLIRContext *getContext() const { return getType().getContext(); }
109 
110  /// Mutate the type of this Value to be of the specified type.
111  ///
112  /// Note that this is an extremely dangerous operation which can create
113  /// completely invalid IR very easily. It is strongly recommended that you
114  /// recreate IR objects with the right types instead of mutating them in
115  /// place.
116  void setType(Type newType) { impl->setType(newType); }
117 
118  /// If this value is the result of an operation, return the operation that
119  /// defines it.
120  Operation *getDefiningOp() const;
121 
122  /// If this value is the result of an operation of type OpTy, return the
123  /// operation that defines it.
124  template <typename OpTy>
125  OpTy getDefiningOp() const {
126  return llvm::dyn_cast_or_null<OpTy>(getDefiningOp());
127  }
128 
129  /// Return the location of this value.
130  Location getLoc() const;
131  void setLoc(Location loc);
132 
133  /// Return the Region in which this Value is defined.
135 
136  /// Return the Block in which this Value is defined.
138 
139  //===--------------------------------------------------------------------===//
140  // UseLists
141  //===--------------------------------------------------------------------===//
142 
143  /// Drop all uses of this object from their respective owners.
144  void dropAllUses() { return impl->dropAllUses(); }
145 
146  /// Replace all uses of 'this' value with the new value, updating anything in
147  /// the IR that uses 'this' to use the other value instead. When this returns
148  /// there are zero uses of 'this'.
149  void replaceAllUsesWith(Value newValue) {
150  impl->replaceAllUsesWith(newValue);
151  }
152 
153  /// Replace all uses of 'this' value with 'newValue', updating anything in the
154  /// IR that uses 'this' to use the other value instead except if the user is
155  /// listed in 'exceptions' .
156  void replaceAllUsesExcept(Value newValue,
157  const SmallPtrSetImpl<Operation *> &exceptions);
158 
159  /// Replace all uses of 'this' value with 'newValue', updating anything in the
160  /// IR that uses 'this' to use the other value instead except if the user is
161  /// 'exceptedUser'.
162  void replaceAllUsesExcept(Value newValue, Operation *exceptedUser);
163 
164  /// Replace all uses of 'this' value with 'newValue' if the given callback
165  /// returns true.
166  void replaceUsesWithIf(Value newValue,
167  function_ref<bool(OpOperand &)> shouldReplace);
168 
169  /// Returns true if the value is used outside of the given block.
170  bool isUsedOutsideOfBlock(Block *block) const;
171 
172  /// Shuffle the use list order according to the provided indices. It is
173  /// responsibility of the caller to make sure that the indices map the current
174  /// use-list chain to another valid use-list chain.
175  void shuffleUseList(ArrayRef<unsigned> indices);
176 
177  //===--------------------------------------------------------------------===//
178  // Uses
179 
180  /// This class implements an iterator over the uses of a value.
183 
184  use_iterator use_begin() const { return impl->use_begin(); }
185  use_iterator use_end() const { return use_iterator(); }
186 
187  /// Returns a range of all uses, which is useful for iterating over all uses.
188  use_range getUses() const { return {use_begin(), use_end()}; }
189 
190  /// Returns true if this value has exactly one use.
191  bool hasOneUse() const { return impl->hasOneUse(); }
192 
193  /// Returns true if this value has no uses.
194  bool use_empty() const { return impl->use_empty(); }
195 
196  //===--------------------------------------------------------------------===//
197  // Users
198 
201 
202  user_iterator user_begin() const { return use_begin(); }
203  user_iterator user_end() const { return use_end(); }
204  user_range getUsers() const { return {user_begin(), user_end()}; }
205 
206  //===--------------------------------------------------------------------===//
207  // Utilities
208 
209  void print(raw_ostream &os) const;
210  void print(raw_ostream &os, const OpPrintingFlags &flags) const;
211  void print(raw_ostream &os, AsmState &state) const;
212  void dump() const;
213 
214  /// Print this value as if it were an operand.
215  void printAsOperand(raw_ostream &os, AsmState &state) const;
216  void printAsOperand(raw_ostream &os, const OpPrintingFlags &flags) const;
217 
218  /// Methods for supporting PointerLikeTypeTraits.
219  void *getAsOpaquePointer() const { return impl; }
220  static Value getFromOpaquePointer(const void *pointer) {
221  return reinterpret_cast<detail::ValueImpl *>(const_cast<void *>(pointer));
222  }
223  detail::ValueImpl *getImpl() const { return impl; }
224 
225  friend ::llvm::hash_code hash_value(Value arg);
226 
227 protected:
228  /// A pointer to the internal implementation of the value.
230 };
231 
232 inline raw_ostream &operator<<(raw_ostream &os, Value value) {
233  value.print(os);
234  return os;
235 }
236 
237 //===----------------------------------------------------------------------===//
238 // OpOperand
239 //===----------------------------------------------------------------------===//
240 
241 /// This class represents an operand of an operation. Instances of this class
242 /// contain a reference to a specific `Value`.
243 class OpOperand : public IROperand<OpOperand, Value> {
244 public:
245  /// Provide the use list that is attached to the given value.
247  return value.getImpl();
248  }
249 
250  /// Return which operand this is in the OpOperand list of the Operation.
251  unsigned getOperandNumber();
252 
253  /// Set the current value being used by this operand.
254  void assign(Value value) { set(value); }
255 
256 private:
257  /// Keep the constructor private and accessible to the OperandStorage class
258  /// only to avoid hard-to-debug typo/programming mistakes.
259  friend class OperandStorage;
261 };
262 
263 //===----------------------------------------------------------------------===//
264 // BlockArgument
265 //===----------------------------------------------------------------------===//
266 
267 namespace detail {
268 /// The internal implementation of a BlockArgument.
269 class BlockArgumentImpl : public ValueImpl {
270 public:
271  static bool classof(const ValueImpl *value) {
272  return value->getKind() == ValueImpl::Kind::BlockArgument;
273  }
274 
275 private:
276  BlockArgumentImpl(Type type, Block *owner, int64_t index, Location loc)
277  : ValueImpl(type, Kind::BlockArgument), owner(owner), index(index),
278  loc(loc) {}
279 
280  /// The owner of this argument.
281  Block *owner;
282 
283  /// The position in the argument list.
284  int64_t index;
285 
286  /// The source location of this argument.
287  Location loc;
288 
289  /// Allow access to owner and constructor.
290  friend BlockArgument;
291 };
292 } // namespace detail
293 
294 /// This class represents an argument of a Block.
295 class BlockArgument : public Value {
296 public:
297  using Value::Value;
298 
299  static bool classof(Value value) {
300  return llvm::isa<detail::BlockArgumentImpl>(value.getImpl());
301  }
302 
303  /// Returns the block that owns this argument.
304  Block *getOwner() const { return getImpl()->owner; }
305 
306  /// Returns the number of this argument.
307  unsigned getArgNumber() const { return getImpl()->index; }
308 
309  /// Return the location for this argument.
310  Location getLoc() const { return getImpl()->loc; }
311  void setLoc(Location loc) { getImpl()->loc = loc; }
312 
313 private:
314  /// Allocate a new argument with the given type and owner.
315  static BlockArgument create(Type type, Block *owner, int64_t index,
316  Location loc) {
317  return new detail::BlockArgumentImpl(type, owner, index, loc);
318  }
319 
320  /// Destroy and deallocate this argument.
321  void destroy() { delete getImpl(); }
322 
323  /// Get a raw pointer to the internal implementation.
324  detail::BlockArgumentImpl *getImpl() const {
325  return reinterpret_cast<detail::BlockArgumentImpl *>(impl);
326  }
327 
328  /// Cache the position in the block argument list.
329  void setArgNumber(int64_t index) { getImpl()->index = index; }
330 
331  /// Allow access to `create`, `destroy` and `setArgNumber`.
332  friend Block;
333 
334  /// Allow access to 'getImpl'.
335  friend Value;
336 };
337 
338 //===----------------------------------------------------------------------===//
339 // OpResult
340 //===----------------------------------------------------------------------===//
341 
342 namespace detail {
343 /// This class provides the implementation for an operation result.
344 class alignas(8) OpResultImpl : public ValueImpl {
345 public:
346  using ValueImpl::ValueImpl;
347 
348  static bool classof(const ValueImpl *value) {
349  return value->getKind() != ValueImpl::Kind::BlockArgument;
350  }
351 
352  /// Returns the parent operation of this result.
353  Operation *getOwner() const;
354 
355  /// Returns the result number of this op result.
356  unsigned getResultNumber() const;
357 
358  /// Returns the next operation result at `offset` after this result. This
359  /// method is useful when indexing the result storage of an operation, given
360  /// that there is more than one kind of operation result (with the different
361  /// kinds having different sizes) and that operations are stored in reverse
362  /// order.
363  OpResultImpl *getNextResultAtOffset(intptr_t offset);
364 
365  /// Returns the maximum number of results that can be stored inline.
366  static unsigned getMaxInlineResults() {
367  return static_cast<unsigned>(Kind::OutOfLineOpResult);
368  }
369 };
370 
371 /// This class provides the implementation for an operation result whose index
372 /// can be represented "inline" in the underlying ValueImpl.
373 struct InlineOpResult : public OpResultImpl {
374 public:
375  InlineOpResult(Type type, unsigned resultNo)
376  : OpResultImpl(type, static_cast<ValueImpl::Kind>(resultNo)) {
377  assert(resultNo < getMaxInlineResults());
378  }
379 
380  /// Return the result number of this op result.
381  unsigned getResultNumber() const { return static_cast<unsigned>(getKind()); }
382 
383  static bool classof(const OpResultImpl *value) {
384  return value->getKind() != ValueImpl::Kind::OutOfLineOpResult;
385  }
386 };
387 
388 /// This class provides the implementation for an operation result whose index
389 /// cannot be represented "inline", and thus requires an additional index field.
391 public:
395 
396  static bool classof(const OpResultImpl *value) {
397  return value->getKind() == ValueImpl::Kind::OutOfLineOpResult;
398  }
399 
400  /// Return the result number of this op result.
401  unsigned getResultNumber() const {
403  }
404 
405  /// The trailing result number, or the offset from the beginning of the
406  /// `OutOfLineOpResult` array.
407  uint64_t outOfLineIndex;
408 };
409 
410 /// Return the result number of this op result.
411 inline unsigned OpResultImpl::getResultNumber() const {
412  if (const auto *outOfLineResult = dyn_cast<OutOfLineOpResult>(this))
413  return outOfLineResult->getResultNumber();
414  return cast<InlineOpResult>(this)->getResultNumber();
415 }
416 
417 /// TypedValue is a Value with a statically know type.
418 /// TypedValue can be null/empty
419 template <typename Ty>
420 struct TypedValue : Value {
421  using Value::Value;
422 
423  static bool classof(Value value) { return llvm::isa<Ty>(value.getType()); }
424 
425  /// Return the known Type
426  Ty getType() const { return llvm::cast<Ty>(Value::getType()); }
427  void setType(Ty ty) { Value::setType(ty); }
428 };
429 
430 } // namespace detail
431 
432 /// This is a value defined by a result of an operation.
433 class OpResult : public Value {
434 public:
435  using Value::Value;
436 
437  static bool classof(Value value) {
438  return llvm::isa<detail::OpResultImpl>(value.getImpl());
439  }
440 
441  /// Returns the operation that owns this result.
442  Operation *getOwner() const { return getImpl()->getOwner(); }
443 
444  /// Returns the number of this result.
445  unsigned getResultNumber() const { return getImpl()->getResultNumber(); }
446 
447 private:
448  /// Get a raw pointer to the internal implementation.
449  detail::OpResultImpl *getImpl() const {
450  return reinterpret_cast<detail::OpResultImpl *>(impl);
451  }
452 
453  /// Given a number of operation results, returns the number that need to be
454  /// stored inline.
455  static unsigned getNumInline(unsigned numResults);
456 
457  /// Given a number of operation results, returns the number that need to be
458  /// stored as trailing.
459  static unsigned getNumTrailing(unsigned numResults);
460 
461  /// Allow access to constructor.
462  friend Operation;
463 };
464 
465 /// Make Value hashable.
466 inline ::llvm::hash_code hash_value(Value arg) {
468 }
469 
470 template <typename Ty, typename Value = mlir::Value>
471 /// If Ty is mlir::Type this will select `Value` instead of having a wrapper
472 /// around it. This helps resolve ambiguous conversion issues.
473 using TypedValue = std::conditional_t<std::is_same_v<Ty, mlir::Type>,
475 
476 } // namespace mlir
477 
478 namespace llvm {
479 
480 template <>
481 struct DenseMapInfo<mlir::Value> {
483  void *pointer = llvm::DenseMapInfo<void *>::getEmptyKey();
484  return mlir::Value::getFromOpaquePointer(pointer);
485  }
488  return mlir::Value::getFromOpaquePointer(pointer);
489  }
490  static unsigned getHashValue(mlir::Value val) {
491  return mlir::hash_value(val);
492  }
493  static bool isEqual(mlir::Value lhs, mlir::Value rhs) { return lhs == rhs; }
494 };
495 template <>
496 struct DenseMapInfo<mlir::BlockArgument> : public DenseMapInfo<mlir::Value> {
498  void *pointer = llvm::DenseMapInfo<void *>::getEmptyKey();
499  return reinterpret_cast<mlir::detail::BlockArgumentImpl *>(pointer);
500  }
503  return reinterpret_cast<mlir::detail::BlockArgumentImpl *>(pointer);
504  }
505 };
506 template <>
507 struct DenseMapInfo<mlir::OpResult> : public DenseMapInfo<mlir::Value> {
509  void *pointer = llvm::DenseMapInfo<void *>::getEmptyKey();
510  return reinterpret_cast<mlir::detail::OpResultImpl *>(pointer);
511  }
514  return reinterpret_cast<mlir::detail::OpResultImpl *>(pointer);
515  }
516 };
517 template <typename T>
519  : public DenseMapInfo<mlir::Value> {
521  void *pointer = llvm::DenseMapInfo<void *>::getEmptyKey();
522  return reinterpret_cast<mlir::detail::ValueImpl *>(pointer);
523  }
526  return reinterpret_cast<mlir::detail::ValueImpl *>(pointer);
527  }
528 };
529 
530 /// Allow stealing the low bits of a value.
531 template <>
532 struct PointerLikeTypeTraits<mlir::Value> {
533 public:
534  static inline void *getAsVoidPointer(mlir::Value value) {
535  return const_cast<void *>(value.getAsOpaquePointer());
536  }
537  static inline mlir::Value getFromVoidPointer(void *pointer) {
538  return mlir::Value::getFromOpaquePointer(pointer);
539  }
540  enum {
541  NumLowBitsAvailable =
542  PointerLikeTypeTraits<mlir::detail::ValueImpl *>::NumLowBitsAvailable
543  };
544 };
545 template <>
546 struct PointerLikeTypeTraits<mlir::BlockArgument>
547  : public PointerLikeTypeTraits<mlir::Value> {
548 public:
549  static inline mlir::BlockArgument getFromVoidPointer(void *pointer) {
550  return reinterpret_cast<mlir::detail::BlockArgumentImpl *>(pointer);
551  }
552 };
553 template <>
554 struct PointerLikeTypeTraits<mlir::OpResult>
555  : public PointerLikeTypeTraits<mlir::Value> {
556 public:
557  static inline mlir::OpResult getFromVoidPointer(void *pointer) {
558  return reinterpret_cast<mlir::detail::OpResultImpl *>(pointer);
559  }
560 };
561 template <typename T>
562 struct PointerLikeTypeTraits<mlir::detail::TypedValue<T>>
563  : public PointerLikeTypeTraits<mlir::Value> {
564 public:
565  static inline mlir::detail::TypedValue<T> getFromVoidPointer(void *pointer) {
566  return reinterpret_cast<mlir::detail::ValueImpl *>(pointer);
567  }
568 };
569 
570 /// Add support for llvm style casts. We provide a cast between To and From if
571 /// From is mlir::Value or derives from it.
572 template <typename To, typename From>
573 struct CastInfo<
574  To, From,
575  std::enable_if_t<std::is_same_v<mlir::Value, std::remove_const_t<From>> ||
576  std::is_base_of_v<mlir::Value, From>>>
578  DefaultDoCastIfPossible<To, From, CastInfo<To, From>> {
579  /// Arguments are taken as mlir::Value here and not as `From`, because
580  /// when casting from an intermediate type of the hierarchy to one of its
581  /// children, the val.getKind() inside T::classof will use the static
582  /// getKind() of the parent instead of the non-static ValueImpl::getKind()
583  /// that returns the dynamic type. This means that T::classof would end up
584  /// comparing the static Kind of the children to the static Kind of its
585  /// parent, making it impossible to downcast from the parent to the child.
586  static inline bool isPossible(mlir::Value ty) {
587  /// Return a constant true instead of a dynamic true when casting to self or
588  /// up the hierarchy.
589  if constexpr (std::is_base_of_v<To, From>) {
590  return true;
591  } else {
592  return To::classof(ty);
593  }
594  }
595  static inline To doCast(mlir::Value value) { return To(value.getImpl()); }
596 };
597 
598 } // namespace llvm
599 
600 #endif
union mlir::linalg::@1191::ArityGroupAndKind::Kind kind
This class provides management for the lifetime of the state used when printing the IR.
Definition: AsmState.h:542
This class represents an argument of a Block.
Definition: Value.h:295
Block * getOwner() const
Returns the block that owns this argument.
Definition: Value.h:304
Location getLoc() const
Return the location for this argument.
Definition: Value.h:310
unsigned getArgNumber() const
Returns the number of this argument.
Definition: Value.h:307
static bool classof(Value value)
Definition: Value.h:299
void setLoc(Location loc)
Definition: Value.h:311
Block represents an ordered list of Operations.
Definition: Block.h:33
This class represents a single IR object that contains a use list.
Definition: UseDefLists.h:195
A reference to a value, suitable for use as an operand of an operation.
Definition: UseDefLists.h:127
void set(Value newValue)
Set the current value being used by this operand.
Definition: UseDefLists.h:163
This class defines the main interface for locations in MLIR and acts as a non-nullable wrapper around...
Definition: Location.h:66
MLIRContext is the top-level object for a collection of MLIR operations.
Definition: MLIRContext.h:60
This class represents an operand of an operation.
Definition: Value.h:243
unsigned getOperandNumber()
Return which operand this is in the OpOperand list of the Operation.
Definition: Value.cpp:216
friend class OperandStorage
Keep the constructor private and accessible to the OperandStorage class only to avoid hard-to-debug t...
Definition: Value.h:259
static IRObjectWithUseList< OpOperand > * getUseList(Value value)
Provide the use list that is attached to the given value.
Definition: Value.h:246
void assign(Value value)
Set the current value being used by this operand.
Definition: Value.h:254
Set of flags used to control the behavior of the various IR print methods (e.g.
This is a value defined by a result of an operation.
Definition: Value.h:433
Operation * getOwner() const
Returns the operation that owns this result.
Definition: Value.h:442
static bool classof(Value value)
Definition: Value.h:437
unsigned getResultNumber() const
Returns the number of this result.
Definition: Value.h:445
Operation is the basic unit of execution within MLIR.
Definition: Operation.h:88
This class contains a list of basic blocks and a link to the parent operation it is attached to.
Definition: Region.h:26
Instances of the Type class are uniqued, have an immutable identifier and an optional mutable compone...
Definition: Types.h:74
MLIRContext * getContext() const
Return the MLIRContext in which this type was uniqued.
Definition: Types.cpp:35
An iterator over the users of an IRObject.
Definition: UseDefLists.h:344
This class represents an instance of an SSA value in the MLIR system, representing a computable value...
Definition: Value.h:96
bool use_empty() const
Returns true if this value has no uses.
Definition: Value.h:194
constexpr Value(detail::ValueImpl *impl=nullptr)
Definition: Value.h:98
void dump() const
use_iterator use_end() const
Definition: Value.h:185
void setLoc(Location loc)
Definition: Value.cpp:33
void dropAllUses()
Drop all uses of this object from their respective owners.
Definition: Value.h:144
detail::ValueImpl * getImpl() const
Definition: Value.h:223
static Value getFromOpaquePointer(const void *pointer)
Definition: Value.h:220
detail::ValueImpl * impl
A pointer to the internal implementation of the value.
Definition: Value.h:229
void replaceUsesWithIf(Value newValue, function_ref< bool(OpOperand &)> shouldReplace)
Replace all uses of 'this' value with 'newValue' if the given callback returns true.
Definition: Value.cpp:81
void setType(Type newType)
Mutate the type of this Value to be of the specified type.
Definition: Value.h:116
void print(raw_ostream &os) const
MLIRContext * getContext() const
Utility to get the associated MLIRContext that this value is defined in.
Definition: Value.h:108
Type getType() const
Return the type of this value.
Definition: Value.h:105
void shuffleUseList(ArrayRef< unsigned > indices)
Shuffle the use list order according to the provided indices.
Definition: Value.cpp:96
use_range getUses() const
Returns a range of all uses, which is useful for iterating over all uses.
Definition: Value.h:188
bool operator==(const Value &other) const
Definition: Value.h:101
bool operator!=(const Value &other) const
Definition: Value.h:102
user_iterator user_begin() const
Definition: Value.h:202
void * getAsOpaquePointer() const
Methods for supporting PointerLikeTypeTraits.
Definition: Value.h:219
OpTy getDefiningOp() const
If this value is the result of an operation of type OpTy, return the operation that defines it.
Definition: Value.h:125
user_iterator user_end() const
Definition: Value.h:203
Block * getParentBlock()
Return the Block in which this Value is defined.
Definition: Value.cpp:48
void replaceAllUsesExcept(Value newValue, const SmallPtrSetImpl< Operation * > &exceptions)
Replace all uses of 'this' value with 'newValue', updating anything in the IR that uses 'this' to use...
Definition: Value.cpp:61
void printAsOperand(raw_ostream &os, AsmState &state) const
Print this value as if it were an operand.
ValueUseIterator< OpOperand > use_iterator
This class implements an iterator over the uses of a value.
Definition: Value.h:181
void replaceAllUsesWith(Value newValue)
Replace all uses of 'this' value with the new value, updating anything in the IR that uses 'this' to ...
Definition: Value.h:149
user_range getUsers() const
Definition: Value.h:204
bool hasOneUse() const
Returns true if this value has exactly one use.
Definition: Value.h:191
bool isUsedOutsideOfBlock(Block *block) const
Returns true if the value is used outside of the given block.
Definition: Value.cpp:89
Location getLoc() const
Return the location of this value.
Definition: Value.cpp:26
Operation * getDefiningOp() const
If this value is the result of an operation, return the operation that defines it.
Definition: Value.cpp:20
friend ::llvm::hash_code hash_value(Value arg)
Make Value hashable.
Definition: Value.h:466
Region * getParentRegion()
Return the Region in which this Value is defined.
Definition: Value.cpp:41
use_iterator use_begin() const
Definition: Value.h:184
The internal implementation of a BlockArgument.
Definition: Value.h:269
static bool classof(const ValueImpl *value)
Definition: Value.h:271
This class provides the implementation for an operation result.
Definition: Value.h:344
unsigned getResultNumber() const
Returns the result number of this op result.
Definition: Value.h:411
OpResultImpl * getNextResultAtOffset(intptr_t offset)
Returns the next operation result at offset after this result.
Definition: Value.cpp:134
Operation * getOwner() const
Returns the parent operation of this result.
Definition: Value.cpp:105
static bool classof(const ValueImpl *value)
Definition: Value.h:348
static unsigned getMaxInlineResults()
Returns the maximum number of results that can be stored inline.
Definition: Value.h:366
This class provides the implementation for an operation result whose index cannot be represented "inl...
Definition: Value.h:390
uint64_t outOfLineIndex
The trailing result number, or the offset from the beginning of the OutOfLineOpResult array.
Definition: Value.h:407
static bool classof(const OpResultImpl *value)
Definition: Value.h:396
unsigned getResultNumber() const
Return the result number of this op result.
Definition: Value.h:401
OutOfLineOpResult(Type type, uint64_t outOfLineIndex)
Definition: Value.h:392
The base class for all derived Value classes.
Definition: Value.h:40
Kind
The enumeration represents the various different kinds of values the internal representation may take...
Definition: Value.h:45
@ OutOfLineOpResult
The next kind represents a 'out-of-line' operation result.
@ BlockArgument
The last kind represents a block argument.
ValueImpl(Type type, Kind kind)
Definition: Value.h:72
llvm::PointerIntPair< Type, 3, Kind > typeAndKind
The type of this result and the kind.
Definition: Value.h:83
LLVM_DUMP_METHOD Kind debug_getKind() const
Definition: Value.h:78
void setType(Type type)
Set the type of this value.
Definition: Value.h:66
LLVM_DUMP_METHOD Type debug_getType() const
Expose a few methods explicitly for the debugger to call for visualization.
Definition: Value.h:77
Type getType() const
Return the type of this value.
Definition: Value.h:63
Kind getKind() const
Return the kind of this value.
Definition: Value.h:69
The OpAsmOpInterface, see OpAsmInterface.td for more details.
Definition: CallGraph.h:229
Include the generated interface declarations.
std::conditional_t< std::is_same_v< Ty, mlir::Type >, mlir::Value, detail::TypedValue< Ty > > TypedValue
If Ty is mlir::Type this will select Value instead of having a wrapper around it.
Definition: Value.h:474
inline ::llvm::hash_code hash_value(Value arg)
Make Value hashable.
Definition: Value.h:466
inline ::llvm::hash_code hash_value(AffineExpr arg)
Make AffineExpr hashable.
Definition: AffineExpr.h:247
raw_ostream & operator<<(raw_ostream &os, const AliasResult &result)
Definition: AliasAnalysis.h:78
static bool isPossible(mlir::Value ty)
Arguments are taken as mlir::Value here and not as From, because when casting from an intermediate ty...
Definition: Value.h:586
static mlir::BlockArgument getEmptyKey()
Definition: Value.h:497
static mlir::BlockArgument getTombstoneKey()
Definition: Value.h:501
static mlir::OpResult getEmptyKey()
Definition: Value.h:508
static mlir::OpResult getTombstoneKey()
Definition: Value.h:512
static mlir::Value getEmptyKey()
Definition: Value.h:482
static unsigned getHashValue(mlir::Value val)
Definition: Value.h:490
static bool isEqual(mlir::Value lhs, mlir::Value rhs)
Definition: Value.h:493
static mlir::Value getTombstoneKey()
Definition: Value.h:486
static mlir::detail::TypedValue< T > getEmptyKey()
Definition: Value.h:520
static mlir::detail::TypedValue< T > getTombstoneKey()
Definition: Value.h:524
static mlir::BlockArgument getFromVoidPointer(void *pointer)
Definition: Value.h:549
static mlir::OpResult getFromVoidPointer(void *pointer)
Definition: Value.h:557
static mlir::Value getFromVoidPointer(void *pointer)
Definition: Value.h:537
static void * getAsVoidPointer(mlir::Value value)
Definition: Value.h:534
static mlir::detail::TypedValue< T > getFromVoidPointer(void *pointer)
Definition: Value.h:565
This class provides the implementation for an operation result whose index can be represented "inline...
Definition: Value.h:373
unsigned getResultNumber() const
Return the result number of this op result.
Definition: Value.h:381
static bool classof(const OpResultImpl *value)
Definition: Value.h:383
InlineOpResult(Type type, unsigned resultNo)
Definition: Value.h:375
TypedValue is a Value with a statically know type.
Definition: Value.h:420
static bool classof(Value value)
Definition: Value.h:423
Ty getType() const
Return the known Type.
Definition: Value.h:426
void setType(Ty ty)
Definition: Value.h:427