MLIR  18.0.0git
Attributes.h
Go to the documentation of this file.
1 //===- Attributes.h - MLIR Attribute Classes --------------------*- 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 #ifndef MLIR_IR_ATTRIBUTES_H
10 #define MLIR_IR_ATTRIBUTES_H
11 
13 #include "llvm/Support/PointerLikeTypeTraits.h"
14 
15 namespace mlir {
16 class AsmState;
17 class StringAttr;
18 
19 /// Attributes are known-constant values of operations.
20 ///
21 /// Instances of the Attribute class are references to immortal key-value pairs
22 /// with immutable, uniqued keys owned by MLIRContext. As such, an Attribute is
23 /// a thin wrapper around an underlying storage pointer. Attributes are usually
24 /// passed by value.
25 class Attribute {
26 public:
27  /// Utility class for implementing attributes.
28  template <typename ConcreteType, typename BaseType, typename StorageType,
29  template <typename T> class... Traits>
30  using AttrBase = detail::StorageUserBase<ConcreteType, BaseType, StorageType,
31  detail::AttributeUniquer, Traits...>;
32 
34  using ValueType = void;
36 
37  constexpr Attribute() = default;
38  /* implicit */ Attribute(const ImplType *impl)
39  : impl(const_cast<ImplType *>(impl)) {}
40 
41  Attribute(const Attribute &other) = default;
42  Attribute &operator=(const Attribute &other) = default;
43 
44  bool operator==(Attribute other) const { return impl == other.impl; }
45  bool operator!=(Attribute other) const { return !(*this == other); }
46  explicit operator bool() const { return impl; }
47 
48  bool operator!() const { return impl == nullptr; }
49 
50  /// Casting utility functions. These are deprecated and will be removed,
51  /// please prefer using the `llvm` namespace variants instead.
52  template <typename... Tys>
53  bool isa() const;
54  template <typename... Tys>
55  bool isa_and_nonnull() const;
56  template <typename U>
57  U dyn_cast() const;
58  template <typename U>
59  U dyn_cast_or_null() const;
60  template <typename U>
61  U cast() const;
62 
63  /// Return a unique identifier for the concrete attribute type. This is used
64  /// to support dynamic type casting.
65  TypeID getTypeID() { return impl->getAbstractAttribute().getTypeID(); }
66 
67  /// Return the context this attribute belongs to.
68  MLIRContext *getContext() const;
69 
70  /// Get the dialect this attribute is registered to.
71  Dialect &getDialect() const {
72  return impl->getAbstractAttribute().getDialect();
73  }
74 
75  /// Print the attribute. If `elideType` is set, the attribute is printed
76  /// without a trailing colon type if it has one.
77  void print(raw_ostream &os, bool elideType = false) const;
78  void print(raw_ostream &os, AsmState &state, bool elideType = false) const;
79  void dump() const;
80 
81  /// Get an opaque pointer to the attribute.
82  const void *getAsOpaquePointer() const { return impl; }
83  /// Construct an attribute from the opaque pointer representation.
84  static Attribute getFromOpaquePointer(const void *ptr) {
85  return Attribute(reinterpret_cast<const ImplType *>(ptr));
86  }
87 
88  friend ::llvm::hash_code hash_value(Attribute arg);
89 
90  /// Returns true if `InterfaceT` has been promised by the dialect or
91  /// implemented.
92  template <typename InterfaceT>
95  getDialect(), getTypeID(), InterfaceT::getInterfaceID()) ||
96  mlir::isa<InterfaceT>(*this);
97  }
98 
99  /// Returns true if the type was registered with a particular trait.
100  template <template <typename T> class Trait>
101  bool hasTrait() {
102  return getAbstractAttribute().hasTrait<Trait>();
103  }
104 
105  /// Return the abstract descriptor for this attribute.
107  return impl->getAbstractAttribute();
108  }
109 
110  /// Walk all of the immediately nested sub-attributes and sub-types. This
111  /// method does not recurse into sub elements.
113  function_ref<void(Type)> walkTypesFn) const {
114  getAbstractAttribute().walkImmediateSubElements(*this, walkAttrsFn,
115  walkTypesFn);
116  }
117 
118  /// Replace the immediately nested sub-attributes and sub-types with those
119  /// provided. The order of the provided elements is derived from the order of
120  /// the elements returned by the callbacks of `walkImmediateSubElements`. The
121  /// element at index 0 would replace the very first attribute given by
122  /// `walkImmediateSubElements`. On success, the new instance with the values
123  /// replaced is returned. If replacement fails, nullptr is returned.
125  ArrayRef<Type> replTypes) const {
126  return getAbstractAttribute().replaceImmediateSubElements(*this, replAttrs,
127  replTypes);
128  }
129 
130  /// Walk this attribute and all attibutes/types nested within using the
131  /// provided walk functions. See `AttrTypeWalker` for information on the
132  /// supported walk function types.
133  template <WalkOrder Order = WalkOrder::PostOrder, typename... WalkFns>
134  auto walk(WalkFns &&...walkFns) {
135  AttrTypeWalker walker;
136  (walker.addWalk(std::forward<WalkFns>(walkFns)), ...);
137  return walker.walk<Order>(*this);
138  }
139 
140  /// Recursively replace all of the nested sub-attributes and sub-types using
141  /// the provided map functions. Returns nullptr in the case of failure. See
142  /// `AttrTypeReplacer` for information on the support replacement function
143  /// types.
144  template <typename... ReplacementFns>
145  auto replace(ReplacementFns &&...replacementFns) {
146  AttrTypeReplacer replacer;
147  (replacer.addReplacement(std::forward<ReplacementFns>(replacementFns)),
148  ...);
149  return replacer.replace(*this);
150  }
151 
152  /// Return the internal Attribute implementation.
153  ImplType *getImpl() const { return impl; }
154 
155 protected:
156  ImplType *impl{nullptr};
157 };
158 
159 inline raw_ostream &operator<<(raw_ostream &os, Attribute attr) {
160  attr.print(os);
161  return os;
162 }
163 
164 template <typename... Tys>
165 bool Attribute::isa() const {
166  return llvm::isa<Tys...>(*this);
167 }
168 
169 template <typename... Tys>
171  return llvm::isa_and_present<Tys...>(*this);
172 }
173 
174 template <typename U>
176  return llvm::dyn_cast<U>(*this);
177 }
178 
179 template <typename U>
181  return llvm::dyn_cast_if_present<U>(*this);
182 }
183 
184 template <typename U>
185 U Attribute::cast() const {
186  return llvm::cast<U>(*this);
187 }
188 
189 inline ::llvm::hash_code hash_value(Attribute arg) {
191 }
192 
193 //===----------------------------------------------------------------------===//
194 // NamedAttribute
195 //===----------------------------------------------------------------------===//
196 
197 /// NamedAttribute represents a combination of a name and an Attribute value.
199 public:
200  NamedAttribute(StringAttr name, Attribute value);
201 
202  /// Return the name of the attribute.
203  StringAttr getName() const;
204 
205  /// Return the dialect of the name of this attribute, if the name is prefixed
206  /// by a dialect namespace. For example, `llvm.fast_math` would return the
207  /// LLVM dialect (if it is loaded). Returns nullptr if the dialect isn't
208  /// loaded, or if the name is not prefixed by a dialect namespace.
209  Dialect *getNameDialect() const;
210 
211  /// Return the value of the attribute.
212  Attribute getValue() const { return value; }
213 
214  /// Set the name of this attribute.
215  void setName(StringAttr newName);
216 
217  /// Set the value of this attribute.
218  void setValue(Attribute newValue) {
219  assert(value && "expected valid attribute value");
220  value = newValue;
221  }
222 
223  /// Compare this attribute to the provided attribute, ordering by name.
224  bool operator<(const NamedAttribute &rhs) const;
225  /// Compare this attribute to the provided string, ordering by name.
226  bool operator<(StringRef rhs) const;
227 
228  bool operator==(const NamedAttribute &rhs) const {
229  return name == rhs.name && value == rhs.value;
230  }
231  bool operator!=(const NamedAttribute &rhs) const { return !(*this == rhs); }
232 
233 private:
234  NamedAttribute(Attribute name, Attribute value) : name(name), value(value) {}
235 
236  /// Allow access to internals to enable hashing.
237  friend ::llvm::hash_code hash_value(const NamedAttribute &arg);
238  friend DenseMapInfo<NamedAttribute>;
239 
240  /// The name of the attribute. This is represented as a StringAttr, but
241  /// type-erased to Attribute in the field.
242  Attribute name;
243  /// The value of the attribute.
244  Attribute value;
245 };
246 
247 inline ::llvm::hash_code hash_value(const NamedAttribute &arg) {
248  using AttrPairT = std::pair<Attribute, Attribute>;
249  return DenseMapInfo<AttrPairT>::getHashValue(AttrPairT(arg.name, arg.value));
250 }
251 
252 /// Allow walking and replacing the subelements of a NamedAttribute.
253 template <>
255  template <typename T>
256  static void walk(T param, AttrTypeImmediateSubElementWalker &walker) {
257  walker.walk(param.getName());
258  walker.walk(param.getValue());
259  }
260  template <typename T>
261  static T replace(T param, AttrSubElementReplacements &attrRepls,
262  TypeSubElementReplacements &typeRepls) {
263  ArrayRef<Attribute> paramRepls = attrRepls.take_front(2);
264  return T(cast<decltype(param.getName())>(paramRepls[0]), paramRepls[1]);
265  }
266 };
267 
268 //===----------------------------------------------------------------------===//
269 // AttributeTraitBase
270 //===----------------------------------------------------------------------===//
271 
272 namespace AttributeTrait {
273 /// This class represents the base of an attribute trait.
274 template <typename ConcreteType, template <typename> class TraitType>
276 } // namespace AttributeTrait
277 
278 //===----------------------------------------------------------------------===//
279 // AttributeInterface
280 //===----------------------------------------------------------------------===//
281 
282 /// This class represents the base of an attribute interface. See the definition
283 /// of `detail::Interface` for requirements on the `Traits` type.
284 template <typename ConcreteType, typename Traits>
286  : public detail::Interface<ConcreteType, Attribute, Traits, Attribute,
287  AttributeTrait::TraitBase> {
288 public:
290  using InterfaceBase = detail::Interface<ConcreteType, Attribute, Traits,
293 
294 protected:
295  /// Returns the impl interface instance for the given type.
297 #ifndef NDEBUG
298  // Check that the current interface isn't an unresolved promise for the
299  // given attribute.
301  attr.getDialect(), attr.getTypeID(), ConcreteType::getInterfaceID(),
302  llvm::getTypeName<ConcreteType>());
303 #endif
304 
305  return attr.getAbstractAttribute().getInterface<ConcreteType>();
306  }
307 
308  /// Allow access to 'getInterfaceFor'.
310 };
311 
312 //===----------------------------------------------------------------------===//
313 // Core AttributeTrait
314 //===----------------------------------------------------------------------===//
315 
316 /// This trait is used to determine if an attribute is mutable or not. It is
317 /// attached on an attribute if the corresponding ImplType defines a `mutate`
318 /// function with proper signature.
319 namespace AttributeTrait {
320 template <typename ConcreteType>
322 } // namespace AttributeTrait
323 
324 } // namespace mlir.
325 
326 namespace llvm {
327 
328 // Attribute hash just like pointers.
329 template <>
330 struct DenseMapInfo<mlir::Attribute> {
332  auto *pointer = llvm::DenseMapInfo<void *>::getEmptyKey();
333  return mlir::Attribute(static_cast<mlir::Attribute::ImplType *>(pointer));
334  }
337  return mlir::Attribute(static_cast<mlir::Attribute::ImplType *>(pointer));
338  }
339  static unsigned getHashValue(mlir::Attribute val) {
340  return mlir::hash_value(val);
341  }
342  static bool isEqual(mlir::Attribute LHS, mlir::Attribute RHS) {
343  return LHS == RHS;
344  }
345 };
346 template <typename T>
348  T, std::enable_if_t<std::is_base_of<mlir::Attribute, T>::value &&
349  !mlir::detail::IsInterface<T>::value>>
350  : public DenseMapInfo<mlir::Attribute> {
351  static T getEmptyKey() {
352  const void *pointer = llvm::DenseMapInfo<const void *>::getEmptyKey();
353  return T::getFromOpaquePointer(pointer);
354  }
355  static T getTombstoneKey() {
357  return T::getFromOpaquePointer(pointer);
358  }
359 };
360 
361 /// Allow LLVM to steal the low bits of Attributes.
362 template <>
363 struct PointerLikeTypeTraits<mlir::Attribute> {
364  static inline void *getAsVoidPointer(mlir::Attribute attr) {
365  return const_cast<void *>(attr.getAsOpaquePointer());
366  }
367  static inline mlir::Attribute getFromVoidPointer(void *ptr) {
369  }
370  static constexpr int NumLowBitsAvailable = llvm::PointerLikeTypeTraits<
371  mlir::AttributeStorage *>::NumLowBitsAvailable;
372 };
373 
374 template <>
375 struct DenseMapInfo<mlir::NamedAttribute> {
378  return mlir::NamedAttribute(emptyAttr, emptyAttr);
379  }
382  return mlir::NamedAttribute(tombAttr, tombAttr);
383  }
384  static unsigned getHashValue(mlir::NamedAttribute val) {
385  return mlir::hash_value(val);
386  }
388  return lhs == rhs;
389  }
390 };
391 
392 /// Add support for llvm style casts. We provide a cast between To and From if
393 /// From is mlir::Attribute or derives from it.
394 template <typename To, typename From>
395 struct CastInfo<To, From,
396  std::enable_if_t<std::is_same_v<mlir::Attribute,
397  std::remove_const_t<From>> ||
398  std::is_base_of_v<mlir::Attribute, From>>>
400  DefaultDoCastIfPossible<To, From, CastInfo<To, From>> {
401  /// Arguments are taken as mlir::Attribute here and not as `From`, because
402  /// when casting from an intermediate type of the hierarchy to one of its
403  /// children, the val.getTypeID() inside T::classof will use the static
404  /// getTypeID of the parent instead of the non-static Type::getTypeID that
405  /// returns the dynamic ID. This means that T::classof would end up comparing
406  /// the static TypeID of the children to the static TypeID of its parent,
407  /// making it impossible to downcast from the parent to the child.
408  static inline bool isPossible(mlir::Attribute ty) {
409  /// Return a constant true instead of a dynamic true when casting to self or
410  /// up the hierarchy.
411  if constexpr (std::is_base_of_v<To, From>) {
412  return true;
413  } else {
414  return To::classof(ty);
415  }
416  }
417  static inline To doCast(mlir::Attribute attr) { return To(attr.getImpl()); }
418 };
419 
420 } // namespace llvm
421 
422 #endif
This class contains all of the static information common to all instances of a registered Attribute.
T::Concept * getInterface() const
Returns an instance of the concept object for the given interface if it was registered to this attrib...
bool hasTrait() const
Returns true if the attribute has a particular trait.
void walkImmediateSubElements(Attribute attr, function_ref< void(Attribute)> walkAttrsFn, function_ref< void(Type)> walkTypesFn) const
Walk the immediate sub-elements of this attribute.
Definition: Attributes.cpp:19
Attribute replaceImmediateSubElements(Attribute attr, ArrayRef< Attribute > replAttrs, ArrayRef< Type > replTypes) const
Replace the immediate sub-elements of this attribute.
Definition: Attributes.cpp:26
This class provides management for the lifetime of the state used when printing the IR.
Definition: AsmState.h:533
void walk(Attribute element)
Walk an attribute.
Attribute replace(Attribute attr)
Replace the given attribute/type, and recursively replace any sub elements.
void addReplacement(ReplaceFn< Attribute > fn)
Register a replacement function for mapping a given attribute or type.
This class is used by AttrTypeSubElementHandler instances to process sub element replacements.
ArrayRef< T > take_front(unsigned n)
Take the first N replacements as an ArrayRef, dropping them from this replacement list.
void addWalk(WalkFn< Attribute > &&fn)
Register a walk function for a given attribute or type.
WalkResult walk(T element)
Walk the given attribute/type, and recursively walk any sub elements.
This class represents the base of an attribute interface.
Definition: Attributes.h:287
friend InterfaceBase
Allow access to 'getInterfaceFor'.
Definition: Attributes.h:309
static InterfaceBase::Concept * getInterfaceFor(Attribute attr)
Returns the impl interface instance for the given type.
Definition: Attributes.h:296
Base storage class appearing in an attribute.
Attributes are known-constant values of operations.
Definition: Attributes.h:25
U dyn_cast_or_null() const
Definition: Attributes.h:180
Dialect & getDialect() const
Get the dialect this attribute is registered to.
Definition: Attributes.h:71
U dyn_cast() const
Definition: Attributes.h:175
auto walk(WalkFns &&...walkFns)
Walk this attribute and all attibutes/types nested within using the provided walk functions.
Definition: Attributes.h:134
ImplType * impl
Definition: Attributes.h:156
bool operator!() const
Definition: Attributes.h:48
Attribute(const ImplType *impl)
Definition: Attributes.h:38
constexpr Attribute()=default
U cast() const
Definition: Attributes.h:185
const AbstractTy & getAbstractAttribute() const
Return the abstract descriptor for this attribute.
Definition: Attributes.h:106
bool operator==(Attribute other) const
Definition: Attributes.h:44
void print(raw_ostream &os, bool elideType=false) const
Print the attribute.
auto replace(ReplacementFns &&...replacementFns)
Recursively replace all of the nested sub-attributes and sub-types using the provided map functions.
Definition: Attributes.h:145
void walkImmediateSubElements(function_ref< void(Attribute)> walkAttrsFn, function_ref< void(Type)> walkTypesFn) const
Walk all of the immediately nested sub-attributes and sub-types.
Definition: Attributes.h:112
void dump() const
bool operator!=(Attribute other) const
Definition: Attributes.h:45
bool isa() const
Casting utility functions.
Definition: Attributes.h:165
MLIRContext * getContext() const
Return the context this attribute belongs to.
Definition: Attributes.cpp:37
auto replaceImmediateSubElements(ArrayRef< Attribute > replAttrs, ArrayRef< Type > replTypes) const
Replace the immediately nested sub-attributes and sub-types with those provided.
Definition: Attributes.h:124
Attribute & operator=(const Attribute &other)=default
friend ::llvm::hash_code hash_value(Attribute arg)
Definition: Attributes.h:189
bool hasTrait()
Returns true if the type was registered with a particular trait.
Definition: Attributes.h:101
const void * getAsOpaquePointer() const
Get an opaque pointer to the attribute.
Definition: Attributes.h:82
Attribute(const Attribute &other)=default
bool hasPromiseOrImplementsInterface()
Returns true if InterfaceT has been promised by the dialect or implemented.
Definition: Attributes.h:93
bool isa_and_nonnull() const
Definition: Attributes.h:170
ImplType * getImpl() const
Return the internal Attribute implementation.
Definition: Attributes.h:153
TypeID getTypeID()
Return a unique identifier for the concrete attribute type.
Definition: Attributes.h:65
static Attribute getFromOpaquePointer(const void *ptr)
Construct an attribute from the opaque pointer representation.
Definition: Attributes.h:84
Dialects are groups of MLIR operations, types and attributes, as well as behavior associated with the...
Definition: Dialect.h:41
MLIRContext is the top-level object for a collection of MLIR operations.
Definition: MLIRContext.h:60
NamedAttribute represents a combination of a name and an Attribute value.
Definition: Attributes.h:198
StringAttr getName() const
Return the name of the attribute.
Definition: Attributes.cpp:49
void setName(StringAttr newName)
Set the name of this attribute.
Definition: Attributes.cpp:57
bool operator==(const NamedAttribute &rhs) const
Definition: Attributes.h:228
bool operator<(const NamedAttribute &rhs) const
Compare this attribute to the provided attribute, ordering by name.
Definition: Attributes.cpp:62
NamedAttribute(StringAttr name, Attribute value)
Definition: Attributes.cpp:43
Dialect * getNameDialect() const
Return the dialect of the name of this attribute, if the name is prefixed by a dialect namespace.
Definition: Attributes.cpp:53
friend ::llvm::hash_code hash_value(const NamedAttribute &arg)
Allow access to internals to enable hashing.
Definition: Attributes.h:247
void setValue(Attribute newValue)
Set the value of this attribute.
Definition: Attributes.h:218
Attribute getValue() const
Return the value of the attribute.
Definition: Attributes.h:212
bool operator!=(const NamedAttribute &rhs) const
Definition: Attributes.h:231
This class provides an efficient unique identifier for a specific C++ type.
Definition: TypeID.h:104
Instances of the Type class are uniqued, have an immutable identifier and an optional mutable compone...
Definition: Types.h:74
This class represents an abstract interface.
Interface< ConcreteType, Attribute, Traits, Attribute, AttributeTrait::TraitBase > InterfaceBase
Utility class for implementing users of storage classes uniqued by a StorageUniquer.
Helper class for implementing traits for storage classes.
Include the generated interface declarations.
Definition: CallGraph.h:229
bool hasPromisedInterface(Dialect &dialect, TypeID interfaceRequestorID, TypeID interfaceID)
Checks if a promise has been made for the interface/requestor pair.
Definition: Dialect.cpp:166
void handleUseOfUndefinedPromisedInterface(Dialect &dialect, TypeID interfaceRequestorID, TypeID interfaceID, StringRef interfaceName)
Checks if the given interface, which is attempting to be used, is a promised interface of this dialec...
Definition: Dialect.cpp:153
Include the generated interface declarations.
WalkOrder
Traversal order for region, block and operation walk utilities.
Definition: Visitors.h:63
inline ::llvm::hash_code hash_value(AffineExpr arg)
Make AffineExpr hashable.
Definition: AffineExpr.h:246
raw_ostream & operator<<(raw_ostream &os, const AliasResult &result)
Definition: AliasAnalysis.h:78
static bool isPossible(mlir::Attribute ty)
Arguments are taken as mlir::Attribute here and not as From, because when casting from an intermediat...
Definition: Attributes.h:408
static bool isEqual(mlir::Attribute LHS, mlir::Attribute RHS)
Definition: Attributes.h:342
static unsigned getHashValue(mlir::Attribute val)
Definition: Attributes.h:339
static mlir::Attribute getEmptyKey()
Definition: Attributes.h:331
static mlir::Attribute getTombstoneKey()
Definition: Attributes.h:335
static unsigned getHashValue(mlir::NamedAttribute val)
Definition: Attributes.h:384
static mlir::NamedAttribute getEmptyKey()
Definition: Attributes.h:376
static mlir::NamedAttribute getTombstoneKey()
Definition: Attributes.h:380
static bool isEqual(mlir::NamedAttribute lhs, mlir::NamedAttribute rhs)
Definition: Attributes.h:387
static mlir::Attribute getFromVoidPointer(void *ptr)
Definition: Attributes.h:367
static void * getAsVoidPointer(mlir::Attribute attr)
Definition: Attributes.h:364
static void walk(T param, AttrTypeImmediateSubElementWalker &walker)
Definition: Attributes.h:256
static T replace(T param, AttrSubElementReplacements &attrRepls, TypeSubElementReplacements &typeRepls)
Definition: Attributes.h:261
This class provides support for interacting with the SubElementInterfaces for different types of para...
This trait is used to determine if a storage user, like Type, is mutable or not.