434 lines
12 KiB
TableGen
434 lines
12 KiB
TableGen
//===-- BuiltinBytecode.td - Builtin bytecode defs ---------*- tablegen -*-===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This is the Builtin bytecode reader/writer definition file.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef BUILTIN_BYTECODE
|
|
#define BUILTIN_BYTECODE
|
|
|
|
include "mlir/IR/BytecodeBase.td"
|
|
|
|
def LocationAttr : AttributeKind;
|
|
def ShapedType: WithType<"ShapedType", Type>;
|
|
|
|
def Location : CompositeBytecode {
|
|
dag members = (attr
|
|
WithGetter<"(LocationAttr)$_attrType", WithType<"LocationAttr", LocationAttr>>:$value
|
|
);
|
|
let cBuilder = "Location($_args)";
|
|
}
|
|
|
|
def String :
|
|
WithParser <"succeeded($_reader.readString($_var))",
|
|
WithBuilder<"$_args",
|
|
WithPrinter<"$_writer.writeOwnedString($_getter)",
|
|
WithGetter <"$_attrType",
|
|
WithType <"StringRef">>>>>;
|
|
|
|
def ArrayAttr : DialectAttribute<(attr
|
|
Array<Attribute>:$value
|
|
)>;
|
|
|
|
let cType = "StringAttr" in {
|
|
def StringAttr : DialectAttribute<(attr
|
|
String:$value
|
|
)> {
|
|
let printerPredicate = "::llvm::isa<NoneType>($_val.getType())";
|
|
}
|
|
|
|
def StringAttrWithType : DialectAttribute<(attr
|
|
String:$value,
|
|
Type:$type
|
|
)> { let printerPredicate = "!::llvm::isa<NoneType>($_val.getType())"; }
|
|
}
|
|
|
|
def NamedAttribute : CompositeBytecode {
|
|
dag members = (attr
|
|
StringAttr:$name,
|
|
Attribute:$value
|
|
);
|
|
let cBuilder = "NamedAttribute($_args)";
|
|
}
|
|
def DictionaryAttr : DialectAttribute<(attr
|
|
Array<NamedAttribute>:$value
|
|
)>;
|
|
|
|
def FlatSymbolRefAttr: DialectAttribute<(attr
|
|
StringAttr:$rootReference
|
|
)>;
|
|
|
|
def SymbolRefAttr: DialectAttribute<(attr
|
|
StringAttr:$rootReference,
|
|
Array<FlatSymbolRefAttr>:$nestedReferences
|
|
)>;
|
|
|
|
def TypeAttr: DialectAttribute<(attr
|
|
Type:$value
|
|
)>;
|
|
|
|
def UnitAttr: DialectAttribute<(attr)>;
|
|
|
|
def IntegerAttr: DialectAttribute<(attr
|
|
Type:$type,
|
|
KnownWidthAPInt<"type">:$value
|
|
)> {
|
|
let cBuilder = "getChecked<$_resultType>([&]() { return reader.emitError(); }, context, type, *value)";
|
|
}
|
|
|
|
defvar FloatType = Type;
|
|
def FloatAttr : DialectAttribute<(attr
|
|
FloatType:$type,
|
|
KnownSemanticsAPFloat<"type">:$value
|
|
)> {
|
|
let cBuilder = "getChecked<$_resultType>([&]() { return reader.emitError(); }, context, type, *value)";
|
|
}
|
|
|
|
def CallSiteLoc : DialectAttribute<(attr
|
|
LocationAttr:$callee,
|
|
LocationAttr:$caller
|
|
)>;
|
|
|
|
let cType = "FileLineColRange" in {
|
|
def FileLineColRange : DialectAttribute<(attr
|
|
StringAttr:$filename,
|
|
WithBuilder<"$_args",
|
|
WithType<"SmallVector<uint64_t>",
|
|
WithParser<"succeeded(readFileLineColRangeLocs($_reader, $_var))",
|
|
WithPrinter<"writeFileLineColRangeLocs($_writer, $_name)">>>>:$rawLocData
|
|
)> {
|
|
let cBuilder = "getFileLineColRange(context, filename, rawLocData)";
|
|
let printerPredicate = "!isStrictFileLineColLoc($_val)";
|
|
}
|
|
|
|
def FileLineColLoc : DialectAttribute<(attr
|
|
StringAttr:$filename,
|
|
VarInt:$start_line,
|
|
VarInt:$start_column
|
|
)> {
|
|
let printerPredicate = "isStrictFileLineColLoc($_val)";
|
|
}
|
|
}
|
|
|
|
let cType = "FusedLoc" in {
|
|
def FusedLoc : DialectAttribute<(attr
|
|
Array<Location>:$locations
|
|
)> {
|
|
let printerPredicate = "!$_val.getMetadata()";
|
|
// FusedLoc::get(context, locs) may return UnknownLoc when locs is empty.
|
|
// Pass Attribute() explicitly to bypass the folding logic and always
|
|
// construct a FusedLoc via Base::getChecked.
|
|
let cBuilder = "cast<FusedLoc>(getChecked<FusedLoc>([&]() { return reader.emitError(); }, context, $_args, Attribute()))";
|
|
}
|
|
|
|
def FusedLocWithMetadata : DialectAttribute<(attr
|
|
Array<Location>:$locations,
|
|
Attribute:$metadata
|
|
)> {
|
|
let printerPredicate = "$_val.getMetadata()";
|
|
let cBuilder = "cast<FusedLoc>(getChecked<FusedLoc>([&]() { return reader.emitError(); }, context, $_args))";
|
|
}
|
|
}
|
|
|
|
def NameLoc : DialectAttribute<(attr
|
|
StringAttr:$name,
|
|
LocationAttr:$childLoc
|
|
)>;
|
|
|
|
def UnknownLoc : DialectAttribute<(attr)>;
|
|
|
|
def DenseResourceElementsAttr : DialectAttribute<(attr
|
|
ShapedType:$type,
|
|
ResourceHandle<"DenseResourceElementsHandle">:$rawHandle
|
|
)> {
|
|
// Note: order of serialization does not match order of builder.
|
|
let cBuilder = "getChecked<$_resultType>([&]() { return reader.emitError(); }, context, type, *rawHandle)";
|
|
}
|
|
|
|
let cType = "RankedTensorType" in {
|
|
def RankedTensorType : DialectType<(type
|
|
Array<SignedVarIntList>:$shape,
|
|
Type:$elementType
|
|
)> {
|
|
let printerPredicate = "!$_val.getEncoding()";
|
|
}
|
|
|
|
def RankedTensorTypeWithEncoding : DialectType<(type
|
|
Attribute:$encoding,
|
|
Array<SignedVarIntList>:$shape,
|
|
Type:$elementType
|
|
)> {
|
|
let printerPredicate = "$_val.getEncoding()";
|
|
// Note: order of serialization does not match order of builder.
|
|
let cBuilder = "getChecked<$_resultType>([&]() { return reader.emitError(); }, context, shape, elementType, encoding)";
|
|
}
|
|
}
|
|
|
|
def DenseArrayAttr : DialectAttribute<(attr
|
|
Type:$elementType,
|
|
VarInt:$size,
|
|
Blob:$rawData
|
|
)>;
|
|
|
|
def DenseElementsAttr : WithType<"DenseElementsAttr", Attribute>;
|
|
def DenseTypedElementsAttr : DialectAttribute<(attr
|
|
ShapedType:$type,
|
|
WithBuilder<"$_args",
|
|
WithType<"SmallVector<char>",
|
|
WithParser<"succeeded(readDenseTypedElementsAttr($_reader, type, $_var))",
|
|
WithPrinter<"writeDenseTypedElementsAttr($_writer, $_name)">>>>:$rawData
|
|
)>;
|
|
|
|
def DenseStringElementsAttr : DialectAttribute<(attr
|
|
ShapedType:$type,
|
|
WithGetter<"$_attrType.isSplat()", VarInt>:$_isSplat,
|
|
WithBuilder<"$_args",
|
|
WithType<"SmallVector<StringRef>",
|
|
WithParser <"succeeded(readPotentiallySplatString($_reader, type, _isSplat, $_var))",
|
|
WithPrinter<"writePotentiallySplatString($_writer, $_name)">>>>:$rawStringData
|
|
)>;
|
|
|
|
def DenseIntElementsAttr : WithType<"DenseIntElementsAttr", Attribute>;
|
|
def SparseElementsAttr : DialectAttribute<(attr
|
|
ShapedType:$type,
|
|
DenseIntElementsAttr:$indices,
|
|
DenseElementsAttr:$values
|
|
)>;
|
|
|
|
def DistinctAttr : DialectAttribute<(attr
|
|
Attribute:$referencedAttr
|
|
)>;
|
|
|
|
// Make easy to disable until version number gets added.
|
|
class EnableAffineMapPrintingJuly2026<dag d> : DialectAttribute<d>;
|
|
|
|
def AffineMapAttr : EnableAffineMapPrintingJuly2026<(attr
|
|
WithParser<"succeeded(readAffineMap($_reader, context, $_var))",
|
|
WithPrinter<"writeAffineMap($_writer, $_name)",
|
|
WithType<"AffineMap">>>:$value
|
|
)>;
|
|
|
|
// Types
|
|
// -----
|
|
|
|
def IntegerType : DialectType<(type
|
|
// Yes not pretty,
|
|
WithParser<"succeeded($_reader.readVarInt($_var))",
|
|
WithBuilder<"$_args",
|
|
WithPrinter<"$_writer.writeVarInt($_name.getWidth() << 2 | $_name.getSignedness())",
|
|
WithType <"uint64_t">>>>:$_widthAndSignedness,
|
|
// Split up parsed varint for create method.
|
|
LocalVar<"uint64_t", "_widthAndSignedness >> 2">:$width,
|
|
LocalVar<"IntegerType::SignednessSemantics",
|
|
"static_cast<IntegerType::SignednessSemantics>(_widthAndSignedness & 0x3)">:$signedness
|
|
)>;
|
|
|
|
def IndexType : DialectType<(type)>;
|
|
|
|
def FunctionType : DialectType<(type
|
|
Array<Type>:$inputs,
|
|
Array<Type>:$results
|
|
)>;
|
|
|
|
def BFloat16Type : DialectType<(type)>;
|
|
|
|
def Float16Type : DialectType<(type)>;
|
|
|
|
// Make it easy to stage the addition of new floating point types so that
|
|
// readers can be updated first. This is enabled by default, but can be flipped
|
|
// to DialectTypeNoPrint if staging needed.
|
|
// Note: this will be removed post next release.
|
|
class EnableFloatPrintingJune2026<dag d> : DialectType<d>;
|
|
|
|
def FloatTF32Type : EnableFloatPrintingJune2026<(type)>;
|
|
|
|
def Float32Type : DialectType<(type)>;
|
|
|
|
def Float64Type : DialectType<(type)>;
|
|
|
|
def Float80Type : DialectType<(type)>;
|
|
|
|
def Float128Type : DialectType<(type)>;
|
|
|
|
def Float8E5M2Type : EnableFloatPrintingJune2026<(type)>;
|
|
|
|
def Float8E4M3Type : EnableFloatPrintingJune2026<(type)>;
|
|
|
|
def Float8E4M3FNType : EnableFloatPrintingJune2026<(type)>;
|
|
|
|
def Float8E5M2FNUZType : EnableFloatPrintingJune2026<(type)>;
|
|
|
|
def Float8E4M3FNUZType : EnableFloatPrintingJune2026<(type)>;
|
|
|
|
def Float8E4M3B11FNUZType : EnableFloatPrintingJune2026<(type)>;
|
|
|
|
def Float8E3M4Type : EnableFloatPrintingJune2026<(type)>;
|
|
|
|
def Float4E2M1FNType : EnableFloatPrintingJune2026<(type)>;
|
|
|
|
def Float6E2M3FNType : EnableFloatPrintingJune2026<(type)>;
|
|
|
|
def Float6E3M2FNType : EnableFloatPrintingJune2026<(type)>;
|
|
|
|
def Float8E8M0FNUType : EnableFloatPrintingJune2026<(type)>;
|
|
|
|
def ComplexType : DialectType<(type
|
|
Type:$elementType
|
|
)>;
|
|
|
|
def MemRefLayout: WithType<"MemRefLayoutAttrInterface", Attribute>;
|
|
|
|
let cType = "MemRefType" in {
|
|
def MemRefType : DialectType<(type
|
|
Array<SignedVarIntList>:$shape,
|
|
Type:$elementType,
|
|
MemRefLayout:$layout
|
|
)> {
|
|
let printerPredicate = "!$_val.getMemorySpace()";
|
|
}
|
|
|
|
def MemRefTypeWithMemSpace : DialectType<(type
|
|
Attribute:$memorySpace,
|
|
Array<SignedVarIntList>:$shape,
|
|
Type:$elementType,
|
|
MemRefLayout:$layout
|
|
)> {
|
|
let printerPredicate = "!!$_val.getMemorySpace()";
|
|
// Note: order of serialization does not match order of builder.
|
|
let cBuilder = "getChecked<$_resultType>([&]() { return reader.emitError(); }, context, shape, elementType, layout, memorySpace)";
|
|
}
|
|
}
|
|
|
|
def NoneType : DialectType<(type)>;
|
|
|
|
def TupleType : DialectType<(type
|
|
Array<Type>:$types
|
|
)>;
|
|
|
|
let cType = "UnrankedMemRefType" in {
|
|
def UnrankedMemRefType : DialectType<(type
|
|
Type:$elementType
|
|
)> {
|
|
let printerPredicate = "!$_val.getMemorySpace()";
|
|
let cBuilder = "getChecked<$_resultType>([&]() { return reader.emitError(); }, context, elementType, Attribute())";
|
|
}
|
|
|
|
def UnrankedMemRefTypeWithMemSpace : DialectType<(type
|
|
Attribute:$memorySpace,
|
|
Type:$elementType
|
|
)> {
|
|
let printerPredicate = "$_val.getMemorySpace()";
|
|
// Note: order of serialization does not match order of builder.
|
|
let cBuilder = "getChecked<$_resultType>([&]() { return reader.emitError(); }, context, elementType, memorySpace)";
|
|
}
|
|
}
|
|
|
|
def UnrankedTensorType : DialectType<(type
|
|
Type:$elementType
|
|
)>;
|
|
|
|
def TokenType : DialectType<(type)>;
|
|
|
|
let cType = "VectorType" in {
|
|
def VectorType : DialectType<(type
|
|
Array<SignedVarIntList>:$shape,
|
|
Type:$elementType
|
|
)> {
|
|
let printerPredicate = "!$_val.isScalable()";
|
|
// Use getChecked to produce a null type (and emit a diagnostic) instead of
|
|
// asserting when the element type does not implement VectorElementTypeInterface.
|
|
let cBuilder = "VectorType::getChecked([&]() { return reader.emitError(\"invalid vector type\"); }, shape, elementType)";
|
|
}
|
|
|
|
def VectorTypeWithScalableDims : DialectType<(type
|
|
Array<BoolList>:$scalableDims,
|
|
Array<SignedVarIntList>:$shape,
|
|
Type:$elementType
|
|
)> {
|
|
let printerPredicate = "$_val.isScalable()";
|
|
// Note: order of serialization does not match order of builder.
|
|
let cBuilder = "getChecked<$_resultType>([&]() { return reader.emitError(); }, context, shape, elementType, scalableDims)";
|
|
}
|
|
}
|
|
|
|
/// This enum contains marker codes used to indicate which attribute is
|
|
/// currently being decoded, and how it should be decoded. The order of these
|
|
/// codes should generally be unchanged, as any changes will inevitably break
|
|
/// compatibility with older bytecode.
|
|
|
|
def BuiltinDialectAttributes : DialectAttributes<"Builtin"> {
|
|
let elems = [
|
|
ArrayAttr,
|
|
DictionaryAttr,
|
|
StringAttr,
|
|
StringAttrWithType,
|
|
FlatSymbolRefAttr,
|
|
SymbolRefAttr,
|
|
TypeAttr,
|
|
UnitAttr,
|
|
IntegerAttr,
|
|
FloatAttr,
|
|
CallSiteLoc,
|
|
FileLineColLoc,
|
|
FusedLoc,
|
|
FusedLocWithMetadata,
|
|
NameLoc,
|
|
UnknownLoc,
|
|
DenseResourceElementsAttr,
|
|
DenseArrayAttr,
|
|
DenseTypedElementsAttr,
|
|
DenseStringElementsAttr,
|
|
SparseElementsAttr,
|
|
DistinctAttr,
|
|
FileLineColRange,
|
|
AffineMapAttr,
|
|
];
|
|
}
|
|
|
|
def BuiltinDialectTypes : DialectTypes<"Builtin"> {
|
|
let elems = [
|
|
IntegerType,
|
|
IndexType,
|
|
FunctionType,
|
|
BFloat16Type,
|
|
Float16Type,
|
|
Float32Type,
|
|
Float64Type,
|
|
Float80Type,
|
|
Float128Type,
|
|
ComplexType,
|
|
MemRefType,
|
|
MemRefTypeWithMemSpace,
|
|
NoneType,
|
|
RankedTensorType,
|
|
RankedTensorTypeWithEncoding,
|
|
TupleType,
|
|
UnrankedMemRefType,
|
|
UnrankedMemRefTypeWithMemSpace,
|
|
UnrankedTensorType,
|
|
VectorType,
|
|
VectorTypeWithScalableDims,
|
|
FloatTF32Type,
|
|
Float8E5M2Type,
|
|
Float8E4M3Type,
|
|
Float8E4M3FNType,
|
|
Float8E5M2FNUZType,
|
|
Float8E4M3FNUZType,
|
|
Float8E4M3B11FNUZType,
|
|
Float8E3M4Type,
|
|
Float4E2M1FNType,
|
|
Float6E2M3FNType,
|
|
Float6E3M2FNType,
|
|
Float8E8M0FNUType,
|
|
TokenType
|
|
];
|
|
}
|
|
|
|
#endif // BUILTIN_BYTECODE
|