1150 lines
46 KiB
C++
1150 lines
46 KiB
C++
/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
|
|
|* *|
|
|
|* AttrDef Declarations *|
|
|
|* *|
|
|
|* Automatically generated file, do not edit! *|
|
|
|* *|
|
|
\*===----------------------------------------------------------------------===*/
|
|
|
|
#ifdef GET_ATTRDEF_CLASSES
|
|
#undef GET_ATTRDEF_CLASSES
|
|
|
|
|
|
namespace mlir {
|
|
class AsmParser;
|
|
class AsmPrinter;
|
|
} // namespace mlir
|
|
namespace mlir {
|
|
|
|
/// An Attribute containing an AffineMap object
|
|
/// Syntax:
|
|
///
|
|
/// ```
|
|
/// affine-map-attribute ::= `affine_map` `<` affine-map `>`
|
|
/// ```
|
|
///
|
|
/// Examples:
|
|
///
|
|
/// ```mlir
|
|
/// affine_map<(d0) -> (d0)>
|
|
/// affine_map<(d0, d1, d2) -> (d0, d1)>
|
|
/// ```
|
|
class AffineMapAttr;
|
|
/// A collection of other Attribute values
|
|
/// Syntax:
|
|
///
|
|
/// ```
|
|
/// array-attribute ::= `[` (attribute-value (`,` attribute-value)*)? `]`
|
|
/// ```
|
|
///
|
|
/// An array attribute is an attribute that represents a collection of attribute
|
|
/// values.
|
|
///
|
|
/// Examples:
|
|
///
|
|
/// ```mlir
|
|
/// []
|
|
/// [10, i32]
|
|
/// [affine_map<(d0, d1, d2) -> (d0, d1)>, i32, "string attribute"]
|
|
/// ```
|
|
class ArrayAttr;
|
|
/// A dense array of integer or floating point elements.
|
|
/// A dense array attribute is an attribute that represents a dense array of
|
|
/// primitive element types. Contrary to DenseTypedElementsAttr this is a
|
|
/// flat unidimensional array which does not have a storage optimization for
|
|
/// splat. This allows to expose the raw array through a C++ API as
|
|
/// `ArrayRef<T>` for compatible types. The element type must be bool or an
|
|
/// integer or float whose bitwidth is a multiple of 8. Bool elements are stored
|
|
/// as bytes.
|
|
///
|
|
/// This is the base class attribute. Access to C++ types is intended to be
|
|
/// managed through the subclasses `DenseI8ArrayAttr`, `DenseI16ArrayAttr`,
|
|
/// `DenseI32ArrayAttr`, `DenseI64ArrayAttr`, `DenseF32ArrayAttr`,
|
|
/// and `DenseF64ArrayAttr`.
|
|
///
|
|
/// Syntax:
|
|
///
|
|
/// ```
|
|
/// dense-array-attribute ::= `array` `<` (integer-type | float-type)
|
|
/// (`:` tensor-literal)? `>`
|
|
/// ```
|
|
/// Examples:
|
|
///
|
|
/// ```mlir
|
|
/// array<i8>
|
|
/// array<i32: 10, 42>
|
|
/// array<f64: 42., 12.>
|
|
/// ```
|
|
///
|
|
/// When a specific subclass is used as argument of an operation, the
|
|
/// declarative assembly will omit the type and print directly:
|
|
///
|
|
/// ```mlir
|
|
/// [1, 2, 3]
|
|
/// ```
|
|
class DenseArrayAttr;
|
|
/// An Attribute containing a dense multi-dimensional array of values
|
|
/// A dense elements attribute stores one or multiple elements of the same type.
|
|
/// The term "dense" refers to the fact that elements are not stored as
|
|
/// individual MLIR attributes, but in a raw buffer. The attribute provides a
|
|
/// covenience API to access elements in the form of MLIR attributes, but users
|
|
/// should avoid that API in performance-critical code and utilize APIs that
|
|
/// operate on raw bytes instead.
|
|
///
|
|
/// The number of elements is determined by the `type` shaped type. (Unranked
|
|
/// shaped types are not supported.) The element type of the shaped type must
|
|
/// implement the `DenseElementType` interface. This type interface defines the
|
|
/// bitwidth of an element and provides a serializer/deserializer to/from MLIR
|
|
/// attributes.
|
|
///
|
|
/// Storage format: Given an element bitwidth "w", element "i" starts at byte
|
|
/// offset "i * ceildiv(w, 8)". In other words, each element starts at a full
|
|
/// byte offset.
|
|
///
|
|
/// Examples:
|
|
///
|
|
/// ```
|
|
/// // Literal-first syntax: A splat tensor of integer values.
|
|
/// dense<10> : tensor<2xi32>
|
|
///
|
|
/// // Literal-first syntax: A tensor of 2 float32 elements.
|
|
/// dense<[10.0, 11.0]> : tensor<2xf32>
|
|
///
|
|
/// // Type-first syntax: A splat tensor of integer values.
|
|
/// dense<tensor<2xi32> : 10 : i32>
|
|
///
|
|
/// // Type-first syntax: A tensor of 2 float32 elements.
|
|
/// dense<tensor<2xf32> : [10.0, 11.0]>
|
|
/// ```
|
|
///
|
|
/// Note: The literal-first syntax is supported only for complex, float, index,
|
|
/// int element types. The parser/print have special casing for these types.
|
|
/// Dense element attributes with other element types must use the type-first
|
|
/// syntax.
|
|
class DenseTypedElementsAttr;
|
|
/// An Attribute containing a dense multi-dimensional array of strings
|
|
/// Syntax:
|
|
///
|
|
/// ```
|
|
/// dense-string-elements-attribute ::= `dense` `<` attribute-value `>` `:`
|
|
/// ( tensor-type | vector-type )
|
|
/// ```
|
|
///
|
|
/// A dense string elements attribute is an elements attribute containing a
|
|
/// densely packed vector or tensor of string values. There are no restrictions
|
|
/// placed on the element type of this attribute, enabling the use of dialect
|
|
/// specific string types.
|
|
///
|
|
/// Examples:
|
|
///
|
|
/// ```
|
|
/// // A splat tensor of strings.
|
|
/// dense<"example"> : tensor<2x!foo.string>
|
|
/// // A tensor of 2 string elements.
|
|
/// dense<["example1", "example2"]> : tensor<2x!foo.string>
|
|
/// ```
|
|
class DenseStringElementsAttr;
|
|
/// An Attribute containing a dense multi-dimensional array backed by a resource
|
|
/// Syntax:
|
|
///
|
|
/// ```
|
|
/// dense-resource-elements-attribute ::=
|
|
/// `dense_resource` `<` resource-handle `>` `:` shaped-type
|
|
/// ```
|
|
///
|
|
/// A dense resource elements attribute is an elements attribute backed by a
|
|
/// handle to a builtin dialect resource containing a densely packed array of
|
|
/// values. This class provides the low-level attribute, which should only be
|
|
/// interacted with in very generic terms, actual access to the underlying
|
|
/// resource data is intended to be managed through one of the subclasses, such
|
|
/// as; `DenseBoolResourceElementsAttr`, `DenseUI64ResourceElementsAttr`,
|
|
/// `DenseI32ResourceElementsAttr`, `DenseF32ResourceElementsAttr`,
|
|
/// `DenseF64ResourceElementsAttr`, etc.
|
|
///
|
|
/// Examples:
|
|
///
|
|
/// ```mlir
|
|
/// "example.user_op"() {attr = dense_resource<blob1> : tensor<3xi64> } : () -> ()
|
|
///
|
|
/// {-#
|
|
/// dialect_resources: {
|
|
/// builtin: {
|
|
/// blob1: "0x08000000010000000000000002000000000000000300000000000000"
|
|
/// }
|
|
/// }
|
|
/// #-}
|
|
/// ```
|
|
class DenseResourceElementsAttr;
|
|
/// An dictionary of named Attribute values
|
|
/// Syntax:
|
|
///
|
|
/// ```
|
|
/// dictionary-attribute ::= `{` (attribute-entry (`,` attribute-entry)*)? `}`
|
|
/// ```
|
|
///
|
|
/// A dictionary attribute is an attribute that represents a sorted collection of
|
|
/// named attribute values. The elements are sorted by name, and each name must be
|
|
/// unique within the collection.
|
|
///
|
|
/// Examples:
|
|
///
|
|
/// ```mlir
|
|
/// {}
|
|
/// {attr_name = "string attribute"}
|
|
/// {int_attr = 10, "string attr name" = "string attribute"}
|
|
/// ```
|
|
class DictionaryAttr;
|
|
/// An Attribute containing a floating-point value
|
|
/// Syntax:
|
|
///
|
|
/// ```
|
|
/// float-attribute ::= (float-literal (`:` float-type)?)
|
|
/// | (hexadecimal-literal `:` float-type)
|
|
/// ```
|
|
///
|
|
/// A float attribute is a literal attribute that represents a floating point
|
|
/// value of the specified [float type](#floating-point-types). It can be
|
|
/// represented in the hexadecimal form where the hexadecimal value is
|
|
/// interpreted as bits of the underlying binary representation. This form is
|
|
/// useful for representing infinity and NaN floating point values. To avoid
|
|
/// confusion with integer attributes, hexadecimal literals _must_ be followed
|
|
/// by a float type to define a float attribute.
|
|
///
|
|
/// Examples:
|
|
///
|
|
/// ```
|
|
/// 42.0 // float attribute defaults to f64 type
|
|
/// 42.0 : f32 // float attribute of f32 type
|
|
/// 0x7C00 : f16 // positive infinity
|
|
/// 0x7CFF : f16 // NaN (one of possible values)
|
|
/// 42 : f32 // Error: expected integer type
|
|
/// ```
|
|
class FloatAttr;
|
|
/// An Attribute containing a integer value
|
|
/// Syntax:
|
|
///
|
|
/// ```
|
|
/// integer-attribute ::= (integer-literal ( `:` (index-type | integer-type) )?)
|
|
/// | `true` | `false`
|
|
/// ```
|
|
///
|
|
/// An integer attribute is a literal attribute that represents an integral
|
|
/// value of the specified integer or index type. `i1` integer attributes are
|
|
/// treated as `boolean` attributes, and use a unique assembly format of either
|
|
/// `true` or `false` depending on the value. The default type for non-boolean
|
|
/// integer attributes, if a type is not specified, is signless 64-bit integer.
|
|
///
|
|
/// Examples:
|
|
///
|
|
/// ```mlir
|
|
/// 10 : i32
|
|
/// 10 // : i64 is implied here.
|
|
/// true // A bool, i.e. i1, value.
|
|
/// false // A bool, i.e. i1, value.
|
|
/// ```
|
|
class IntegerAttr;
|
|
/// An Attribute containing an IntegerSet object
|
|
/// Syntax:
|
|
///
|
|
/// ```
|
|
/// integer-set-attribute ::= `affine_set` `<` integer-set `>`
|
|
/// ```
|
|
///
|
|
/// Examples:
|
|
///
|
|
/// ```mlir
|
|
/// affine_set<(d0) : (d0 - 2 >= 0)>
|
|
/// ```
|
|
class IntegerSetAttr;
|
|
/// An opaque representation of another Attribute
|
|
/// Syntax:
|
|
///
|
|
/// ```
|
|
/// opaque-attribute ::= dialect-namespace `<` attr-data `>`
|
|
/// ```
|
|
///
|
|
/// Opaque attributes represent attributes of non-registered dialects. These are
|
|
/// attribute represented in their raw string form, and can only usefully be
|
|
/// tested for attribute equality.
|
|
///
|
|
/// Examples:
|
|
///
|
|
/// ```mlir
|
|
/// #dialect<"opaque attribute data">
|
|
/// ```
|
|
class OpaqueAttr;
|
|
/// An opaque representation of a multi-dimensional array
|
|
/// Syntax:
|
|
///
|
|
/// ```
|
|
/// sparse-elements-attribute ::= `sparse` `<` attribute-value `,`
|
|
/// attribute-value `>` `:`
|
|
/// ( tensor-type | vector-type )
|
|
/// ```
|
|
///
|
|
/// A sparse elements attribute is an elements attribute that represents a
|
|
/// sparse vector or tensor object. This is where very few of the elements are
|
|
/// non-zero.
|
|
///
|
|
/// The attribute uses COO (coordinate list) encoding to represent the sparse
|
|
/// elements of the elements attribute. The indices are stored via a 2-D tensor
|
|
/// of 64-bit integer elements with shape [N, ndims], which specifies the
|
|
/// indices of the elements in the sparse tensor that contains non-zero values.
|
|
/// The element values are stored via a 1-D tensor with shape [N], that supplies
|
|
/// the corresponding values for the indices.
|
|
///
|
|
/// Example:
|
|
///
|
|
/// ```mlir
|
|
/// sparse<[[0, 0], [1, 2]], [1, 5]> : tensor<3x4xi32>
|
|
///
|
|
/// // This represents the following tensor:
|
|
/// /// [[1, 0, 0, 0],
|
|
/// /// [0, 0, 5, 0],
|
|
/// /// [0, 0, 0, 0]]
|
|
/// ```
|
|
class SparseElementsAttr;
|
|
/// An Attribute representing a strided layout of a shaped type
|
|
/// Syntax:
|
|
///
|
|
/// ```
|
|
/// strided-layout-attribute ::= `strided` `<` `[` stride-list `]`
|
|
/// (`,` `offset` `:` dimension)? `>`
|
|
/// stride-list ::= /*empty*/
|
|
/// | dimension (`,` dimension)*
|
|
/// dimension ::= decimal-literal | `?`
|
|
/// ```
|
|
///
|
|
/// A strided layout attribute captures layout information of the memref type in
|
|
/// the canonical form. Specifically, it contains a list of _strides_, one for
|
|
/// each dimension. A stride is the number of elements in the linear storage
|
|
/// one must step over to reflect an increment in the given dimension. For
|
|
/// example, a `MxN` row-major contiguous shaped type would have the strides
|
|
/// `[N, 1]`. The layout attribute also contains the _offset_ from the base
|
|
/// pointer of the shaped type to the first effectively accessed element,
|
|
/// expressed in terms of the number of contiguously stored elements.
|
|
///
|
|
/// Strides must be positive and the offset must be non-negative. Both the
|
|
/// strides and the offset may be _dynamic_, i.e. their value may not be known
|
|
/// at compile time. This is expressed as a `?` in the assembly syntax and as
|
|
/// `ShapedType::kDynamic` in the code. Stride and offset values
|
|
/// must satisfy the constraints above at runtime, the behavior is undefined
|
|
/// otherwise.
|
|
///
|
|
/// See [Dialects/Builtin.md#memreftype](MemRef type) for more information.
|
|
class StridedLayoutAttr;
|
|
/// An Attribute containing a string
|
|
/// Syntax:
|
|
///
|
|
/// ```
|
|
/// string-attribute ::= string-literal (`:` type)?
|
|
/// ```
|
|
///
|
|
/// A string attribute is an attribute that represents a string literal value.
|
|
///
|
|
/// Examples:
|
|
///
|
|
/// ```mlir
|
|
/// "An important string"
|
|
/// "string with a type" : !dialect.string
|
|
/// ```
|
|
class StringAttr;
|
|
/// An Attribute containing a symbolic reference to an Operation
|
|
/// Syntax:
|
|
///
|
|
/// ```
|
|
/// symbol-ref-attribute ::= symbol-ref-id (`::` symbol-ref-id)*
|
|
/// ```
|
|
///
|
|
/// A symbol reference attribute is a literal attribute that represents a named
|
|
/// reference to an operation that is nested within an operation with the
|
|
/// `OpTrait::SymbolTable` trait. As such, this reference is given meaning by
|
|
/// the nearest parent operation containing the `OpTrait::SymbolTable` trait. It
|
|
/// may optionally contain a set of nested references that further resolve to a
|
|
/// symbol nested within a different symbol table.
|
|
///
|
|
/// **Rationale:** Identifying accesses to global data is critical to
|
|
/// enabling efficient multi-threaded compilation. Restricting global
|
|
/// data access to occur through symbols and limiting the places that can
|
|
/// legally hold a symbol reference simplifies reasoning about these data
|
|
/// accesses.
|
|
///
|
|
/// See [`Symbols And SymbolTables`](../SymbolsAndSymbolTables.md) for more
|
|
/// information.
|
|
///
|
|
/// Examples:
|
|
///
|
|
/// ```mlir
|
|
/// @flat_reference
|
|
/// @parent_reference::@nested_reference
|
|
/// ```
|
|
class SymbolRefAttr;
|
|
/// An Attribute containing a Type
|
|
/// Syntax:
|
|
///
|
|
/// ```
|
|
/// type-attribute ::= type
|
|
/// ```
|
|
///
|
|
/// A type attribute is an attribute that represents a
|
|
/// [type object](#type-system).
|
|
///
|
|
/// Examples:
|
|
///
|
|
/// ```mlir
|
|
/// i32
|
|
/// !dialect.type
|
|
/// ```
|
|
class TypeAttr;
|
|
/// An Attribute value of `unit` type
|
|
/// Syntax:
|
|
///
|
|
/// ```
|
|
/// unit-attribute ::= `unit`
|
|
/// ```
|
|
///
|
|
/// A unit attribute is an attribute that represents a value of `unit` type. The
|
|
/// `unit` type allows only one value forming a singleton set. This attribute
|
|
/// value is used to represent attributes that only have meaning from their
|
|
/// existence.
|
|
///
|
|
/// One example of such an attribute could be the `swift.self` attribute. This
|
|
/// attribute indicates that a function parameter is the self/context parameter.
|
|
/// It could be represented as a [boolean attribute](#boolean-attribute)(true or
|
|
/// false), but a value of false doesn't really bring any value. The parameter
|
|
/// either is the self/context or it isn't.
|
|
///
|
|
///
|
|
/// Examples:
|
|
///
|
|
/// ```mlir
|
|
/// // A unit attribute defined with the `unit` value specifier.
|
|
/// func.func @verbose_form() attributes {dialectName.unitAttr = unit}
|
|
///
|
|
/// // A unit attribute in an attribute dictionary can also be defined without
|
|
/// // the value specifier.
|
|
/// func.func @simple_form() attributes {dialectName.unitAttr}
|
|
/// ```
|
|
class UnitAttr;
|
|
namespace detail {
|
|
|
|
struct AffineMapAttrStorage;
|
|
|
|
} // namespace detail
|
|
class AffineMapAttr : public ::mlir::Attribute::AttrBase<AffineMapAttr, ::mlir::Attribute, detail::AffineMapAttrStorage, ::mlir::MemRefLayoutAttrInterface::Trait, ::mlir::OpAsmAttrInterface::Trait> {
|
|
public:
|
|
using Base::Base;
|
|
using ValueType = AffineMap;
|
|
AffineMap getAffineMap() const { return getValue(); }
|
|
|
|
//===------------------------------------------------------------------===//
|
|
// OpAsmAttrInterface Methods
|
|
//===------------------------------------------------------------------===//
|
|
|
|
/// Get a name to use when generating an alias for this attribute.
|
|
::mlir::OpAsmAliasResult getAlias(::llvm::raw_ostream &os) const {
|
|
os << "map";
|
|
return ::mlir::OpAsmAliasResult::OverridableAlias;
|
|
}
|
|
static constexpr ::llvm::StringLiteral name = "builtin.affine_map";
|
|
static constexpr ::llvm::StringLiteral dialectName = "builtin";
|
|
static AffineMapAttr get(AffineMap value);
|
|
AffineMap getValue() const;
|
|
};
|
|
namespace detail {
|
|
|
|
struct ArrayAttrStorage;
|
|
|
|
} // namespace detail
|
|
class ArrayAttr : public ::mlir::Attribute::AttrBase<ArrayAttr, ::mlir::Attribute, detail::ArrayAttrStorage> {
|
|
public:
|
|
using Base::Base;
|
|
using ValueType = ArrayRef<Attribute>;
|
|
|
|
/// Return the element at the given index.
|
|
Attribute operator[](unsigned idx) const {
|
|
assert(idx < size() && "index out of bounds");
|
|
return getValue()[idx];
|
|
}
|
|
|
|
/// Support range iteration.
|
|
using iterator = llvm::ArrayRef<Attribute>::iterator;
|
|
iterator begin() const { return getValue().begin(); }
|
|
iterator end() const { return getValue().end(); }
|
|
size_t size() const { return getValue().size(); }
|
|
bool empty() const { return size() == 0; }
|
|
|
|
private:
|
|
/// Class for underlying value iterator support.
|
|
template <typename AttrTy>
|
|
class attr_value_iterator final
|
|
: public llvm::mapped_iterator<ArrayAttr::iterator,
|
|
AttrTy (*)(Attribute)> {
|
|
public:
|
|
explicit attr_value_iterator(ArrayAttr::iterator it)
|
|
: llvm::mapped_iterator<ArrayAttr::iterator, AttrTy (*)(Attribute)>(
|
|
it, [](Attribute attr) { return ::llvm::cast<AttrTy>(attr); }) {}
|
|
AttrTy operator*() const { return ::llvm::cast<AttrTy>(*this->I); }
|
|
};
|
|
|
|
public:
|
|
template <typename AttrTy>
|
|
iterator_range<attr_value_iterator<AttrTy>> getAsRange() const {
|
|
return llvm::make_range(attr_value_iterator<AttrTy>(begin()),
|
|
attr_value_iterator<AttrTy>(end()));
|
|
}
|
|
template <typename AttrTy,
|
|
typename UnderlyingTy = typename AttrTy::ValueType>
|
|
auto getAsValueRange() const {
|
|
return llvm::map_range(getAsRange<AttrTy>(), [](AttrTy attr) {
|
|
return static_cast<UnderlyingTy>(attr.getValue());
|
|
});
|
|
}
|
|
static constexpr ::llvm::StringLiteral name = "builtin.array";
|
|
static constexpr ::llvm::StringLiteral dialectName = "builtin";
|
|
static ArrayAttr get(::mlir::MLIRContext *context, ::llvm::ArrayRef<Attribute> value);
|
|
::llvm::ArrayRef<Attribute> getValue() const;
|
|
};
|
|
namespace detail {
|
|
|
|
struct DenseArrayAttrStorage;
|
|
|
|
} // namespace detail
|
|
class DenseArrayAttr : public ::mlir::Attribute::AttrBase<DenseArrayAttr, ::mlir::Attribute, detail::DenseArrayAttrStorage, ::mlir::BlobAttr::Trait> {
|
|
public:
|
|
using Base::Base;
|
|
/// Get the number of elements in the array.
|
|
int64_t size() const { return getSize(); }
|
|
/// Return true if there are no elements in the dense array.
|
|
bool empty() const { return !size(); }
|
|
/// BlobAttrInterface method.
|
|
ArrayRef<char> getData() {
|
|
return getRawData();
|
|
}
|
|
static constexpr ::llvm::StringLiteral name = "builtin.dense_array";
|
|
static constexpr ::llvm::StringLiteral dialectName = "builtin";
|
|
using Base::getChecked;
|
|
static DenseArrayAttr get(::mlir::MLIRContext *context, Type elementType, int64_t size, ::llvm::ArrayRef<char> rawData);
|
|
static DenseArrayAttr getChecked(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, ::mlir::MLIRContext *context, Type elementType, int64_t size, ::llvm::ArrayRef<char> rawData);
|
|
static DenseArrayAttr get(Type elementType, unsigned size, ArrayRef<char> rawData);
|
|
static DenseArrayAttr getChecked(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, Type elementType, unsigned size, ArrayRef<char> rawData);
|
|
static ::llvm::LogicalResult verify(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, Type elementType, int64_t size, ::llvm::ArrayRef<char> rawData);
|
|
static ::llvm::LogicalResult verifyInvariants(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, Type elementType, int64_t size, ::llvm::ArrayRef<char> rawData);
|
|
Type getElementType() const;
|
|
int64_t getSize() const;
|
|
::llvm::ArrayRef<char> getRawData() const;
|
|
};
|
|
class DenseTypedElementsAttr : public ::mlir::Attribute::AttrBase<DenseTypedElementsAttr, DenseElementsAttr, detail::DenseTypedElementsAttrStorage, ::mlir::TypedAttr::Trait, ::mlir::ElementsAttr::Trait> {
|
|
public:
|
|
using Base::Base;
|
|
using DenseElementsAttr::empty;
|
|
using DenseElementsAttr::getNumElements;
|
|
using DenseElementsAttr::getElementType;
|
|
using DenseElementsAttr::getValues;
|
|
using DenseElementsAttr::isSplat;
|
|
using DenseElementsAttr::size;
|
|
using DenseElementsAttr::value_begin;
|
|
|
|
/// The set of data types that can be iterated by this attribute.
|
|
using ContiguousIterableTypesT = std::tuple<
|
|
// Integer types.
|
|
uint8_t, uint16_t, uint32_t, uint64_t,
|
|
int8_t, int16_t, int32_t, int64_t,
|
|
short, unsigned short, int, unsigned, long, unsigned long,
|
|
mlir::Complex<uint8_t>, mlir::Complex<uint16_t>, mlir::Complex<uint32_t>,
|
|
mlir::Complex<uint64_t>,
|
|
mlir::Complex<int8_t>, mlir::Complex<int16_t>, mlir::Complex<int32_t>,
|
|
mlir::Complex<int64_t>,
|
|
// Float types.
|
|
float, double, mlir::Complex<float>, mlir::Complex<double>
|
|
>;
|
|
using NonContiguousIterableTypesT = std::tuple<
|
|
Attribute,
|
|
// Integer types.
|
|
APInt, bool, mlir::Complex<APInt>,
|
|
// Float types.
|
|
APFloat, mlir::Complex<APFloat>
|
|
>;
|
|
|
|
/// Provide a `try_value_begin_impl` to enable iteration within
|
|
/// ElementsAttr.
|
|
template <typename T>
|
|
auto try_value_begin_impl(OverloadToken<T>) const {
|
|
return try_value_begin<T>();
|
|
}
|
|
|
|
/// Convert endianess of input ArrayRef for big-endian(BE) machines. All of
|
|
/// the elements of `inRawData` has `type`. If `inRawData` is little endian
|
|
/// (LE), it is converted to big endian (BE). Conversely, if `inRawData` is
|
|
/// BE, converted to LE.
|
|
static void
|
|
convertEndianOfArrayRefForBEmachine(ArrayRef<char> inRawData,
|
|
MutableArrayRef<char> outRawData,
|
|
ShapedType type);
|
|
|
|
/// Convert endianess of input for big-endian(BE) machines. The number of
|
|
/// elements of `inRawData` is `numElements`, and each element has
|
|
/// `elementBitWidth` bits. If `inRawData` is little endian (LE), it is
|
|
/// converted to big endian (BE) and saved in `outRawData`. Conversely, if
|
|
/// `inRawData` is BE, converted to LE.
|
|
static void convertEndianOfCharForBEmachine(const char *inRawData,
|
|
char *outRawData,
|
|
size_t elementBitWidth,
|
|
size_t numElements);
|
|
|
|
protected:
|
|
friend DenseElementsAttr;
|
|
|
|
/// Constructs a dense elements attribute from an array of raw APFloat
|
|
/// values. Each APFloat value is expected to have the same bitwidth as the
|
|
/// element type of 'type'. 'type' must be a vector or tensor with static
|
|
/// shape.
|
|
///
|
|
/// If the `values` array only has a single element, then this constructs
|
|
/// splat of that value.
|
|
static DenseElementsAttr getRaw(ShapedType type, size_t storageWidth,
|
|
ArrayRef<APFloat> values);
|
|
|
|
/// Constructs a dense elements attribute from an array of raw APInt values.
|
|
/// Each APInt value is expected to have the same bitwidth as the element
|
|
/// type of 'type'. 'type' must be a vector or tensor with static shape.
|
|
///
|
|
/// If the `values` array only has a single element, then this constructs
|
|
/// splat of that value.
|
|
static DenseElementsAttr getRaw(ShapedType type, size_t storageWidth,
|
|
ArrayRef<APInt> values);
|
|
|
|
/// Get or create a new dense elements attribute instance with the given raw
|
|
/// data buffer. 'type' must be a vector or tensor with static shape.
|
|
///
|
|
/// If the `values` array only has a single element, then this constructs
|
|
/// splat of that value.
|
|
static DenseElementsAttr getRaw(ShapedType type, ArrayRef<char> data);
|
|
|
|
/// Overload of the raw 'get' method that asserts that the given type is of
|
|
/// complex type. This method is used to verify type invariants that the
|
|
/// templatized 'get' method cannot.
|
|
static DenseElementsAttr getRawComplex(ShapedType type, ArrayRef<char> data,
|
|
int64_t dataEltSize, bool isInt,
|
|
bool isSigned);
|
|
|
|
/// Overload of the raw 'get' method that asserts that the given type is of
|
|
/// integer or floating-point type. This method is used to verify type
|
|
/// invariants that the templatized 'get' method cannot.
|
|
static DenseElementsAttr getRawIntOrFloat(ShapedType type,
|
|
ArrayRef<char> data,
|
|
int64_t dataEltSize, bool isInt,
|
|
bool isSigned);
|
|
public:
|
|
static constexpr ::llvm::StringLiteral name = "builtin.dense_typed_elements";
|
|
static constexpr ::llvm::StringLiteral dialectName = "builtin";
|
|
};
|
|
class DenseStringElementsAttr : public ::mlir::Attribute::AttrBase<DenseStringElementsAttr, DenseElementsAttr, detail::DenseStringElementsAttrStorage, ::mlir::TypedAttr::Trait, ::mlir::ElementsAttr::Trait> {
|
|
public:
|
|
using Base::Base;
|
|
using DenseElementsAttr::empty;
|
|
using DenseElementsAttr::getNumElements;
|
|
using DenseElementsAttr::getElementType;
|
|
using DenseElementsAttr::getValues;
|
|
using DenseElementsAttr::isSplat;
|
|
using DenseElementsAttr::size;
|
|
using DenseElementsAttr::value_begin;
|
|
|
|
/// The set of data types that can be iterated by this attribute.
|
|
using ContiguousIterableTypesT = std::tuple<StringRef>;
|
|
using NonContiguousIterableTypesT = std::tuple<Attribute>;
|
|
|
|
/// Provide a `try_value_begin_impl` to enable iteration within
|
|
/// ElementsAttr.
|
|
template <typename T>
|
|
auto try_value_begin_impl(OverloadToken<T>) const {
|
|
return try_value_begin<T>();
|
|
}
|
|
|
|
protected:
|
|
friend DenseElementsAttr;
|
|
|
|
public:
|
|
static constexpr ::llvm::StringLiteral name = "builtin.dense_string_elements";
|
|
static constexpr ::llvm::StringLiteral dialectName = "builtin";
|
|
static DenseStringElementsAttr get(ShapedType type, ArrayRef<StringRef> values);
|
|
};
|
|
namespace detail {
|
|
|
|
struct DenseResourceElementsAttrStorage;
|
|
|
|
} // namespace detail
|
|
class DenseResourceElementsAttr : public ::mlir::Attribute::AttrBase<DenseResourceElementsAttr, ::mlir::Attribute, detail::DenseResourceElementsAttrStorage, ::mlir::TypedAttr::Trait, ::mlir::ElementsAttr::Trait, ::mlir::BlobAttr::Trait> {
|
|
public:
|
|
using Base::Base;
|
|
/// BlobAttrInterface method.
|
|
ArrayRef<char> getData();
|
|
static constexpr ::llvm::StringLiteral name = "builtin.dense_resource_elements";
|
|
static constexpr ::llvm::StringLiteral dialectName = "builtin";
|
|
static DenseResourceElementsAttr get(ShapedType type, DenseResourceElementsHandle handle);
|
|
static DenseResourceElementsAttr get(ShapedType type, StringRef blobName, AsmResourceBlob blob);
|
|
ShapedType getType() const;
|
|
DenseResourceElementsHandle getRawHandle() const;
|
|
};
|
|
namespace detail {
|
|
|
|
struct DictionaryAttrStorage;
|
|
|
|
} // namespace detail
|
|
class DictionaryAttr : public ::mlir::Attribute::AttrBase<DictionaryAttr, ::mlir::Attribute, detail::DictionaryAttrStorage> {
|
|
public:
|
|
using Base::Base;
|
|
using ValueType = ArrayRef<NamedAttribute>;
|
|
|
|
/// Construct a dictionary with an array of values that is known to already
|
|
/// be sorted by name and uniqued.
|
|
static DictionaryAttr getWithSorted(MLIRContext *context,
|
|
ArrayRef<NamedAttribute> value);
|
|
|
|
/// Return the specified attribute if present, null otherwise.
|
|
Attribute get(StringRef name) const;
|
|
Attribute get(StringAttr name) const;
|
|
|
|
/// Return the specified named attribute if present, std::nullopt otherwise.
|
|
std::optional<NamedAttribute> getNamed(StringRef name) const;
|
|
std::optional<NamedAttribute> getNamed(StringAttr name) const;
|
|
|
|
/// Return whether the specified attribute is present.
|
|
bool contains(StringRef name) const;
|
|
bool contains(StringAttr name) const;
|
|
|
|
/// Support range iteration.
|
|
using iterator = llvm::ArrayRef<NamedAttribute>::iterator;
|
|
iterator begin() const;
|
|
iterator end() const;
|
|
bool empty() const { return size() == 0; }
|
|
size_t size() const;
|
|
|
|
/// Sorts the NamedAttributes in the array ordered by name as expected by
|
|
/// getWithSorted and returns whether the values were sorted.
|
|
/// Requires: uniquely named attributes.
|
|
static bool sort(ArrayRef<NamedAttribute> values,
|
|
SmallVectorImpl<NamedAttribute> &storage);
|
|
|
|
/// Sorts the NamedAttributes in the array ordered by name as expected by
|
|
/// getWithSorted in place on an array and returns whether the values needed
|
|
/// to be sorted.
|
|
/// Requires: uniquely named attributes.
|
|
static bool sortInPlace(SmallVectorImpl<NamedAttribute> &array);
|
|
|
|
/// Returns an entry with a duplicate name in `array`, if it exists, else
|
|
/// returns std::nullopt. If `isSorted` is true, the array is assumed to be
|
|
/// sorted else it will be sorted in place before finding the duplicate entry.
|
|
static std::optional<NamedAttribute>
|
|
findDuplicate(SmallVectorImpl<NamedAttribute> &array, bool isSorted);
|
|
|
|
/// Return the specified attribute if present and is an instance of
|
|
/// `AttrClass`, null otherwise.
|
|
template<typename AttrClass, typename NameClass>
|
|
AttrClass getAs(NameClass &&name) const {
|
|
return llvm::dyn_cast_or_null<AttrClass>(
|
|
get(std::forward<NameClass>(name)));
|
|
}
|
|
|
|
private:
|
|
/// Return empty dictionary.
|
|
static DictionaryAttr getEmpty(MLIRContext *context);
|
|
|
|
/// Return empty dictionary. This is a special variant of the above method
|
|
/// that is used by the MLIRContext to cache the empty dictionary instance.
|
|
static DictionaryAttr getEmptyUnchecked(MLIRContext *context);
|
|
|
|
/// Allow access to `getEmptyUnchecked`.
|
|
friend MLIRContext;
|
|
|
|
public:
|
|
static constexpr ::llvm::StringLiteral name = "builtin.dictionary";
|
|
static constexpr ::llvm::StringLiteral dialectName = "builtin";
|
|
static DictionaryAttr get(::mlir::MLIRContext *context, ArrayRef<NamedAttribute> value = {});
|
|
::llvm::ArrayRef<NamedAttribute> getValue() const;
|
|
};
|
|
namespace detail {
|
|
|
|
struct FloatAttrStorage;
|
|
|
|
} // namespace detail
|
|
class FloatAttr : public ::mlir::Attribute::AttrBase<FloatAttr, ::mlir::Attribute, detail::FloatAttrStorage, ::mlir::TypedAttr::Trait> {
|
|
public:
|
|
using Base::Base;
|
|
using ValueType = APFloat;
|
|
|
|
/// This function is used to convert the value to a double, even if it loses
|
|
/// precision.
|
|
double getValueAsDouble() const;
|
|
static double getValueAsDouble(APFloat val);
|
|
static constexpr ::llvm::StringLiteral name = "builtin.float";
|
|
static constexpr ::llvm::StringLiteral dialectName = "builtin";
|
|
using Base::getChecked;
|
|
static FloatAttr get(Type type, const APFloat &value);
|
|
static FloatAttr getChecked(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, Type type, const APFloat &value);
|
|
static FloatAttr get(Type type, double value);
|
|
static FloatAttr getChecked(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, Type type, double value);
|
|
static ::llvm::LogicalResult verify(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, ::mlir::Type type, ::llvm::APFloat value);
|
|
static ::llvm::LogicalResult verifyInvariants(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, ::mlir::Type type, ::llvm::APFloat value);
|
|
::mlir::Type getType() const;
|
|
::llvm::APFloat getValue() const;
|
|
};
|
|
namespace detail {
|
|
|
|
struct IntegerAttrStorage;
|
|
|
|
} // namespace detail
|
|
class IntegerAttr : public ::mlir::Attribute::AttrBase<IntegerAttr, ::mlir::Attribute, detail::IntegerAttrStorage, ::mlir::TypedAttr::Trait> {
|
|
public:
|
|
using Base::Base;
|
|
using ValueType = APInt;
|
|
|
|
/// Return the integer value as a 64-bit int. The attribute must be a
|
|
/// signless integer.
|
|
// TODO: Change callers to use getValue instead.
|
|
int64_t getInt() const;
|
|
/// Return the integer value as a signed 64-bit int. The attribute must be
|
|
/// a signed integer.
|
|
int64_t getSInt() const;
|
|
/// Return the integer value as a unsigned 64-bit int. The attribute must be
|
|
/// an unsigned integer.
|
|
uint64_t getUInt() const;
|
|
|
|
/// Return the value as an APSInt which carries the signed from the type of
|
|
/// the attribute. This traps on signless integers types!
|
|
APSInt getAPSInt() const;
|
|
|
|
private:
|
|
/// Return a boolean attribute. This is a special variant of the `get`
|
|
/// method that is used by the MLIRContext to cache the boolean IntegerAttr
|
|
/// instances.
|
|
static BoolAttr getBoolAttrUnchecked(IntegerType type, bool value);
|
|
|
|
/// Allow access to `getBoolAttrUnchecked`.
|
|
friend MLIRContext;
|
|
|
|
public:
|
|
static constexpr ::llvm::StringLiteral name = "builtin.integer";
|
|
static constexpr ::llvm::StringLiteral dialectName = "builtin";
|
|
using Base::getChecked;
|
|
static IntegerAttr get(Type type, const APInt &value);
|
|
static IntegerAttr getChecked(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, Type type, const APInt &value);
|
|
static IntegerAttr get(::mlir::MLIRContext *context, const APSInt &value);
|
|
static IntegerAttr getChecked(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, ::mlir::MLIRContext *context, const APSInt &value);
|
|
static IntegerAttr get(Type type, int64_t value);
|
|
static IntegerAttr getChecked(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, Type type, int64_t value);
|
|
static ::llvm::LogicalResult verify(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, ::mlir::Type type, ::llvm::APInt value);
|
|
static ::llvm::LogicalResult verifyInvariants(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, ::mlir::Type type, ::llvm::APInt value);
|
|
::mlir::Type getType() const;
|
|
const ::llvm::APInt &getValue() const;
|
|
};
|
|
namespace detail {
|
|
|
|
struct IntegerSetAttrStorage;
|
|
|
|
} // namespace detail
|
|
class IntegerSetAttr : public ::mlir::Attribute::AttrBase<IntegerSetAttr, ::mlir::Attribute, detail::IntegerSetAttrStorage, ::mlir::OpAsmAttrInterface::Trait> {
|
|
public:
|
|
using Base::Base;
|
|
using ValueType = IntegerSet;
|
|
|
|
//===------------------------------------------------------------------===//
|
|
// OpAsmAttrInterface Methods
|
|
//===------------------------------------------------------------------===//
|
|
|
|
/// Get a name to use when generating an alias for this attribute.
|
|
::mlir::OpAsmAliasResult getAlias(::llvm::raw_ostream &os) const {
|
|
os << "set";
|
|
return ::mlir::OpAsmAliasResult::OverridableAlias;
|
|
}
|
|
static constexpr ::llvm::StringLiteral name = "builtin.integer_set";
|
|
static constexpr ::llvm::StringLiteral dialectName = "builtin";
|
|
static IntegerSetAttr get(IntegerSet value);
|
|
IntegerSet getValue() const;
|
|
};
|
|
namespace detail {
|
|
|
|
struct OpaqueAttrStorage;
|
|
|
|
} // namespace detail
|
|
class OpaqueAttr : public ::mlir::Attribute::AttrBase<OpaqueAttr, ::mlir::Attribute, detail::OpaqueAttrStorage, ::mlir::TypedAttr::Trait> {
|
|
public:
|
|
using Base::Base;
|
|
static constexpr ::llvm::StringLiteral name = "builtin.opaque";
|
|
static constexpr ::llvm::StringLiteral dialectName = "builtin";
|
|
using Base::getChecked;
|
|
static OpaqueAttr get(StringAttr dialect, StringRef attrData, Type type);
|
|
static OpaqueAttr getChecked(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, StringAttr dialect, StringRef attrData, Type type);
|
|
static ::llvm::LogicalResult verify(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, StringAttr dialectNamespace, ::llvm::StringRef attrData, ::mlir::Type type);
|
|
static ::llvm::LogicalResult verifyInvariants(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, StringAttr dialectNamespace, ::llvm::StringRef attrData, ::mlir::Type type);
|
|
StringAttr getDialectNamespace() const;
|
|
::llvm::StringRef getAttrData() const;
|
|
::mlir::Type getType() const;
|
|
};
|
|
namespace detail {
|
|
|
|
struct SparseElementsAttrStorage;
|
|
|
|
} // namespace detail
|
|
class SparseElementsAttr : public ::mlir::Attribute::AttrBase<SparseElementsAttr, ::mlir::Attribute, detail::SparseElementsAttrStorage, ::mlir::TypedAttr::Trait, ::mlir::ElementsAttr::Trait> {
|
|
public:
|
|
using Base::Base;
|
|
/// The set of data types that can be iterated by this attribute.
|
|
// FIXME: Realistically, SparseElementsAttr could use ElementsAttr for the
|
|
// value storage. This would mean dispatching to `values` when accessing
|
|
// values. For now, we just add the types that can be iterated by
|
|
// DenseElementsAttr.
|
|
using NonContiguousIterableTypesT = std::tuple<
|
|
Attribute,
|
|
// Integer types.
|
|
APInt, bool, uint8_t, uint16_t, uint32_t, uint64_t,
|
|
int8_t, int16_t, int32_t, int64_t,
|
|
short, unsigned short, int, unsigned, long, unsigned long,
|
|
mlir::Complex<APInt>, mlir::Complex<uint8_t>, mlir::Complex<uint16_t>,
|
|
mlir::Complex<uint32_t>, mlir::Complex<uint64_t>, mlir::Complex<int8_t>,
|
|
mlir::Complex<int16_t>, mlir::Complex<int32_t>, mlir::Complex<int64_t>,
|
|
// Float types.
|
|
APFloat, float, double,
|
|
mlir::Complex<APFloat>, mlir::Complex<float>, mlir::Complex<double>,
|
|
// String types.
|
|
StringRef
|
|
>;
|
|
using ElementsAttr::Trait<SparseElementsAttr>::getValues;
|
|
using ElementsAttr::Trait<SparseElementsAttr>::value_begin;
|
|
|
|
template <typename T>
|
|
using iterator =
|
|
llvm::mapped_iterator<typename decltype(llvm::seq<ptrdiff_t>(0, 0))::iterator,
|
|
std::function<T(ptrdiff_t)>>;
|
|
|
|
/// Provide a `try_value_begin_impl` to enable iteration within
|
|
/// ElementsAttr.
|
|
template <typename T>
|
|
FailureOr<iterator<T>> try_value_begin_impl(OverloadToken<T>) const;
|
|
|
|
private:
|
|
/// Get a zero APFloat for the given sparse attribute.
|
|
APFloat getZeroAPFloat() const;
|
|
|
|
/// Get a zero APInt for the given sparse attribute.
|
|
APInt getZeroAPInt() const;
|
|
|
|
/// Get a zero attribute for the given sparse attribute.
|
|
Attribute getZeroAttr() const;
|
|
|
|
/// Utility methods to generate a zero value of some type 'T'. This is used
|
|
/// by the 'iterator' class.
|
|
/// Get a zero for a given attribute type.
|
|
template <typename T>
|
|
std::enable_if_t<std::is_base_of<Attribute, T>::value, T>
|
|
getZeroValue() const {
|
|
return ::llvm::cast<T>(getZeroAttr());
|
|
}
|
|
/// Get a zero for an APInt.
|
|
template <typename T>
|
|
std::enable_if_t<std::is_same<APInt, T>::value, T>
|
|
getZeroValue() const {
|
|
return getZeroAPInt();
|
|
}
|
|
template <typename T>
|
|
std::enable_if_t<std::is_same<mlir::Complex<APInt>, T>::value, T>
|
|
getZeroValue() const {
|
|
APInt intZero = getZeroAPInt();
|
|
return {intZero, intZero};
|
|
}
|
|
/// Get a zero for an APFloat.
|
|
template <typename T>
|
|
std::enable_if_t<std::is_same<APFloat, T>::value, T>
|
|
getZeroValue() const {
|
|
return getZeroAPFloat();
|
|
}
|
|
template <typename T>
|
|
std::enable_if_t<std::is_same<mlir::Complex<APFloat>, T>::value, T>
|
|
getZeroValue() const {
|
|
APFloat floatZero = getZeroAPFloat();
|
|
return {floatZero, floatZero};
|
|
}
|
|
|
|
/// Get a zero for an C++ integer, float, StringRef, or complex type.
|
|
template <typename T>
|
|
std::enable_if_t<std::numeric_limits<T>::is_integer ||
|
|
DenseElementsAttr::is_valid_cpp_fp_type<T>::value ||
|
|
std::is_same<T, StringRef>::value ||
|
|
(detail::is_complex_t<T>::value &&
|
|
!llvm::is_one_of<T, mlir::Complex<APInt>,
|
|
mlir::Complex<APFloat>>::value),
|
|
T>
|
|
getZeroValue() const {
|
|
return T();
|
|
}
|
|
|
|
/// Flatten, and return, all of the sparse indices in this attribute in
|
|
/// row-major order.
|
|
SmallVector<ptrdiff_t> getFlattenedSparseIndices() const;
|
|
|
|
public:
|
|
static constexpr ::llvm::StringLiteral name = "builtin.sparse_elements";
|
|
static constexpr ::llvm::StringLiteral dialectName = "builtin";
|
|
using Base::getChecked;
|
|
static SparseElementsAttr get(ShapedType type, DenseElementsAttr indices, DenseElementsAttr values);
|
|
static SparseElementsAttr getChecked(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, ShapedType type, DenseElementsAttr indices, DenseElementsAttr values);
|
|
static ::llvm::LogicalResult verify(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, ShapedType type, DenseIntElementsAttr indices, DenseElementsAttr values);
|
|
static ::llvm::LogicalResult verifyInvariants(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, ShapedType type, DenseIntElementsAttr indices, DenseElementsAttr values);
|
|
ShapedType getType() const;
|
|
DenseIntElementsAttr getIndices() const;
|
|
DenseElementsAttr getValues() const;
|
|
};
|
|
namespace detail {
|
|
|
|
struct StridedLayoutAttrStorage;
|
|
|
|
} // namespace detail
|
|
class StridedLayoutAttr : public ::mlir::Attribute::AttrBase<StridedLayoutAttr, ::mlir::Attribute, detail::StridedLayoutAttrStorage, ::mlir::MemRefLayoutAttrInterface::Trait> {
|
|
public:
|
|
using Base::Base;
|
|
/// Print the attribute to the given output stream.
|
|
void print(raw_ostream &os) const;
|
|
|
|
/// Returns true if this layout is static, i.e. the strides and offset all
|
|
/// have a known value > 0.
|
|
bool hasStaticLayout() const;
|
|
static constexpr ::llvm::StringLiteral name = "builtin.strided_layout";
|
|
static constexpr ::llvm::StringLiteral dialectName = "builtin";
|
|
using Base::getChecked;
|
|
using ::mlir::MemRefLayoutAttrInterface::Trait<StridedLayoutAttr>::isIdentity;
|
|
static StridedLayoutAttr get(::mlir::MLIRContext *context, int64_t offset, ::llvm::ArrayRef<int64_t> strides);
|
|
static StridedLayoutAttr getChecked(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, ::mlir::MLIRContext *context, int64_t offset, ::llvm::ArrayRef<int64_t> strides);
|
|
static ::llvm::LogicalResult verify(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, int64_t offset, ::llvm::ArrayRef<int64_t> strides);
|
|
static ::llvm::LogicalResult verifyInvariants(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, int64_t offset, ::llvm::ArrayRef<int64_t> strides);
|
|
int64_t getOffset() const;
|
|
::llvm::ArrayRef<int64_t> getStrides() const;
|
|
::mlir::AffineMap getAffineMap() const;
|
|
::llvm::LogicalResult verifyLayout(::llvm::ArrayRef<int64_t> shape, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) const;
|
|
::llvm::LogicalResult getStridesAndOffset(::llvm::ArrayRef<int64_t> shape, ::llvm::SmallVectorImpl<int64_t>&strides, int64_t&offset) const;
|
|
};
|
|
class StringAttr : public ::mlir::Attribute::AttrBase<StringAttr, ::mlir::Attribute, detail::StringAttrStorage, ::mlir::TypedAttr::Trait> {
|
|
public:
|
|
using Base::Base;
|
|
using ValueType = StringRef;
|
|
|
|
/// If the value of this string is prefixed with a dialect namespace,
|
|
/// returns the dialect corresponding to that namespace if it is loaded,
|
|
/// nullptr otherwise. For example, the string `llvm.fastmathflags` would
|
|
/// return the LLVM dialect, assuming it is loaded in the context.
|
|
Dialect *getReferencedDialect() const;
|
|
|
|
/// Enable conversion to StringRef.
|
|
operator StringRef() const { return getValue(); }
|
|
|
|
/// Returns the underlying string value
|
|
StringRef strref() const { return getValue(); }
|
|
|
|
/// Convert the underling value to an std::string.
|
|
std::string str() const { return getValue().str(); }
|
|
|
|
/// Return a pointer to the start of the string data.
|
|
const char *data() const { return getValue().data(); }
|
|
|
|
/// Return the number of bytes in this string.
|
|
size_t size() const { return getValue().size(); }
|
|
|
|
/// Return whether the string is empty.
|
|
bool empty() const { return getValue().empty(); }
|
|
|
|
/// Iterate over the underlying string data.
|
|
StringRef::iterator begin() const { return getValue().begin(); }
|
|
StringRef::iterator end() const { return getValue().end(); }
|
|
|
|
/// Compare the underlying string value to the one in `rhs`.
|
|
int compare(StringAttr rhs) const {
|
|
if (*this == rhs)
|
|
return 0;
|
|
return getValue().compare(rhs.getValue());
|
|
}
|
|
|
|
private:
|
|
/// Return an empty StringAttr with NoneType type. This is a special variant
|
|
/// of the `get` method that is used by the MLIRContext to cache the
|
|
/// instance.
|
|
static StringAttr getEmptyStringAttrUnchecked(MLIRContext *context);
|
|
friend MLIRContext;
|
|
public:
|
|
static constexpr ::llvm::StringLiteral name = "builtin.string";
|
|
static constexpr ::llvm::StringLiteral dialectName = "builtin";
|
|
static StringAttr get(const Twine &bytes, Type type);
|
|
static StringAttr get(::mlir::MLIRContext *context, const Twine &bytes);
|
|
static StringAttr get(::mlir::MLIRContext *context);
|
|
::llvm::StringRef getValue() const;
|
|
::mlir::Type getType() const;
|
|
};
|
|
namespace detail {
|
|
|
|
struct SymbolRefAttrStorage;
|
|
|
|
} // namespace detail
|
|
class SymbolRefAttr : public ::mlir::Attribute::AttrBase<SymbolRefAttr, ::mlir::Attribute, detail::SymbolRefAttrStorage> {
|
|
public:
|
|
using Base::Base;
|
|
static SymbolRefAttr get(MLIRContext *ctx, StringRef value,
|
|
ArrayRef<FlatSymbolRefAttr> nestedRefs);
|
|
/// Convenience getters for building a SymbolRefAttr with no path, which is
|
|
/// known to produce a FlatSymbolRefAttr.
|
|
static FlatSymbolRefAttr get(StringAttr value);
|
|
static FlatSymbolRefAttr get(MLIRContext *ctx, StringRef value);
|
|
|
|
/// Convenience getter for buliding a SymbolRefAttr based on an operation
|
|
/// that implements the SymbolTrait.
|
|
static FlatSymbolRefAttr get(Operation *symbol);
|
|
|
|
/// Returns the name of the fully resolved symbol, i.e. the leaf of the
|
|
/// reference path.
|
|
StringAttr getLeafReference() const;
|
|
static constexpr ::llvm::StringLiteral name = "builtin.symbol_ref";
|
|
static constexpr ::llvm::StringLiteral dialectName = "builtin";
|
|
static SymbolRefAttr get(StringAttr rootReference, ArrayRef<FlatSymbolRefAttr> nestedReferences);
|
|
StringAttr getRootReference() const;
|
|
::llvm::ArrayRef<FlatSymbolRefAttr> getNestedReferences() const;
|
|
};
|
|
namespace detail {
|
|
|
|
struct TypeAttrStorage;
|
|
|
|
} // namespace detail
|
|
class TypeAttr : public ::mlir::Attribute::AttrBase<TypeAttr, ::mlir::Attribute, detail::TypeAttrStorage> {
|
|
public:
|
|
using Base::Base;
|
|
using ValueType = Type;static constexpr ::llvm::StringLiteral name = "builtin.type";
|
|
static constexpr ::llvm::StringLiteral dialectName = "builtin";
|
|
static TypeAttr get(Type type);
|
|
Type getValue() const;
|
|
};
|
|
class UnitAttr : public ::mlir::Attribute::AttrBase<UnitAttr, ::mlir::Attribute, ::mlir::AttributeStorage> {
|
|
public:
|
|
using Base::Base;
|
|
static UnitAttr get(MLIRContext *context);
|
|
static constexpr ::llvm::StringLiteral name = "builtin.unit";
|
|
static constexpr ::llvm::StringLiteral dialectName = "builtin";
|
|
};
|
|
|
|
} // namespace mlir
|
|
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::AffineMapAttr)
|
|
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::ArrayAttr)
|
|
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::DenseArrayAttr)
|
|
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::DenseTypedElementsAttr)
|
|
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::DenseStringElementsAttr)
|
|
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::DenseResourceElementsAttr)
|
|
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::DictionaryAttr)
|
|
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::FloatAttr)
|
|
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::IntegerAttr)
|
|
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::IntegerSetAttr)
|
|
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::OpaqueAttr)
|
|
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::SparseElementsAttr)
|
|
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::StridedLayoutAttr)
|
|
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::StringAttr)
|
|
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::SymbolRefAttr)
|
|
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::TypeAttr)
|
|
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::UnitAttr)
|
|
|
|
#endif // GET_ATTRDEF_CLASSES
|
|
|