This is an archive of the discontinued LLVM Phabricator instance.

Show All 16 Lines

namespace mlir {		namespace mlir {
class AffineExpr;		class AffineExpr;
class AffineMap;		class AffineMap;
class FloatType;		class FloatType;
class Identifier;		class Identifier;
class IndexType;		class IndexType;
class IntegerType;		class IntegerType;
class Location;
class MLIRContext;
class TypeRange;		class TypeRange;

namespace detail {

struct BaseMemRefTypeStorage;
struct MemRefTypeStorage;
struct RankedTensorTypeStorage;
struct ShapedTypeStorage;
struct UnrankedMemRefTypeStorage;
struct UnrankedTensorTypeStorage;
struct VectorTypeStorage;

} // namespace detail

//===----------------------------------------------------------------------===//		//===----------------------------------------------------------------------===//
// FloatType		// FloatType
//===----------------------------------------------------------------------===//		//===----------------------------------------------------------------------===//

class FloatType : public Type {		class FloatType : public Type {
public:		public:
using Type::Type;		using Type::Type;

Show All 24 Lines
//===----------------------------------------------------------------------===//		//===----------------------------------------------------------------------===//

/// This is a common base class between Vector, UnrankedTensor, RankedTensor,		/// This is a common base class between Vector, UnrankedTensor, RankedTensor,
/// and MemRef types because they share behavior and semantics around shape,		/// and MemRef types because they share behavior and semantics around shape,
/// rank, and fixed element type. Any type with these semantics should inherit		/// rank, and fixed element type. Any type with these semantics should inherit
/// from ShapedType.		/// from ShapedType.
class ShapedType : public Type {		class ShapedType : public Type {
public:		public:
using ImplType = detail::ShapedTypeStorage;
using Type::Type;		using Type::Type;

// TODO: merge these two special values in a single one used everywhere.		// TODO: merge these two special values in a single one used everywhere.
// Unfortunately, uses of `-1` have crept deep into the codebase now and are		// Unfortunately, uses of `-1` have crept deep into the codebase now and are
// hard to track.		// hard to track.
static constexpr int64_t kDynamicSize = -1;		static constexpr int64_t kDynamicSize = -1;
static constexpr int64_t kDynamicStrideOrOffset =		static constexpr int64_t kDynamicStrideOrOffset =
std::numeric_limits<int64_t>::min();		std::numeric_limits<int64_t>::min();
▲ Show 20 Lines • Show All 63 Lines • ▼ Show 20 Lines	static constexpr bool isDynamic(int64_t dSize) {
return dSize == kDynamicSize;		return dSize == kDynamicSize;
}		}
static constexpr bool isDynamicStrideOrOffset(int64_t dStrideOrOffset) {		static constexpr bool isDynamicStrideOrOffset(int64_t dStrideOrOffset) {
return dStrideOrOffset == kDynamicStrideOrOffset;		return dStrideOrOffset == kDynamicStrideOrOffset;
}		}
};		};

//===----------------------------------------------------------------------===//		//===----------------------------------------------------------------------===//
// VectorType
//===----------------------------------------------------------------------===//

/// Vector types represent multi-dimensional SIMD vectors, and have a fixed
/// known constant shape with one or more dimension.
class VectorType
: public Type::TypeBase<VectorType, ShapedType, detail::VectorTypeStorage> {
public:
using Base::Base;
using Base::getChecked;

/// Get or create a new VectorType of the provided shape and element type.
/// Assumes the arguments define a well-formed VectorType.
static VectorType get(ArrayRef<int64_t> shape, Type elementType);

/// Get or create a new VectorType of the provided shape and element type. If
/// the VectorType defined by the arguments would be ill-formed, an error is
/// emitted to `emitError` and a null type is returned.
static VectorType getChecked(function_ref<InFlightDiagnostic()> emitError,
ArrayRef<int64_t> shape, Type elementType);

/// Verify the construction of a vector type.
static LogicalResult verify(function_ref<InFlightDiagnostic()> emitError,
ArrayRef<int64_t> shape, Type elementType);

/// Returns true of the given type can be used as an element of a vector type.
/// In particular, vectors can consist of integer or float primitives.
static bool isValidElementType(Type t) {
return t.isa<IntegerType, FloatType>();
}

ArrayRef<int64_t> getShape() const;

/// Get or create a new VectorType with the same shape as `this` and an
/// element type of bitwidth scaled by `scale`.
/// Return null if the scaled element type cannot be represented.
VectorType scaleElementBitwidth(unsigned scale);
};

//===----------------------------------------------------------------------===//
// TensorType		// TensorType
//===----------------------------------------------------------------------===//		//===----------------------------------------------------------------------===//

/// Tensor types represent multi-dimensional arrays, and have two variants:		/// Tensor types represent multi-dimensional arrays, and have two variants:
/// RankedTensorType and UnrankedTensorType.		/// RankedTensorType and UnrankedTensorType.
class TensorType : public ShapedType {		class TensorType : public ShapedType {
public:		public:
using ShapedType::ShapedType;		using ShapedType::ShapedType;

/// Return true if the specified element type is ok in a tensor.		/// Return true if the specified element type is ok in a tensor.
static bool isValidElementType(Type type);		static bool isValidElementType(Type type);

/// Methods for support type inquiry through isa, cast, and dyn_cast.		/// Methods for support type inquiry through isa, cast, and dyn_cast.
static bool classof(Type type);		static bool classof(Type type);
};		};

//===----------------------------------------------------------------------===//		//===----------------------------------------------------------------------===//
// RankedTensorType

/// Ranked tensor types represent multi-dimensional arrays that have a shape
/// with a fixed number of dimensions. Each shape element can be a non-negative
/// integer or unknown (represented by -1).
class RankedTensorType
: public Type::TypeBase<RankedTensorType, TensorType,
detail::RankedTensorTypeStorage> {
public:
using Base::Base;
using Base::getChecked;

/// Get or create a new RankedTensorType of the provided shape and element
/// type. Assumes the arguments define a well-formed type.
static RankedTensorType get(ArrayRef<int64_t> shape, Type elementType);

/// Get or create a new RankedTensorType of the provided shape and element
/// type. If the RankedTensorType defined by the arguments would be
/// ill-formed, an error is emitted to `emitError` and a null type is
/// returned.
static RankedTensorType
getChecked(function_ref<InFlightDiagnostic()> emitError,
ArrayRef<int64_t> shape, Type elementType);

/// Verify the construction of a ranked tensor type.
static LogicalResult verify(function_ref<InFlightDiagnostic()> emitError,
ArrayRef<int64_t> shape, Type elementType);

ArrayRef<int64_t> getShape() const;
};

//===----------------------------------------------------------------------===//
// UnrankedTensorType

/// Unranked tensor types represent multi-dimensional arrays that have an
/// unknown shape.
class UnrankedTensorType
: public Type::TypeBase<UnrankedTensorType, TensorType,
detail::UnrankedTensorTypeStorage> {
public:
using Base::Base;
using Base::getChecked;

/// Get or create a new UnrankedTensorType of the provided shape and element
/// type. Assumes the arguments define a well-formed type.
static UnrankedTensorType get(Type elementType);

/// Get or create a new UnrankedTensorType of the provided shape and element
/// type. If the RankedTensorType defined by the arguments would be
/// ill-formed, an error is emitted to `emitError` and a null type is
/// returned.
static UnrankedTensorType
getChecked(function_ref<InFlightDiagnostic()> emitError, Type elementType);

/// Verify the construction of a unranked tensor type.
static LogicalResult verify(function_ref<InFlightDiagnostic()> emitError,
Type elementType);

ArrayRef<int64_t> getShape() const { return llvm::None; }
};

//===----------------------------------------------------------------------===//
// BaseMemRefType		// BaseMemRefType
//===----------------------------------------------------------------------===//		//===----------------------------------------------------------------------===//

/// Base MemRef for Ranked and Unranked variants		/// Base MemRef for Ranked and Unranked variants
class BaseMemRefType : public ShapedType {		class BaseMemRefType : public ShapedType {
public:		public:
using ImplType = detail::BaseMemRefTypeStorage;
using ShapedType::ShapedType;		using ShapedType::ShapedType;

/// Return true if the specified element type is ok in a memref.		/// Return true if the specified element type is ok in a memref.
static bool isValidElementType(Type type);		static bool isValidElementType(Type type);

/// Methods for support type inquiry through isa, cast, and dyn_cast.		/// Methods for support type inquiry through isa, cast, and dyn_cast.
static bool classof(Type type);		static bool classof(Type type);

/// Returns the memory space in which data referred to by this memref resides.		/// Returns the memory space in which data referred to by this memref resides.
unsigned getMemorySpaceAsInt() const;		unsigned getMemorySpaceAsInt() const;
};		};

		} // end namespace mlir

		//===----------------------------------------------------------------------===//
		// Tablegen Type Declarations
		//===----------------------------------------------------------------------===//

		#define GET_TYPEDEF_CLASSES
		#include "mlir/IR/BuiltinTypes.h.inc"

		namespace mlir {
//===----------------------------------------------------------------------===//		//===----------------------------------------------------------------------===//
// MemRefType		// MemRefType
		//===----------------------------------------------------------------------===//

/// MemRef types represent a region of memory that have a shape with a fixed
/// number of dimensions. Each shape element can be a non-negative integer or
/// unknown (represented by -1). MemRef types also have an affine map
/// composition, represented as an array AffineMap pointers.
class MemRefType : public Type::TypeBase<MemRefType, BaseMemRefType,
detail::MemRefTypeStorage> {
public:
/// This is a builder type that keeps local references to arguments. Arguments		/// This is a builder type that keeps local references to arguments. Arguments
/// that are passed into the builder must out-live the builder.		/// that are passed into the builder must out-live the builder.
class Builder {		class MemRefType::Builder {
public:		public:
// Build from another MemRefType.		// Build from another MemRefType.
explicit Builder(MemRefType other)		explicit Builder(MemRefType other)
: shape(other.getShape()), elementType(other.getElementType()),		: shape(other.getShape()), elementType(other.getElementType()),
affineMaps(other.getAffineMaps()),		affineMaps(other.getAffineMaps()),
memorySpace(other.getMemorySpaceAsInt()) {}		memorySpace(other.getMemorySpaceAsInt()) {}

// Build from scratch.		// Build from scratch.
Builder(ArrayRef<int64_t> shape, Type elementType)		Builder(ArrayRef<int64_t> shape, Type elementType)
: shape(shape), elementType(elementType), affineMaps(), memorySpace(0) {		: shape(shape), elementType(elementType), affineMaps(), memorySpace(0) {}
}

Builder &setShape(ArrayRef<int64_t> newShape) {		Builder &setShape(ArrayRef<int64_t> newShape) {
shape = newShape;		shape = newShape;
return *this;		return *this;
}		}

Builder &setElementType(Type newElementType) {		Builder &setElementType(Type newElementType) {
elementType = newElementType;		elementType = newElementType;
return *this;		return *this;
}		}

Builder &setAffineMaps(ArrayRef<AffineMap> newAffineMaps) {		Builder &setAffineMaps(ArrayRef<AffineMap> newAffineMaps) {
affineMaps = newAffineMaps;		affineMaps = newAffineMaps;
return *this;		return *this;
}		}

Builder &setMemorySpace(unsigned newMemorySpace) {		Builder &setMemorySpace(unsigned newMemorySpace) {
memorySpace = newMemorySpace;		memorySpace = newMemorySpace;
return *this;		return *this;
}		}

operator MemRefType() {		operator MemRefType() {
return MemRefType::get(shape, elementType, affineMaps, memorySpace);		return MemRefType::get(shape, elementType, affineMaps, memorySpace);
}		}

private:		private:
ArrayRef<int64_t> shape;		ArrayRef<int64_t> shape;
Type elementType;		Type elementType;
ArrayRef<AffineMap> affineMaps;		ArrayRef<AffineMap> affineMaps;
unsigned memorySpace;		unsigned memorySpace;
};		};

using Base::Base;
using Base::getChecked;

/// Get or create a new MemRefType based on shape, element type, affine
/// map composition, and memory space. Assumes the arguments define a
/// well-formed MemRef type. Use getChecked to gracefully handle MemRefType
/// construction failures.
static MemRefType get(ArrayRef<int64_t> shape, Type elementType,
ArrayRef<AffineMap> affineMapComposition = {},
unsigned memorySpace = 0);

/// Get or create a new MemRefType based on shape, element type, affine
/// map composition, and memory space. If the MemRefType defined by the
/// arguments would be ill-formed, an error is emitted to `emitError` and a
/// null type is returned.
static MemRefType getChecked(function_ref<InFlightDiagnostic()> emitError,
ArrayRef<int64_t> shape, Type elementType,
ArrayRef<AffineMap> affineMapComposition,
unsigned memorySpace);

ArrayRef<int64_t> getShape() const;

/// Returns an array of affine map pointers representing the memref affine
/// map composition.
ArrayRef<AffineMap> getAffineMaps() const;

// TODO: merge these two special values in a single one used everywhere.
// Unfortunately, uses of `-1` have crept deep into the codebase now and are
// hard to track.
static int64_t getDynamicStrideOrOffset() {
return ShapedType::kDynamicStrideOrOffset;
}

private:
/// Get or create a new MemRefType defined by the arguments. If the resulting
/// type would be ill-formed, return nullptr.
static MemRefType getImpl(ArrayRef<int64_t> shape, Type elementType,
ArrayRef<AffineMap> affineMapComposition,
unsigned memorySpace,
function_ref<InFlightDiagnostic()> emitError);
using Base::getImpl;
};

//===----------------------------------------------------------------------===//
// UnrankedMemRefType

/// Unranked MemRef type represent multi-dimensional MemRefs that
/// have an unknown rank.
class UnrankedMemRefType
: public Type::TypeBase<UnrankedMemRefType, BaseMemRefType,
detail::UnrankedMemRefTypeStorage> {
public:
using Base::Base;
using Base::getChecked;

/// Get or create a new UnrankedMemRefType of the provided element
/// type and memory space
static UnrankedMemRefType get(Type elementType, unsigned memorySpace);

/// Get or create a new UnrankedMemRefType of the provided element
/// type and memory space. If the UnrankedMemRefType defined by the arguments
/// would be ill-formed, an error is emitted to `emitError` and a null type is
/// returned.
static UnrankedMemRefType
getChecked(function_ref<InFlightDiagnostic()> emitError, Type elementType,
unsigned memorySpace);

/// Verify the construction of a unranked memref type.
static LogicalResult verify(function_ref<InFlightDiagnostic()> emitError,
Type elementType, unsigned memorySpace);

ArrayRef<int64_t> getShape() const { return llvm::None; }
};
} // end namespace mlir

//===----------------------------------------------------------------------===//
// Tablegen Type Declarations
//===----------------------------------------------------------------------===//

#define GET_TYPEDEF_CLASSES
#include "mlir/IR/BuiltinTypes.h.inc"

//===----------------------------------------------------------------------===//		//===----------------------------------------------------------------------===//
// Deferred Method Definitions		// Deferred Method Definitions
//===----------------------------------------------------------------------===//		//===----------------------------------------------------------------------===//

namespace mlir {
inline bool BaseMemRefType::classof(Type type) {		inline bool BaseMemRefType::classof(Type type) {
return type.isa<MemRefType, UnrankedMemRefType>();		return type.isa<MemRefType, UnrankedMemRefType>();
}		}

inline bool BaseMemRefType::isValidElementType(Type type) {		inline bool BaseMemRefType::isValidElementType(Type type) {
return type.isIntOrIndexOrFloat() \|\| type.isa<ComplexType, VectorType>();		return type.isIntOrIndexOrFloat() \|\| type.isa<ComplexType, VectorType>();
}		}

▲ Show 20 Lines • Show All 133 Lines • Show Last 20 Lines

mlir/include/mlir/IR/BuiltinTypes.td

Show All 15 Lines

include "mlir/IR/BuiltinDialect.td"		include "mlir/IR/BuiltinDialect.td"

// TODO: Currently the types defined in this file are prefixed with `Builtin_`.		// TODO: Currently the types defined in this file are prefixed with `Builtin_`.
// This is to differentiate the types here with the ones in OpBase.td. We should		// This is to differentiate the types here with the ones in OpBase.td. We should
// remove the definitions in OpBase.td, and repoint users to this file instead.		// remove the definitions in OpBase.td, and repoint users to this file instead.

// Base class for Builtin dialect types.		// Base class for Builtin dialect types.
class Builtin_Type<string name> : TypeDef<Builtin_Dialect, name> {		class Builtin_Type<string name, string baseCppClass = "::mlir::Type">
		: TypeDef<Builtin_Dialect, name, baseCppClass> {
let mnemonic = ?;		let mnemonic = ?;
}		}

//===----------------------------------------------------------------------===//		//===----------------------------------------------------------------------===//
// ComplexType		// ComplexType
//===----------------------------------------------------------------------===//		//===----------------------------------------------------------------------===//

def Builtin_Complex : Builtin_Type<"Complex"> {		def Builtin_Complex : Builtin_Type<"Complex"> {
▲ Show 20 Lines • Show All 213 Lines • ▼ Show 20 Lines	let extraClassDeclaration = [{

/// Integer representation maximal bitwidth.		/// Integer representation maximal bitwidth.
/// Note: This is aligned with the maximum width of llvm::IntegerType.		/// Note: This is aligned with the maximum width of llvm::IntegerType.
static constexpr unsigned kMaxWidth = (1 << 24) - 1;		static constexpr unsigned kMaxWidth = (1 << 24) - 1;
}];		}];
}		}

//===----------------------------------------------------------------------===//		//===----------------------------------------------------------------------===//
		// MemRefType
		//===----------------------------------------------------------------------===//

		def Builtin_MemRef : Builtin_Type<"MemRef", "BaseMemRefType"> {
		let summary = "Shaped reference to a region of memory";
		let description = [{
		Syntax:

		```
		memref-type ::= `memref` `<` dimension-list-ranked type
		(`,` layout-specification)? (`,` memory-space)? `>`

		stride-list ::= `[` (dimension (`,` dimension)*)? `]`
		strided-layout ::= `offset:` dimension `,` `strides: ` stride-list
		semi-affine-map-composition ::= (semi-affine-map `,` )* semi-affine-map
		layout-specification ::= semi-affine-map-composition \| strided-layout
		memory-space ::= integer-literal /* \| TODO: address-space-id */
		```

		A `memref` type is a reference to a region of memory (similar to a buffer
		pointer, but more powerful). The buffer pointed to by a memref can be
		allocated, aliased and deallocated. A memref can be used to read and write
		data from/to the memory region which it references. Memref types use the
		same shape specifier as tensor types. Note that `memref<f32>`,
		`memref<0 x f32>`, `memref<1 x 0 x f32>`, and `memref<0 x 1 x f32>` are all
		different types.

		A `memref` is allowed to have an unknown rank (e.g. `memref<*xf32>`). The
		purpose of unranked memrefs is to allow external library functions to
		receive memref arguments of any rank without versioning the functions based
		on the rank. Other uses of this type are disallowed or will have undefined
		behavior.

		##### Codegen of Unranked Memref

		Using unranked memref in codegen besides the case mentioned above is highly
		discouraged. Codegen is concerned with generating loop nests and specialized
		instructions for high-performance, unranked memref is concerned with hiding
		the rank and thus, the number of enclosing loops required to iterate over
		the data. However, if there is a need to code-gen unranked memref, one
		possible path is to cast into a static ranked type based on the dynamic
		rank. Another possible path is to emit a single while loop conditioned on a
		linear index and perform delinearization of the linear index to a dynamic
		array containing the (unranked) indices. While this is possible, it is
		expected to not be a good idea to perform this during codegen as the cost
		of the translations is expected to be prohibitive and optimizations at this
		level are not expected to be worthwhile. If expressiveness is the main
		concern, irrespective of performance, passing unranked memrefs to an
		external C++ library and implementing rank-agnostic logic there is expected
		to be significantly simpler.

		Unranked memrefs may provide expressiveness gains in the future and help
		bridge the gap with unranked tensors. Unranked memrefs will not be expected
		to be exposed to codegen but one may query the rank of an unranked memref
		(a special op will be needed for this purpose) and perform a switch and cast
		to a ranked memref as a prerequisite to codegen.

		Example:

		```mlir
		// With static ranks, we need a function for each possible argument type
		%A = alloc() : memref<16x32xf32>
		%B = alloc() : memref<16x32x64xf32>
		call @helper_2D(%A) : (memref<16x32xf32>)->()
		call @helper_3D(%B) : (memref<16x32x64xf32>)->()

		// With unknown rank, the functions can be unified under one unranked type
		%A = alloc() : memref<16x32xf32>
		%B = alloc() : memref<16x32x64xf32>
		// Remove rank info
		%A_u = memref_cast %A : memref<16x32xf32> -> memref<*xf32>
		%B_u = memref_cast %B : memref<16x32x64xf32> -> memref<*xf32>
		// call same function with dynamic ranks
		call @helper(%A_u) : (memref<*xf32>)->()
		call @helper(%B_u) : (memref<*xf32>)->()
		```

		The core syntax and representation of a layout specification is a
		[semi-affine map](Dialects/Affine.md#semi-affine-maps). Additionally,
		syntactic sugar is supported to make certain layout specifications more
		intuitive to read. For the moment, a `memref` supports parsing a strided
		form which is converted to a semi-affine map automatically.

		The memory space of a memref is specified by a target-specific integer
		index. If no memory space is specified, then the default memory space (0)
		is used. The default space is target specific but always at index 0.

		TODO: MLIR will eventually have target-dialects which allow symbolic use of
		memory hierarchy names (e.g. L3, L2, L1, ...) but we have not spec'd the
		details of that mechanism yet. Until then, this document pretends that it
		is valid to refer to these memories by `bare-id`.

		The notionally dynamic value of a memref value includes the address of the
		buffer allocated, as well as the symbols referred to by the shape, layout
		map, and index maps.

		Examples of memref static type

		```mlir
		// Identity index/layout map
		#identity = affine_map<(d0, d1) -> (d0, d1)>

		// Column major layout.
		#col_major = affine_map<(d0, d1, d2) -> (d2, d1, d0)>

		// A 2-d tiled layout with tiles of size 128 x 256.
		#tiled_2d_128x256 = affine_map<(d0, d1) -> (d0 div 128, d1 div 256, d0 mod 128, d1 mod 256)>

		// A tiled data layout with non-constant tile sizes.
		#tiled_dynamic = affine_map<(d0, d1)[s0, s1] -> (d0 floordiv s0, d1 floordiv s1,
		d0 mod s0, d1 mod s1)>

		// A layout that yields a padding on two at either end of the minor dimension.
		#padded = affine_map<(d0, d1) -> (d0, (d1 + 2) floordiv 2, (d1 + 2) mod 2)>


		// The dimension list "16x32" defines the following 2D index space:
		//
		// { (i, j) : 0 <= i < 16, 0 <= j < 32 }
		//
		memref<16x32xf32, #identity>

		// The dimension list "16x4x?" defines the following 3D index space:
		//
		// { (i, j, k) : 0 <= i < 16, 0 <= j < 4, 0 <= k < N }
		//
		// where N is a symbol which represents the runtime value of the size of
		// the third dimension.
		//
		// %N here binds to the size of the third dimension.
		%A = alloc(%N) : memref<16x4x?xf32, #col_major>

		// A 2-d dynamic shaped memref that also has a dynamically sized tiled
		// layout. The memref index space is of size %M x %N, while %B1 and %B2
		// bind to the symbols s0, s1 respectively of the layout map #tiled_dynamic.
		// Data tiles of size %B1 x %B2 in the logical space will be stored
		// contiguously in memory. The allocation size will be
		// (%M ceildiv %B1) * %B1 * (%N ceildiv %B2) * %B2 f32 elements.
		%T = alloc(%M, %N) [%B1, %B2] : memref<?x?xf32, #tiled_dynamic>

		// A memref that has a two-element padding at either end. The allocation
		// size will fit 16 * 64 float elements of data.
		%P = alloc() : memref<16x64xf32, #padded>

		// Affine map with symbol 's0' used as offset for the first dimension.
		#imapS = affine_map<(d0, d1) [s0] -> (d0 + s0, d1)>
		// Allocate memref and bind the following symbols:
		// '%n' is bound to the dynamic second dimension of the memref type.
		// '%o' is bound to the symbol 's0' in the affine map of the memref type.
		%n = ...
		%o = ...
		%A = alloc (%n)[%o] : <16x?xf32, #imapS>
		```

		##### Index Space

		A memref dimension list defines an index space within which the memref can
		be indexed to access data.

		##### Index

		Data is accessed through a memref type using a multidimensional index into
		the multidimensional index space defined by the memref's dimension list.

		Examples

		```mlir
		// Allocates a memref with 2D index space:
		// { (i, j) : 0 <= i < 16, 0 <= j < 32 }
		%A = alloc() : memref<16x32xf32, #imapA>

		// Loads data from memref '%A' using a 2D index: (%i, %j)
		%v = load %A[%i, %j] : memref<16x32xf32, #imapA>
		```

		##### Index Map

		An index map is a one-to-one
		[semi-affine map](Dialects/Affine.md#semi-affine-maps) that transforms a
		multidimensional index from one index space to another. For example, the
		following figure shows an index map which maps a 2-dimensional index from a
		2x2 index space to a 3x3 index space, using symbols `S0` and `S1` as
		offsets.

		![Index Map Example](/includes/img/index-map.svg)

		The number of domain dimensions and range dimensions of an index map can be
		different, but must match the number of dimensions of the input and output
		index spaces on which the map operates. The index space is always
		non-negative and integral. In addition, an index map must specify the size
		of each of its range dimensions onto which it maps. Index map symbols must
		be listed in order with symbols for dynamic dimension sizes first, followed
		by other required symbols.

		##### Layout Map

		A layout map is a [semi-affine map](Dialects/Affine.md#semi-affine-maps)
		which encodes logical to physical index space mapping, by mapping input
		dimensions to their ordering from most-major (slowest varying) to most-minor
		(fastest varying). Therefore, an identity layout map corresponds to a
		row-major layout. Identity layout maps do not contribute to the MemRef type
		identification and are discarded on construction. That is, a type with an
		explicit identity map is `memref<?x?xf32, (i,j)->(i,j)>` is strictly the
		same as the one without layout maps, `memref<?x?xf32>`.

		Layout map examples:

		```mlir
		// MxN matrix stored in row major layout in memory:
		#layout_map_row_major = (i, j) -> (i, j)

		// MxN matrix stored in column major layout in memory:
		#layout_map_col_major = (i, j) -> (j, i)

		// MxN matrix stored in a 2-d blocked/tiled layout with 64x64 tiles.
		#layout_tiled = (i, j) -> (i floordiv 64, j floordiv 64, i mod 64, j mod 64)
		```

		##### Affine Map Composition

		A memref specifies a semi-affine map composition as part of its type. A
		semi-affine map composition is a composition of semi-affine maps beginning
		with zero or more index maps, and ending with a layout map. The composition
		must be conformant: the number of dimensions of the range of one map, must
		match the number of dimensions of the domain of the next map in the
		composition.

		The semi-affine map composition specified in the memref type, maps from
		accesses used to index the memref in load/store operations to other index
		spaces (i.e. logical to physical index mapping). Each of the
		[semi-affine maps](Affine.md) and thus its composition is required
		to be one-to-one.

		The semi-affine map composition can be used in dependence analysis, memory
		access pattern analysis, and for performance optimizations like
		vectorization, copy elision and in-place updates. If an affine map
		composition is not specified for the memref, the identity affine map is
		assumed.

		##### Strided MemRef

		A memref may specify strides as part of its type. A stride specification is
		a list of integer values that are either static or `?` (dynamic case).
		Strides encode the distance, in number of elements, in (linear) memory
		between successive entries along a particular dimension. A stride
		specification is syntactic sugar for an equivalent strided memref
		representation using semi-affine maps. For example,
		`memref<42x16xf32, offset: 33, strides: [1, 64]>` specifies a non-contiguous
		memory region of `42` by `16` `f32` elements such that:

		1. the minimal size of the enclosing memory region must be
		`33 + 42 * 1 + 16 * 64 = 1066` elements;
		2. the address calculation for accessing element `(i, j)` computes
		`33 + i + 64 * j`
		3. the distance between two consecutive elements along the inner dimension
		is `1` element and the distance between two consecutive elements along
		the outer dimension is `64` elements.

		This corresponds to a column major view of the memory region and is
		internally represented as the type
		`memref<42x16xf32, (i, j) -> (33 + i + 64 * j)>`.

		The specification of strides must not alias: given an n-D strided memref,
		indices `(i1, ..., in)` and `(j1, ..., jn)` may not refer to the same memory
		address unless `i1 == j1, ..., in == jn`.

		Strided memrefs represent a view abstraction over preallocated data. They
		are constructed with special ops, yet to be introduced. Strided memrefs are
		a special subclass of memrefs with generic semi-affine map and correspond to
		a normalized memref descriptor when lowering to LLVM.
		}];
		let parameters = (ins
		ArrayRefParameter<"int64_t">:$shape,
		"Type":$elementType,
		ArrayRefParameter<"AffineMap">:$affineMaps,
		"unsigned":$memorySpaceAsInt
		);

		let builders = [
		TypeBuilderWithInferredContext<(ins
		"ArrayRef<int64_t>":$shape, "Type":$elementType,
		CArg<"ArrayRef<AffineMap>", "{}">:$affineMaps,
		CArg<"unsigned", "0">:$memorySpace
		), [{
		// Drop identity maps from the composition. This may lead to the
		// composition becoming empty, which is interpreted as an implicit
		// identity.
		auto nonIdentityMaps = llvm::make_filter_range(affineMaps,
		[](AffineMap map) { return !map.isIdentity(); });
		return $_get(elementType.getContext(), shape, elementType,
		llvm::to_vector<4>(nonIdentityMaps), memorySpace);
		}]>
		];
		let extraClassDeclaration = [{
		/// This is a builder type that keeps local references to arguments.
		/// Arguments that are passed into the builder must out-live the builder.
		class Builder;

		// TODO: merge these two special values in a single one used everywhere.
		// Unfortunately, uses of `-1` have crept deep into the codebase now and are
		// hard to track.
		static int64_t getDynamicStrideOrOffset() {
		return ShapedType::kDynamicStrideOrOffset;
		}
		}];
		let skipDefaultBuilders = 1;
		let genVerifyDecl = 1;
		}

		//===----------------------------------------------------------------------===//
// NoneType		// NoneType
//===----------------------------------------------------------------------===//		//===----------------------------------------------------------------------===//

def Builtin_None : Builtin_Type<"None"> {		def Builtin_None : Builtin_Type<"None"> {
let summary = "A unit type";		let summary = "A unit type";
let description = [{		let description = [{
NoneType is a unit type, i.e. a type with exactly one possible value, where		NoneType is a unit type, i.e. a type with exactly one possible value, where
its value does not have a defined dynamic representation.		its value does not have a defined dynamic representation.
Show All 39 Lines	), [{
return $_get(dialectNamespace.getContext(), dialectNamespace, typeData);		return $_get(dialectNamespace.getContext(), dialectNamespace, typeData);
}]>		}]>
];		];
let skipDefaultBuilders = 1;		let skipDefaultBuilders = 1;
let genVerifyDecl = 1;		let genVerifyDecl = 1;
}		}

//===----------------------------------------------------------------------===//		//===----------------------------------------------------------------------===//
		// RankedTensorType
		//===----------------------------------------------------------------------===//

		def Builtin_RankedTensor : Builtin_Type<"RankedTensor", "TensorType"> {
		let summary = "Multi-dimensional array with a fixed number of dimensions";
		let description = [{
		Syntax:

		```
		tensor-type ::= `tensor` `<` dimension-list type `>`
		dimension-list ::= (dimension `x`)*
		dimension ::= `?` \| decimal-literal
		```

		Values with tensor type represents aggregate N-dimensional data values, and
		have a known element type and a fixed rank with a list of dimensions. Each
		dimension may be a static non-negative decimal constant or be dynamically
		determined (indicated by `?`).

		The runtime representation of the MLIR tensor type is intentionally
		abstracted - you cannot control layout or get a pointer to the data. For
		low level buffer access, MLIR has a [`memref` type](#memref-type). This
		abstracted runtime representation holds both the tensor data values as well
		as information about the (potentially dynamic) shape of the tensor. The
		[`dim` operation](Dialects/Standard.md#dim-operation) returns the size of a
		dimension from a value of tensor type.

		Note: hexadecimal integer literals are not allowed in tensor type
		declarations to avoid confusion between `0xf32` and `0 x f32`. Zero sizes
		are allowed in tensors and treated as other sizes, e.g.,
		`tensor<0 x 1 x i32>` and `tensor<1 x 0 x i32>` are different types. Since
		zero sizes are not allowed in some other types, such tensors should be
		optimized away before lowering tensors to vectors.

		Examples:

		```mlir
		// Known rank but unknown dimensions.
		tensor<? x ? x ? x ? x f32>

		// Partially known dimensions.
		tensor<? x ? x 13 x ? x f32>

		// Full static shape.
		tensor<17 x 4 x 13 x 4 x f32>

		// Tensor with rank zero. Represents a scalar.
		tensor<f32>

		// Zero-element dimensions are allowed.
		tensor<0 x 42 x f32>

		// Zero-element tensor of f32 type (hexadecimal literals not allowed here).
		tensor<0xf32>
		```
		}];
		let parameters = (ins
		ArrayRefParameter<"int64_t">:$shape,
		"Type":$elementType
		);

		let builders = [
		TypeBuilderWithInferredContext<(ins
		"ArrayRef<int64_t>":$shape, "Type":$elementType
		), [{
		return $_get(elementType.getContext(), shape, elementType);
		}]>
		];
		let skipDefaultBuilders = 1;
		let genVerifyDecl = 1;
		}

		//===----------------------------------------------------------------------===//
// TupleType		// TupleType
//===----------------------------------------------------------------------===//		//===----------------------------------------------------------------------===//

def Builtin_Tuple : Builtin_Type<"Tuple"> {		def Builtin_Tuple : Builtin_Type<"Tuple"> {
let summary = "Fixed-sized collection of other types";		let summary = "Fixed-sized collection of other types";
let description = [{		let description = [{
Syntax:		Syntax:

▲ Show 20 Lines • Show All 50 Lines • ▼ Show 20 Lines	let extraClassDeclaration = [{
/// Return the element type at index 'index'.		/// Return the element type at index 'index'.
Type getType(size_t index) const {		Type getType(size_t index) const {
assert(index < size() && "invalid index for tuple type");		assert(index < size() && "invalid index for tuple type");
return getTypes()[index];		return getTypes()[index];
}		}
}];		}];
}		}

		//===----------------------------------------------------------------------===//
		// UnrankedMemRefType
		//===----------------------------------------------------------------------===//

		def Builtin_UnrankedMemRef : Builtin_Type<"UnrankedMemRef", "BaseMemRefType"> {
		let summary = "Shaped reference, with unknown rank, to a region of memory";
		let description = [{
		Syntax:

		```
		unranked-memref-type ::= `memref` `<*x` type (`,` memory-space)? `>`
		memory-space ::= integer-literal /* \| TODO: address-space-id */
		```

		A `memref` type with an unknown rank (e.g. `memref<*xf32>`). The purpose of
		unranked memrefs is to allow external library functions to receive memref
		arguments of any rank without versioning the functions based on the rank.
		Other uses of this type are disallowed or will have undefined behavior.

		See [MemRefType](#builtin_memref-memreftype) for more information on
		memref types.

		Examples:

		```mlir
		memref<*f32>

		// An unranked memref with a memory space of 10.
		memref<*f32, 10>
		```
		}];
		let parameters = (ins "Type":$elementType, "unsigned":$memorySpaceAsInt);

		let builders = [
		TypeBuilderWithInferredContext<(ins "Type":$elementType,
		"unsigned":$memorySpace), [{
		return $_get(elementType.getContext(), elementType, memorySpace);
		}]>
		];
		let extraClassDeclaration = [{
		ArrayRef<int64_t> getShape() const { return llvm::None; }
		}];
		let skipDefaultBuilders = 1;
		let genVerifyDecl = 1;
		}

		//===----------------------------------------------------------------------===//
		// UnrankedTensorType
		//===----------------------------------------------------------------------===//

		def Builtin_UnrankedTensor : Builtin_Type<"UnrankedTensor", "TensorType"> {
		let summary = "Multi-dimensional array with unknown dimensions";
		let description = [{
		Syntax:

		```
		tensor-type ::= `tensor` `<` `*` `x` type `>`
		```

		An unranked tensor is a type of tensor in which the set of dimensions have
		unknown rank. See [RankedTensorType](#builtin_rankedtensor-rankedtensortype)
		for more information on tensor types.

		Examples:

		```mlir
		tensor<*f32>
		```
		}];
		let parameters = (ins "Type":$elementType);

		let builders = [
		TypeBuilderWithInferredContext<(ins "Type":$elementType), [{
		return $_get(elementType.getContext(), elementType);
		}]>
		];
		let extraClassDeclaration = [{
		ArrayRef<int64_t> getShape() const { return llvm::None; }
		}];
		let skipDefaultBuilders = 1;
		let genVerifyDecl = 1;
		}

		//===----------------------------------------------------------------------===//
		// VectorType
		//===----------------------------------------------------------------------===//

		def Builtin_Vector : Builtin_Type<"Vector", "ShapedType"> {
		let summary = "Multi-dimensional SIMD vector type";
		let description = [{
		Syntax:

		```
		vector-type ::= `vector` `<` static-dimension-list vector-element-type `>`
		vector-element-type ::= float-type \| integer-type

		static-dimension-list ::= (decimal-literal `x`)+
		```

		The vector type represents a SIMD style vector, used by target-specific
		operation sets like AVX. While the most common use is for 1D vectors (e.g.
		vector<16 x f32>) we also support multidimensional registers on targets that
		support them (like TPUs).

		Vector shapes must be positive decimal integers.

		Note: hexadecimal integer literals are not allowed in vector type
		declarations, `vector<0x42xi32>` is invalid because it is interpreted as a
		2D vector with shape `(0, 42)` and zero shapes are not allowed.


		Examples:

		```mlir
		vector<3x42xi32>
		```
		}];
		let parameters = (ins
		ArrayRefParameter<"int64_t">:$shape,
		"Type":$elementType
		);

		let builders = [
		TypeBuilderWithInferredContext<(ins
		"ArrayRef<int64_t>":$shape, "Type":$elementType
		), [{
		return $_get(elementType.getContext(), shape, elementType);
		}]>
		];
		let extraClassDeclaration = [{
		/// Returns true of the given type can be used as an element of a vector
		/// type. In particular, vectors can consist of integer or float primitives.
		static bool isValidElementType(Type t) {
		return t.isa<IntegerType, FloatType>();
		}

		/// Get or create a new VectorType with the same shape as `this` and an
		/// element type of bitwidth scaled by `scale`.
		/// Return null if the scaled element type cannot be represented.
		VectorType scaleElementBitwidth(unsigned scale);
		}];
		let skipDefaultBuilders = 1;
		let genVerifyDecl = 1;
		}

#endif // BUILTIN_TYPES		#endif // BUILTIN_TYPES

mlir/include/mlir/IR/OpBase.td

Show First 20 Lines • Show All 2,678 Lines • ▼ Show 20 Lines	class AttrOrTypeParameter<string type, string desc> {
string summary = desc;		string summary = desc;
// The format string for the asm syntax (documentation only).		// The format string for the asm syntax (documentation only).
string syntax = ?;		string syntax = ?;
}		}
class AttrParameter<string type, string desc> : AttrOrTypeParameter<type, desc>;		class AttrParameter<string type, string desc> : AttrOrTypeParameter<type, desc>;
class TypeParameter<string type, string desc> : AttrOrTypeParameter<type, desc>;		class TypeParameter<string type, string desc> : AttrOrTypeParameter<type, desc>;

// For StringRefs, which require allocation.		// For StringRefs, which require allocation.
class StringRefParameter<string desc> :		class StringRefParameter<string desc = ""> :
AttrOrTypeParameter<"::llvm::StringRef", desc> {		AttrOrTypeParameter<"::llvm::StringRef", desc> {
let allocator = [{$_dst = $_allocator.copyInto($_self);}];		let allocator = [{$_dst = $_allocator.copyInto($_self);}];
}		}

// For standard ArrayRefs, which require allocation.		// For standard ArrayRefs, which require allocation.
class ArrayRefParameter<string arrayOf, string desc> :		class ArrayRefParameter<string arrayOf, string desc = ""> :
AttrOrTypeParameter<"::llvm::ArrayRef<" # arrayOf # ">", desc> {		AttrOrTypeParameter<"::llvm::ArrayRef<" # arrayOf # ">", desc> {
let allocator = [{$_dst = $_allocator.copyInto($_self);}];		let allocator = [{$_dst = $_allocator.copyInto($_self);}];
}		}

// For classes which require allocation and have their own allocateInto method.		// For classes which require allocation and have their own allocateInto method.
class SelfAllocationParameter<string type, string desc> :		class SelfAllocationParameter<string type, string desc> :
AttrOrTypeParameter<type, desc> {		AttrOrTypeParameter<type, desc> {
let allocator = [{$_dst = $_self.allocateInto($_allocator);}];		let allocator = [{$_dst = $_self.allocateInto($_allocator);}];
Show All 20 Lines

mlir/lib/IR/BuiltinTypes.cpp

Show All 10 Lines
#include "mlir/IR/AffineExpr.h"		#include "mlir/IR/AffineExpr.h"
#include "mlir/IR/AffineMap.h"		#include "mlir/IR/AffineMap.h"
#include "mlir/IR/Diagnostics.h"		#include "mlir/IR/Diagnostics.h"
#include "mlir/IR/Dialect.h"		#include "mlir/IR/Dialect.h"
#include "llvm/ADT/APFloat.h"		#include "llvm/ADT/APFloat.h"
#include "llvm/ADT/BitVector.h"		#include "llvm/ADT/BitVector.h"
#include "llvm/ADT/Sequence.h"		#include "llvm/ADT/Sequence.h"
#include "llvm/ADT/Twine.h"		#include "llvm/ADT/Twine.h"
		#include "llvm/ADT/TypeSwitch.h"

using namespace mlir;		using namespace mlir;
using namespace mlir::detail;		using namespace mlir::detail;

//===----------------------------------------------------------------------===//		//===----------------------------------------------------------------------===//
/// Tablegen Type Definitions		/// Tablegen Type Definitions
//===----------------------------------------------------------------------===//		//===----------------------------------------------------------------------===//

▲ Show 20 Lines • Show All 234 Lines • ▼ Show 20 Lines	ShapedType ShapedType::clone(Type elementType) {

if (isa<VectorType>())		if (isa<VectorType>())
return VectorType::get(getShape(), elementType);		return VectorType::get(getShape(), elementType);

llvm_unreachable("Unhandled ShapedType clone hit");		llvm_unreachable("Unhandled ShapedType clone hit");
}		}

Type ShapedType::getElementType() const {		Type ShapedType::getElementType() const {
return static_cast<ImplType *>(impl)->elementType;		return TypeSwitch<Type, Type>(*this)
		.Case<VectorType, RankedTensorType, UnrankedTensorType, MemRefType,
		UnrankedMemRefType>([](auto ty) { return ty.getElementType(); });
}		}

unsigned ShapedType::getElementTypeBitWidth() const {		unsigned ShapedType::getElementTypeBitWidth() const {
return getElementType().getIntOrFloatBitWidth();		return getElementType().getIntOrFloatBitWidth();
}		}

int64_t ShapedType::getNumElements() const {		int64_t ShapedType::getNumElements() const {
assert(hasStaticShape() && "cannot get element count of dynamic shaped type");		assert(hasStaticShape() && "cannot get element count of dynamic shaped type");
▲ Show 20 Lines • Show All 74 Lines • ▼ Show 20 Lines
bool ShapedType::hasStaticShape(ArrayRef<int64_t> shape) const {		bool ShapedType::hasStaticShape(ArrayRef<int64_t> shape) const {
return hasStaticShape() && getShape() == shape;		return hasStaticShape() && getShape() == shape;
}		}

//===----------------------------------------------------------------------===//		//===----------------------------------------------------------------------===//
// VectorType		// VectorType
//===----------------------------------------------------------------------===//		//===----------------------------------------------------------------------===//

VectorType VectorType::get(ArrayRef<int64_t> shape, Type elementType) {
return Base::get(elementType.getContext(), shape, elementType);
}

VectorType VectorType::getChecked(function_ref<InFlightDiagnostic()> emitError,
ArrayRef<int64_t> shape, Type elementType) {
return Base::getChecked(emitError, elementType.getContext(), shape,
elementType);
}

LogicalResult VectorType::verify(function_ref<InFlightDiagnostic()> emitError,		LogicalResult VectorType::verify(function_ref<InFlightDiagnostic()> emitError,
ArrayRef<int64_t> shape, Type elementType) {		ArrayRef<int64_t> shape, Type elementType) {
if (shape.empty())		if (shape.empty())
return emitError() << "vector types must have at least one dimension";		return emitError() << "vector types must have at least one dimension";

if (!isValidElementType(elementType))		if (!isValidElementType(elementType))
return emitError() << "vector elements must be int or float type";		return emitError() << "vector elements must be int or float type";

if (any_of(shape, [](int64_t i) { return i <= 0; }))		if (any_of(shape, [](int64_t i) { return i <= 0; }))
return emitError() << "vector types must have positive constant sizes";		return emitError() << "vector types must have positive constant sizes";

return success();		return success();
}		}

ArrayRef<int64_t> VectorType::getShape() const { return getImpl()->getShape(); }

VectorType VectorType::scaleElementBitwidth(unsigned scale) {		VectorType VectorType::scaleElementBitwidth(unsigned scale) {
if (!scale)		if (!scale)
return VectorType();		return VectorType();
if (auto et = getElementType().dyn_cast<IntegerType>())		if (auto et = getElementType().dyn_cast<IntegerType>())
if (auto scaledEt = et.scaleElementBitwidth(scale))		if (auto scaledEt = et.scaleElementBitwidth(scale))
return VectorType::get(getShape(), scaledEt);		return VectorType::get(getShape(), scaledEt);
if (auto et = getElementType().dyn_cast<FloatType>())		if (auto et = getElementType().dyn_cast<FloatType>())
if (auto scaledEt = et.scaleElementBitwidth(scale))		if (auto scaledEt = et.scaleElementBitwidth(scale))
Show All 23 Lines	return type.isa<ComplexType, FloatType, IntegerType, OpaqueType, VectorType,
IndexType>() \|\|		IndexType>() \|\|
!type.getDialect().getNamespace().empty();		!type.getDialect().getNamespace().empty();
}		}

//===----------------------------------------------------------------------===//		//===----------------------------------------------------------------------===//
// RankedTensorType		// RankedTensorType
//===----------------------------------------------------------------------===//		//===----------------------------------------------------------------------===//

RankedTensorType RankedTensorType::get(ArrayRef<int64_t> shape,
Type elementType) {
return Base::get(elementType.getContext(), shape, elementType);
}

RankedTensorType
RankedTensorType::getChecked(function_ref<InFlightDiagnostic()> emitError,
ArrayRef<int64_t> shape, Type elementType) {
return Base::getChecked(emitError, elementType.getContext(), shape,
elementType);
}

LogicalResult		LogicalResult
RankedTensorType::verify(function_ref<InFlightDiagnostic()> emitError,		RankedTensorType::verify(function_ref<InFlightDiagnostic()> emitError,
ArrayRef<int64_t> shape, Type elementType) {		ArrayRef<int64_t> shape, Type elementType) {
for (int64_t s : shape) {		for (int64_t s : shape)
if (s < -1)		if (s < -1)
return emitError() << "invalid tensor dimension size";		return emitError() << "invalid tensor dimension size";
}
return checkTensorElementType(emitError, elementType);		return checkTensorElementType(emitError, elementType);
}		}

ArrayRef<int64_t> RankedTensorType::getShape() const {
return getImpl()->getShape();
}

//===----------------------------------------------------------------------===//		//===----------------------------------------------------------------------===//
// UnrankedTensorType		// UnrankedTensorType
//===----------------------------------------------------------------------===//		//===----------------------------------------------------------------------===//

UnrankedTensorType UnrankedTensorType::get(Type elementType) {
return Base::get(elementType.getContext(), elementType);
}

UnrankedTensorType
UnrankedTensorType::getChecked(function_ref<InFlightDiagnostic()> emitError,
Type elementType) {
return Base::getChecked(emitError, elementType.getContext(), elementType);
}

LogicalResult		LogicalResult
UnrankedTensorType::verify(function_ref<InFlightDiagnostic()> emitError,		UnrankedTensorType::verify(function_ref<InFlightDiagnostic()> emitError,
Type elementType) {		Type elementType) {
return checkTensorElementType(emitError, elementType);		return checkTensorElementType(emitError, elementType);
}		}

//===----------------------------------------------------------------------===//		//===----------------------------------------------------------------------===//
// BaseMemRefType		// BaseMemRefType
//===----------------------------------------------------------------------===//		//===----------------------------------------------------------------------===//

unsigned BaseMemRefType::getMemorySpaceAsInt() const {		unsigned BaseMemRefType::getMemorySpaceAsInt() const {
return static_cast<ImplType *>(impl)->memorySpace;		if (auto rankedMemRefTy = dyn_cast<MemRefType>())
		return rankedMemRefTy.getMemorySpaceAsInt();
		return cast<UnrankedMemRefType>().getMemorySpaceAsInt();
}		}

//===----------------------------------------------------------------------===//		//===----------------------------------------------------------------------===//
// MemRefType		// MemRefType
//===----------------------------------------------------------------------===//		//===----------------------------------------------------------------------===//

/// Get or create a new MemRefType based on shape, element type, affine		LogicalResult MemRefType::verify(function_ref<InFlightDiagnostic()> emitError,
/// map composition, and memory space. Assumes the arguments define a
/// well-formed MemRef type. Use getChecked to gracefully handle MemRefType
/// construction failures.
MemRefType MemRefType::get(ArrayRef<int64_t> shape, Type elementType,
ArrayRef<AffineMap> affineMapComposition,
unsigned memorySpace) {
auto result =
getImpl(shape, elementType, affineMapComposition, memorySpace, [=] {
return emitError(UnknownLoc::get(elementType.getContext()));
});
assert(result && "Failed to construct instance of MemRefType.");
return result;
}

/// Get or create a new MemRefType based on shape, element type, affine
/// map composition, and memory space declared at the given location.
/// If the location is unknown, the last argument should be an instance of
/// UnknownLoc. If the MemRefType defined by the arguments would be
/// ill-formed, emits errors (to the handler registered with the context or to
/// the error stream) and returns nullptr.
MemRefType MemRefType::getChecked(function_ref<InFlightDiagnostic()> emitError,
ArrayRef<int64_t> shape, Type elementType,		ArrayRef<int64_t> shape, Type elementType,
ArrayRef<AffineMap> affineMapComposition,		ArrayRef<AffineMap> affineMapComposition,
unsigned memorySpace) {		unsigned memorySpace) {
return getImpl(shape, elementType, affineMapComposition, memorySpace,
emitError);
}

/// Get or create a new MemRefType defined by the arguments. If the resulting
/// type would be ill-formed, return nullptr. If the location is provided,
/// emit detailed error messages. To emit errors when the location is unknown,
/// pass in an instance of UnknownLoc.
MemRefType MemRefType::getImpl(ArrayRef<int64_t> shape, Type elementType,
ArrayRef<AffineMap> affineMapComposition,
unsigned memorySpace,
function_ref<InFlightDiagnostic()> emitError) {
auto *context = elementType.getContext();

if (!BaseMemRefType::isValidElementType(elementType))		if (!BaseMemRefType::isValidElementType(elementType))
return (emitError() << "invalid memref element type", MemRefType());		return emitError() << "invalid memref element type";

for (int64_t s : shape) {
// Negative sizes are not allowed except for `-1` that means dynamic size.		// Negative sizes are not allowed except for `-1` that means dynamic size.
		for (int64_t s : shape)
if (s < -1)		if (s < -1)
return (emitError() << "invalid memref size", MemRefType());		return emitError() << "invalid memref size";
}

// Check that the structure of the composition is valid, i.e. that each		// Check that the structure of the composition is valid, i.e. that each
// subsequent affine map has as many inputs as the previous map has results.		// subsequent affine map has as many inputs as the previous map has results.
// Take the dimensionality of the MemRef for the first map.		// Take the dimensionality of the MemRef for the first map.
auto dim = shape.size();		size_t dim = shape.size();
unsigned i = 0;		for (auto it : llvm::enumerate(affineMapComposition)) {
for (const auto &affineMap : affineMapComposition) {		AffineMap map = it.value();
if (affineMap.getNumDims() != dim) {		if (map.getNumDims() == dim) {
emitError() << "memref affine map dimension mismatch between "		dim = map.getNumResults();
<< (i == 0 ? Twine("memref rank") : "affine map " + Twine(i))
<< " and affine map" << i + 1 << ": " << dim
<< " != " << affineMap.getNumDims();
return nullptr;
}

dim = affineMap.getNumResults();
++i;
}

// Drop identity maps from the composition.
// This may lead to the composition becoming empty, which is interpreted as an
// implicit identity.
SmallVector<AffineMap, 2> cleanedAffineMapComposition;
for (const auto &map : affineMapComposition) {
if (map.isIdentity())
continue;		continue;
cleanedAffineMapComposition.push_back(map);
}		}
		return emitError() << "memref affine map dimension mismatch between "
return Base::get(context, shape, elementType, cleanedAffineMapComposition,		<< (it.index() == 0 ? Twine("memref rank")
memorySpace);		: "affine map " + Twine(it.index()))
		<< " and affine map" << it.index() + 1 << ": " << dim
		<< " != " << map.getNumDims();
}		}
		return success();
ArrayRef<int64_t> MemRefType::getShape() const { return getImpl()->getShape(); }

ArrayRef<AffineMap> MemRefType::getAffineMaps() const {
return getImpl()->getAffineMaps();
}		}

//===----------------------------------------------------------------------===//		//===----------------------------------------------------------------------===//
// UnrankedMemRefType		// UnrankedMemRefType
//===----------------------------------------------------------------------===//		//===----------------------------------------------------------------------===//

UnrankedMemRefType UnrankedMemRefType::get(Type elementType,
unsigned memorySpace) {
return Base::get(elementType.getContext(), elementType, memorySpace);
}

UnrankedMemRefType
UnrankedMemRefType::getChecked(function_ref<InFlightDiagnostic()> emitError,
Type elementType, unsigned memorySpace) {
return Base::getChecked(emitError, elementType.getContext(), elementType,
memorySpace);
}

LogicalResult		LogicalResult
UnrankedMemRefType::verify(function_ref<InFlightDiagnostic()> emitError,		UnrankedMemRefType::verify(function_ref<InFlightDiagnostic()> emitError,
Type elementType, unsigned memorySpace) {		Type elementType, unsigned memorySpace) {
if (!BaseMemRefType::isValidElementType(elementType))		if (!BaseMemRefType::isValidElementType(elementType))
return emitError() << "invalid memref element type";		return emitError() << "invalid memref element type";
return success();		return success();
}		}

▲ Show 20 Lines • Show All 327 Lines • Show Last 20 Lines

mlir/lib/IR/TypeDetail.h

Show All 17 Lines
#include "mlir/IR/MLIRContext.h"		#include "mlir/IR/MLIRContext.h"
#include "mlir/IR/OperationSupport.h"		#include "mlir/IR/OperationSupport.h"
#include "mlir/IR/TypeRange.h"		#include "mlir/IR/TypeRange.h"
#include "llvm/ADT/bit.h"		#include "llvm/ADT/bit.h"
#include "llvm/Support/TrailingObjects.h"		#include "llvm/Support/TrailingObjects.h"

namespace mlir {		namespace mlir {

class MLIRContext;

namespace detail {		namespace detail {

/// Integer Type Storage and Uniquing.		/// Integer Type Storage and Uniquing.
struct IntegerTypeStorage : public TypeStorage {		struct IntegerTypeStorage : public TypeStorage {
IntegerTypeStorage(unsigned width,		IntegerTypeStorage(unsigned width,
IntegerType::SignednessSemantics signedness)		IntegerType::SignednessSemantics signedness)
: width(width), signedness(signedness) {}		: width(width), signedness(signedness) {}

▲ Show 20 Lines • Show All 55 Lines • ▼ Show 20 Lines	ArrayRef<Type> getResults() const {
return ArrayRef<Type>(inputsAndResults + numInputs, numResults);		return ArrayRef<Type>(inputsAndResults + numInputs, numResults);
}		}

unsigned numInputs;		unsigned numInputs;
unsigned numResults;		unsigned numResults;
Type const *inputsAndResults;		Type const *inputsAndResults;
};		};

/// Shaped Type Storage.
struct ShapedTypeStorage : public TypeStorage {
ShapedTypeStorage(Type elementTy) : elementType(elementTy) {}

/// The hash key used for uniquing.
using KeyTy = Type;
bool operator==(const KeyTy &key) const { return key == elementType; }

Type elementType;
};

/// Vector Type Storage and Uniquing.
struct VectorTypeStorage : public ShapedTypeStorage {
VectorTypeStorage(unsigned shapeSize, Type elementTy,
const int64_t *shapeElements)
: ShapedTypeStorage(elementTy), shapeElements(shapeElements),
shapeSize(shapeSize) {}

/// The hash key used for uniquing.
using KeyTy = std::pair<ArrayRef<int64_t>, Type>;
bool operator==(const KeyTy &key) const {
return key == KeyTy(getShape(), elementType);
}

/// Construction.
static VectorTypeStorage *construct(TypeStorageAllocator &allocator,
const KeyTy &key) {
// Copy the shape into the bump pointer.
ArrayRef<int64_t> shape = allocator.copyInto(key.first);

// Initialize the memory using placement new.
return new (allocator.allocate<VectorTypeStorage>())
VectorTypeStorage(shape.size(), key.second, shape.data());
}

ArrayRef<int64_t> getShape() const {
return ArrayRef<int64_t>(shapeElements, shapeSize);
}

const int64_t *shapeElements;
unsigned shapeSize;
};

struct RankedTensorTypeStorage : public ShapedTypeStorage {
RankedTensorTypeStorage(unsigned shapeSize, Type elementTy,
const int64_t *shapeElements)
: ShapedTypeStorage(elementTy), shapeElements(shapeElements),
shapeSize(shapeSize) {}

/// The hash key used for uniquing.
using KeyTy = std::pair<ArrayRef<int64_t>, Type>;
bool operator==(const KeyTy &key) const {
return key == KeyTy(getShape(), elementType);
}

/// Construction.
static RankedTensorTypeStorage *construct(TypeStorageAllocator &allocator,
const KeyTy &key) {
// Copy the shape into the bump pointer.
ArrayRef<int64_t> shape = allocator.copyInto(key.first);

// Initialize the memory using placement new.
return new (allocator.allocate<RankedTensorTypeStorage>())
RankedTensorTypeStorage(shape.size(), key.second, shape.data());
}

ArrayRef<int64_t> getShape() const {
return ArrayRef<int64_t>(shapeElements, shapeSize);
}

const int64_t *shapeElements;
unsigned shapeSize;
};

struct UnrankedTensorTypeStorage : public ShapedTypeStorage {
using ShapedTypeStorage::KeyTy;
using ShapedTypeStorage::ShapedTypeStorage;

/// Construction.
static UnrankedTensorTypeStorage *construct(TypeStorageAllocator &allocator,
Type elementTy) {
return new (allocator.allocate<UnrankedTensorTypeStorage>())
UnrankedTensorTypeStorage(elementTy);
}
};

struct BaseMemRefTypeStorage : public ShapedTypeStorage {
BaseMemRefTypeStorage(Type elementType, unsigned memorySpace)
: ShapedTypeStorage(elementType), memorySpace(memorySpace) {}

/// Memory space in which data referenced by memref resides.
const unsigned memorySpace;
};

struct MemRefTypeStorage : public BaseMemRefTypeStorage {
MemRefTypeStorage(unsigned shapeSize, Type elementType,
const int64_t *shapeElements, const unsigned numAffineMaps,
AffineMap const *affineMapList, const unsigned memorySpace)
: BaseMemRefTypeStorage(elementType, memorySpace),
shapeElements(shapeElements), shapeSize(shapeSize),
numAffineMaps(numAffineMaps), affineMapList(affineMapList) {}

/// The hash key used for uniquing.
// MemRefs are uniqued based on their shape, element type, affine map
// composition, and memory space.
using KeyTy =
std::tuple<ArrayRef<int64_t>, Type, ArrayRef<AffineMap>, unsigned>;
bool operator==(const KeyTy &key) const {
return key == KeyTy(getShape(), elementType, getAffineMaps(), memorySpace);
}

/// Construction.
static MemRefTypeStorage *construct(TypeStorageAllocator &allocator,
const KeyTy &key) {
// Copy the shape into the bump pointer.
ArrayRef<int64_t> shape = allocator.copyInto(std::get<0>(key));

// Copy the affine map composition into the bump pointer.
ArrayRef<AffineMap> affineMapComposition =
allocator.copyInto(std::get<2>(key));

// Initialize the memory using placement new.
return new (allocator.allocate<MemRefTypeStorage>())
MemRefTypeStorage(shape.size(), std::get<1>(key), shape.data(),
affineMapComposition.size(),
affineMapComposition.data(), std::get<3>(key));
}

ArrayRef<int64_t> getShape() const {
return ArrayRef<int64_t>(shapeElements, shapeSize);
}

ArrayRef<AffineMap> getAffineMaps() const {
return ArrayRef<AffineMap>(affineMapList, numAffineMaps);
}

/// An array of integers which stores the shape dimension sizes.
const int64_t *shapeElements;
/// The number of shape elements.
unsigned shapeSize;
/// The number of affine maps in the 'affineMapList' array.
const unsigned numAffineMaps;
/// List of affine maps in the memref's layout/index map composition.
AffineMap const *affineMapList;
};

/// Unranked MemRef is a MemRef with unknown rank.
/// Only element type and memory space are known
struct UnrankedMemRefTypeStorage : public BaseMemRefTypeStorage {

UnrankedMemRefTypeStorage(Type elementTy, const unsigned memorySpace)
: BaseMemRefTypeStorage(elementTy, memorySpace) {}

/// The hash key used for uniquing.
using KeyTy = std::tuple<Type, unsigned>;
bool operator==(const KeyTy &key) const {
return key == KeyTy(elementType, memorySpace);
}

/// Construction.
static UnrankedMemRefTypeStorage *construct(TypeStorageAllocator &allocator,
const KeyTy &key) {

// Initialize the memory using placement new.
return new (allocator.allocate<UnrankedMemRefTypeStorage>())
UnrankedMemRefTypeStorage(std::get<0>(key), std::get<1>(key));
}
};

/// A type representing a collection of other types.		/// A type representing a collection of other types.
struct TupleTypeStorage final		struct TupleTypeStorage final
: public TypeStorage,		: public TypeStorage,
public llvm::TrailingObjects<TupleTypeStorage, Type> {		public llvm::TrailingObjects<TupleTypeStorage, Type> {
using KeyTy = TypeRange;		using KeyTy = TypeRange;

TupleTypeStorage(unsigned numTypes) : numElements(numTypes) {}		TupleTypeStorage(unsigned numTypes) : numElements(numTypes) {}

Show All 32 Lines

This is an archive of the discontinued LLVM Phabricator instance.

[mlir][IR][NFC] Move the remaining builtin types to ODSClosedPublic

Details

Diff Detail

Event Timeline

Revision Contents

Diff 329144

mlir/include/mlir/IR/BuiltinTypes.h

mlir/include/mlir/IR/BuiltinTypes.td

mlir/include/mlir/IR/OpBase.td

mlir/lib/IR/BuiltinTypes.cpp

mlir/lib/IR/TypeDetail.h

[mlir][IR][NFC] Move the remaining builtin types to ODS
ClosedPublic