18 #include "llvm/Support/raw_ostream.h"
29 return FusedLoc::get(locs, metadata,
context);
85 return IntegerType::get(
context, width);
89 return IntegerType::get(
94 return FunctionType::get(
context, inputs, results);
98 return TupleType::get(
context, elementTypes);
118 return DictionaryAttr::get(
context, value);
122 return IntegerAttr::get(
getIndexType(), APInt(64, value));
131 VectorType::get(
static_cast<int64_t
>(values.size()),
getI1Type()),
137 VectorType::get(
static_cast<int64_t
>(values.size()),
getIntegerType(32)),
143 VectorType::get(
static_cast<int64_t
>(values.size()),
getIntegerType(64)),
149 VectorType::get(
static_cast<int64_t
>(values.size()),
getIndexType()),
183 RankedTensorType::get(
static_cast<int64_t
>(values.size()),
190 RankedTensorType::get(
static_cast<int64_t
>(values.size()),
197 RankedTensorType::get(
static_cast<int64_t
>(values.size()),
208 APInt(32, value,
true));
213 APInt(32, (uint64_t)value,
false));
226 return IntegerAttr::get(type, APInt(64, value));
227 return IntegerAttr::get(
232 return IntegerAttr::get(type, value);
236 return FloatAttr::get(
getF64Type(), APFloat(value));
240 return FloatAttr::get(
getF32Type(), APFloat(value));
248 return FloatAttr::get(type, value);
252 return FloatAttr::get(type, value);
256 return StringAttr::get(
context, bytes);
260 return ArrayAttr::get(
context, value);
264 auto attrs = llvm::to_vector<8>(llvm::map_range(
270 auto attrs = llvm::to_vector<8>(llvm::map_range(
275 auto attrs = llvm::to_vector<8>(llvm::map_range(
281 auto attrs = llvm::to_vector<8>(
282 llvm::map_range(values, [
this](int64_t v) ->
Attribute {
289 auto attrs = llvm::to_vector<8>(llvm::map_range(
295 auto attrs = llvm::to_vector<8>(llvm::map_range(
301 auto attrs = llvm::to_vector<8>(llvm::map_range(
307 auto attrs = llvm::to_vector<8>(llvm::map_range(
308 values, [](
Type v) ->
Attribute {
return TypeAttr::get(v); }));
313 auto attrs = llvm::to_vector<8>(llvm::map_range(
321 if (type.
isa<IndexType>())
323 if (
auto integerType = type.
dyn_cast<IntegerType>())
325 if (type.
isa<RankedTensorType, VectorType>()) {
326 auto vtType = type.
cast<ShapedType>();
327 auto element =
getZeroAttr(vtType.getElementType());
364 dimExprs.reserve(rank);
365 for (
unsigned i = 0; i < rank; ++i)
386 shiftedResults.push_back(resultExpr + shift);
407 assert(parent &&
"expected valid parent region");
408 assert(argTypes.size() == locs.size() &&
"argument location mismatch");
410 insertPt = parent->
end();
426 assert(insertBefore &&
"expected valid insertion block");
442 OperationState state(loc, opName, operands, types, attributes, successors,
454 results.reserve(opResults.size());
455 auto cleanupFailure = [&] {
456 results.assign(opResults.begin(), opResults.end());
462 return cleanupFailure();
467 for (
unsigned i = 0, e = constOperands.size(); i != e; ++i)
472 if (
failed(op->
fold(constOperands, foldResults)) || foldResults.empty())
473 return cleanupFailure();
481 for (
auto it : llvm::zip(foldResults, opResults.
getTypes())) {
482 Type expectedType = std::get<1>(it);
485 if (
auto value = std::get<0>(it).dyn_cast<Value>()) {
486 if (value.getType() != expectedType)
487 return cleanupFailure();
489 results.push_back(value);
495 return cleanupFailure();
503 for (
Operation *cst : generatedConstants)
505 return cleanupFailure();
509 generatedConstants.push_back(constOp);
510 results.push_back(constOp->getResult(0));
514 for (
Operation *cst : generatedConstants)
537 return clone(op, mapper);
Base type for affine expression.
A multi-dimensional affine map Affine map's are immutable like Type's, and they are uniqued.
static AffineMap get(MLIRContext *context)
Returns a zero result affine map with no dimensions or symbols: () -> ().
unsigned getNumSymbols() const
unsigned getNumDims() const
ArrayRef< AffineExpr > getResults() const
unsigned getNumResults() const
Attributes are known-constant values of operations.
This class provides an abstraction over the different types of ranges over Blocks.
Block represents an ordered list of Operations.
iterator_range< args_iterator > addArguments(TypeRange types, ArrayRef< Location > locs)
Add one argument to the argument list for each type specified in the list.
Region * getParent() const
Provide a 'getParent' method for ilist_node_with_parent methods.
OpListType & getOperations()
Special case of IntegerAttr to represent boolean integers, i.e., signless i1 integers.
static BoolAttr get(MLIRContext *context, bool value)
FloatType getFloat8E5M2Type()
IntegerAttr getIndexAttr(int64_t value)
AffineMap getSingleDimShiftAffineMap(int64_t shift)
Returns a map that shifts its (single) input dimension by 'shift'.
ArrayAttr getIndexArrayAttr(ArrayRef< int64_t > values)
DenseF64ArrayAttr getDenseF64ArrayAttr(ArrayRef< double > values)
DenseI8ArrayAttr getDenseI8ArrayAttr(ArrayRef< int8_t > values)
IntegerAttr getI32IntegerAttr(int32_t value)
DenseI32ArrayAttr getDenseI32ArrayAttr(ArrayRef< int32_t > values)
DenseIntElementsAttr getBoolVectorAttr(ArrayRef< bool > values)
Vector-typed DenseIntElementsAttr getters. values must not be empty.
TupleType getTupleType(TypeRange elementTypes)
IntegerAttr getIntegerAttr(Type type, int64_t value)
FloatAttr getF64FloatAttr(double value)
AffineMap getShiftedAffineMap(AffineMap map, int64_t shift)
Returns an affine map that is a translation (shift) of all result expressions in 'map' by 'shift'.
FloatType getFloat8E4M3B11FNUZType()
ArrayAttr getI32ArrayAttr(ArrayRef< int32_t > values)
DenseI64ArrayAttr getDenseI64ArrayAttr(ArrayRef< int64_t > values)
FloatAttr getF16FloatAttr(float value)
AffineMap getDimIdentityMap()
AffineMap getMultiDimIdentityMap(unsigned rank)
IntegerAttr getI16IntegerAttr(int16_t value)
DenseI16ArrayAttr getDenseI16ArrayAttr(ArrayRef< int16_t > values)
AffineExpr getAffineSymbolExpr(unsigned position)
FloatAttr getFloatAttr(Type type, double value)
AffineExpr getAffineConstantExpr(int64_t constant)
DenseIntElementsAttr getI32TensorAttr(ArrayRef< int32_t > values)
Tensor-typed DenseIntElementsAttr getters.
FunctionType getFunctionType(TypeRange inputs, TypeRange results)
IntegerAttr getI64IntegerAttr(int64_t value)
IntegerType getIntegerType(unsigned width)
DenseIntElementsAttr getI64TensorAttr(ArrayRef< int64_t > values)
BoolAttr getBoolAttr(bool value)
StringAttr getStringAttr(const Twine &bytes)
AffineMap getEmptyAffineMap()
Returns a zero result affine map with no dimensions or symbols: () -> ().
IntegerAttr getSI32IntegerAttr(int32_t value)
Signed and unsigned integer attribute getters.
Location getFusedLoc(ArrayRef< Location > locs, Attribute metadata=Attribute())
AffineExpr getAffineDimExpr(unsigned position)
DenseIntElementsAttr getIndexTensorAttr(ArrayRef< int64_t > values)
AffineMap getConstantAffineMap(int64_t val)
Returns a single constant result affine map with 0 dimensions and 0 symbols.
MLIRContext * getContext() const
ArrayAttr getTypeArrayAttr(TypeRange values)
DenseIntElementsAttr getI32VectorAttr(ArrayRef< int32_t > values)
DenseF32ArrayAttr getDenseF32ArrayAttr(ArrayRef< float > values)
FloatType getFloat8E4M3FNType()
DenseIntElementsAttr getI64VectorAttr(ArrayRef< int64_t > values)
AffineMap getSymbolIdentityMap()
ArrayAttr getF64ArrayAttr(ArrayRef< double > values)
Attribute getZeroAttr(Type type)
ArrayAttr getArrayAttr(ArrayRef< Attribute > value)
DenseBoolArrayAttr getDenseBoolArrayAttr(ArrayRef< bool > values)
Tensor-typed DenseArrayAttr getters.
FloatType getFloat8E4M3FNUZType()
ArrayAttr getI64ArrayAttr(ArrayRef< int64_t > values)
FloatAttr getF32FloatAttr(float value)
DictionaryAttr getDictionaryAttr(ArrayRef< NamedAttribute > value)
NamedAttribute getNamedAttr(StringRef name, Attribute val)
IntegerAttr getUI32IntegerAttr(uint32_t value)
FloatType getFloat8E5M2FNUZType()
IntegerAttr getI8IntegerAttr(int8_t value)
ArrayAttr getF32ArrayAttr(ArrayRef< float > values)
ArrayAttr getBoolArrayAttr(ArrayRef< bool > values)
ArrayAttr getStrArrayAttr(ArrayRef< StringRef > values)
DenseIntElementsAttr getIndexVectorAttr(ArrayRef< int64_t > values)
ArrayAttr getAffineMapArrayAttr(ArrayRef< AffineMap > values)
static DenseElementsAttr get(ShapedType type, ArrayRef< Attribute > values)
Constructs a dense elements attribute from an array of element values.
An attribute that represents a reference to a dense integer vector or tensor object.
static DenseIntElementsAttr get(const ShapedType &type, Arg &&arg)
Get an instance of a DenseIntElementsAttr with the given arguments.
Dialects are groups of MLIR operations, types and attributes, as well as behavior associated with the...
virtual Operation * materializeConstant(OpBuilder &builder, Attribute value, Type type, Location loc)
Registered hook to materialize a single constant operation from a given attribute value with the desi...
static FloatType getF64(MLIRContext *ctx)
static FloatType getFloat8E5M2(MLIRContext *ctx)
static FloatType getF80(MLIRContext *ctx)
static FloatType getFloat8E4M3FN(MLIRContext *ctx)
static FloatType getF16(MLIRContext *ctx)
static FloatType getBF16(MLIRContext *ctx)
static FloatType getFloat8E4M3FNUZ(MLIRContext *ctx)
static FloatType getFloat8E4M3B11FNUZ(MLIRContext *ctx)
static FloatType getFloat8E5M2FNUZ(MLIRContext *ctx)
static FloatType getF128(MLIRContext *ctx)
static FloatType getF32(MLIRContext *ctx)
This is a utility class for mapping one set of IR entities to another.
This class defines the main interface for locations in MLIR and acts as a non-nullable wrapper around...
NamedAttribute represents a combination of a name and an Attribute value.
This class helps build Operations.
Operation * clone(Operation &op, IRMapping &mapper)
Creates a deep copy of the specified operation, remapping any operands that use values outside of the...
void setInsertionPointToEnd(Block *block)
Sets the insertion point to the end of the specified block.
Listener * listener
The optional listener for events of this builder.
Block * createBlock(Region *parent, Region::iterator insertPt={}, TypeRange argTypes=std::nullopt, ArrayRef< Location > locs=std::nullopt)
Add new block with 'argTypes' arguments and set the insertion point to the end of it.
Operation * create(const OperationState &state)
Creates an operation given the fields represented as an OperationState.
LogicalResult tryFold(Operation *op, SmallVectorImpl< Value > &results)
Attempts to fold the given operation and places new results within 'results'.
Operation * insert(Operation *op)
Insert the given operation at the current insertion point and return it.
Operation is the basic unit of execution within MLIR.
LogicalResult fold(ArrayRef< Attribute > operands, SmallVectorImpl< OpFoldResult > &results)
Attempt to fold this operation with the specified constant operand values.
Value getOperand(unsigned idx)
Dialect * getDialect()
Return the dialect this operation is associated with, or nullptr if the associated dialect is not loa...
Operation * clone(IRMapping &mapper, CloneOptions options=CloneOptions::all())
Create a deep copy of this operation, remapping any operands that use values outside of the operation...
Location getLoc()
The source location the operation was defined or derived from.
unsigned getNumOperands()
static Operation * create(Location location, OperationName name, TypeRange resultTypes, ValueRange operands, NamedAttrList &&attributes, BlockRange successors, unsigned numRegions)
Create a new Operation with the specific fields.
MutableArrayRef< Region > getRegions()
Returns the regions held by this operation.
result_range getResults()
void erase()
Remove this operation from its parent block and delete it.
This class contains a list of basic blocks and a link to the parent operation it is attached to.
BlockListType & getBlocks()
BlockListType::iterator iterator
This class implements the result iterators for the Operation class.
type_range getTypes() const
This class provides an abstraction over the various different ranges of value types.
Instances of the Type class are uniqued, have an immutable identifier and an optional mutable compone...
bool isSignedInteger() const
Return true if this is a signed integer type (with the specified width).
unsigned getIntOrFloatBitWidth() const
Return the bit width of an integer or a float type, assert failure on other types.
This class provides an abstraction over the different types of ranges over Values.
Base class for DenseArrayAttr that is instantiated and specialized for each supported element type be...
static DenseArrayAttrImpl get(MLIRContext *context, ArrayRef< T > content)
Builder from ArrayRef<T>.
This header declares functions that assit transformations in the MemRef dialect.
bool matchPattern(Value value, const Pattern &pattern)
Entry point for matching a pattern over a Value.
LogicalResult failure(bool isFailure=true)
Utility function to generate a LogicalResult.
LogicalResult success(bool isSuccess=true)
Utility function to generate a LogicalResult.
AffineExpr getAffineConstantExpr(int64_t constant, MLIRContext *context)
detail::constant_op_matcher m_Constant()
Matches a constant foldable operation.
AffineExpr getAffineDimExpr(unsigned position, MLIRContext *context)
These free functions allow clients of the API to not use classes in detail.
bool failed(LogicalResult result)
Utility function that returns true if the provided LogicalResult corresponds to a failure value.
AffineExpr getAffineSymbolExpr(unsigned position, MLIRContext *context)
This class represents an efficient way to signal success or failure.
virtual void notifyBlockCreated(Block *block)
Notification handler for when a block is created using the builder.
virtual void notifyOperationInserted(Operation *op)
Notification handler for when an operation is inserted into the builder.
This represents an operation in an abstracted form, suitable for use with the builder APIs.