22 #include "llvm/ADT/ScopeExit.h"
23 #include "llvm/ADT/TypeSwitch.h"
24 #include "llvm/Support/TypeSize.h"
53 params.push_back(type);
61 params.push_back(type);
68 llvm::interleaveComma(params, p,
93 auto typeOrIntParser = [&]() -> ParseResult {
96 if (intResult.has_value() && !failed(*intResult)) {
98 intParams.push_back(i);
108 typeParams.push_back(t);
116 "failed to parse parameter list for target extension type");
125 if (!typeParams.empty() && !intParams.empty())
139 LLVM_ATTRIBUTE_UNUSED
static LogicalResult
142 #include "mlir/Dialect/LLVMIR/LLVMTypeInterfaces.cpp.inc"
144 #define GET_TYPEDEF_CLASSES
145 #include "mlir/Dialect/LLVMIR/LLVMTypes.cpp.inc"
151 bool LLVMArrayType::isValidElementType(
Type type) {
152 return !llvm::isa<LLVMVoidType, LLVMLabelType, LLVMMetadataType,
153 LLVMFunctionType, LLVMTokenType>(type);
157 assert(elementType &&
"expected non-null subtype");
163 Type elementType, uint64_t numElements) {
164 assert(elementType &&
"expected non-null subtype");
171 Type elementType, uint64_t numElements) {
172 if (!isValidElementType(elementType))
173 return emitError() <<
"invalid array element type: " << elementType;
182 LLVMArrayType::getTypeSizeInBits(
const DataLayout &dataLayout,
185 getTypeSize(dataLayout, params));
188 llvm::TypeSize LLVMArrayType::getTypeSize(
const DataLayout &dataLayout,
195 uint64_t LLVMArrayType::getABIAlignment(
const DataLayout &dataLayout,
201 LLVMArrayType::getPreferredAlignment(
const DataLayout &dataLayout,
210 bool LLVMFunctionType::isValidArgumentType(
Type type) {
211 return !llvm::isa<LLVMVoidType, LLVMFunctionType>(type);
214 bool LLVMFunctionType::isValidResultType(
Type type) {
215 return !llvm::isa<LLVMFunctionType, LLVMMetadataType, LLVMLabelType>(type);
220 assert(result &&
"expected non-null result");
228 assert(result &&
"expected non-null result");
235 if (results.size() != 1 || !isValidResultType(results[0]))
237 if (!llvm::all_of(inputs, isValidArgumentType))
239 return get(results[0], llvm::to_vector(inputs), isVarArg());
243 return static_cast<detail::LLVMFunctionTypeStorage *
>(getImpl())->returnType;
249 if (!isValidResultType(result))
250 return emitError() <<
"invalid function result type: " << result;
252 for (
Type arg : arguments)
253 if (!isValidArgumentType(arg))
254 return emitError() <<
"invalid function argument type: " << arg;
268 auto spec = cast<DenseIntElementsAttr>(attr);
269 auto idx =
static_cast<int64_t
>(pos);
270 if (idx >= spec.size())
272 return spec.getValues<uint64_t>()[idx];
279 static std::optional<uint64_t>
284 for (DataLayoutEntryInterface entry : params) {
285 if (!entry.isTypeEntry())
287 if (cast<LLVMPointerType>(cast<Type>(entry.getKey())).getAddressSpace() ==
288 type.getAddressSpace()) {
289 currentEntry = entry.getValue();
306 if (type.getAddressSpace() == 0) {
316 LLVMPointerType::getTypeSizeInBits(
const DataLayout &dataLayout,
318 if (std::optional<uint64_t> size =
320 return llvm::TypeSize::getFixed(*size);
327 uint64_t LLVMPointerType::getABIAlignment(
const DataLayout &dataLayout,
329 if (std::optional<uint64_t> alignment =
337 LLVMPointerType::getPreferredAlignment(
const DataLayout &dataLayout,
339 if (std::optional<uint64_t> alignment =
346 std::optional<uint64_t>
349 if (std::optional<uint64_t> indexBitwidth =
351 return *indexBitwidth;
356 bool LLVMPointerType::areCompatible(
358 DataLayoutSpecInterface newSpec,
360 for (DataLayoutEntryInterface newEntry : newLayout) {
361 if (!newEntry.isTypeEntry())
366 llvm::cast<LLVMPointerType>(llvm::cast<Type>(newEntry.getKey()));
368 llvm::find_if(oldLayout, [&](DataLayoutEntryInterface entry) {
369 if (
auto type = llvm::dyn_cast_if_present<Type>(entry.getKey())) {
370 return llvm::cast<LLVMPointerType>(type).getAddressSpace() ==
371 newType.getAddressSpace();
375 if (it == oldLayout.end()) {
376 llvm::find_if(oldLayout, [&](DataLayoutEntryInterface entry) {
377 if (
auto type = llvm::dyn_cast_if_present<Type>(entry.getKey())) {
378 return llvm::cast<LLVMPointerType>(type).getAddressSpace() == 0;
383 if (it != oldLayout.end()) {
388 Attribute newSpec = llvm::cast<DenseIntElementsAttr>(newEntry.getValue());
391 if (size != newSize || abi < newAbi || abi % newAbi != 0)
399 for (DataLayoutEntryInterface entry : entries) {
400 if (!entry.isTypeEntry())
402 auto key = llvm::cast<Type>(entry.getKey());
403 auto values = llvm::dyn_cast<DenseIntElementsAttr>(entry.getValue());
404 if (!values || (values.size() != 3 && values.size() != 4)) {
406 <<
"expected layout attribute for " << key
407 <<
" to be a dense integer elements attribute with 3 or 4 "
410 if (!values.getElementType().isInteger(64))
411 return emitError(loc) <<
"expected i64 parameters for " << key;
415 return emitError(loc) <<
"preferred alignment is expected to be at least "
416 "as large as ABI alignment";
426 bool LLVMStructType::isValidElementType(
Type type) {
427 return !llvm::isa<LLVMVoidType, LLVMLabelType, LLVMMetadataType,
428 LLVMFunctionType, LLVMTokenType>(type);
431 LLVMStructType LLVMStructType::getIdentified(
MLIRContext *context,
436 LLVMStructType LLVMStructType::getIdentifiedChecked(
439 return Base::getChecked(
emitError, context, name,
false);
442 LLVMStructType LLVMStructType::getNewIdentified(
MLIRContext *context,
446 std::string stringName = name.str();
447 unsigned counter = 0;
449 auto type = LLVMStructType::getIdentified(context, stringName);
450 if (type.isInitialized() || failed(type.setBody(elements, isPacked))) {
452 stringName = (Twine(name) +
"." + std::to_string(counter)).str();
459 LLVMStructType LLVMStructType::getLiteral(
MLIRContext *context,
461 return Base::get(context, types, isPacked);
468 return Base::getChecked(
emitError, context, types, isPacked);
471 LLVMStructType LLVMStructType::getOpaque(StringRef name,
MLIRContext *context) {
478 return Base::getChecked(
emitError, context, name,
true);
481 LogicalResult LLVMStructType::setBody(
ArrayRef<Type> types,
bool isPacked) {
482 assert(isIdentified() &&
"can only set bodies of identified structs");
483 assert(llvm::all_of(types, LLVMStructType::isValidElementType) &&
484 "expected valid body types");
485 return Base::mutate(types, isPacked);
488 bool LLVMStructType::isPacked()
const {
return getImpl()->isPacked(); }
489 bool LLVMStructType::isIdentified()
const {
return getImpl()->isIdentified(); }
490 bool LLVMStructType::isOpaque()
const {
491 return getImpl()->isIdentified() &&
492 (getImpl()->isOpaque() || !getImpl()->isInitialized());
494 bool LLVMStructType::isInitialized() {
return getImpl()->isInitialized(); }
495 StringRef LLVMStructType::getName()
const {
return getImpl()->getIdentifier(); }
497 return isIdentified() ? getImpl()->getIdentifiedStructBody()
498 : getImpl()->getTypeList();
511 if (!isValidElementType(t))
512 return emitError() <<
"invalid LLVM structure element type: " << t;
518 LLVMStructType::getTypeSizeInBits(
const DataLayout &dataLayout,
520 auto structSize = llvm::TypeSize::getFixed(0);
521 uint64_t structAlignment = 1;
522 for (
Type element : getBody()) {
523 uint64_t elementAlignment =
527 structSize = llvm::alignTo(structSize, elementAlignment);
532 structAlignment =
std::max(elementAlignment, structAlignment);
536 structSize = llvm::alignTo(structSize, structAlignment);
544 static std::optional<uint64_t>
546 StructDLEntryPos pos) {
547 const auto *currentEntry =
548 llvm::find_if(params, [](DataLayoutEntryInterface entry) {
549 return entry.isTypeEntry();
551 if (currentEntry == params.end())
554 auto attr = llvm::cast<DenseIntElementsAttr>(currentEntry->getValue());
555 if (pos == StructDLEntryPos::Preferred &&
556 attr.size() <=
static_cast<int64_t
>(StructDLEntryPos::Preferred))
558 pos = StructDLEntryPos::Abi;
560 return attr.getValues<uint64_t>()[
static_cast<size_t>(pos)];
566 StructDLEntryPos pos) {
568 if (pos == StructDLEntryPos::Abi && type.isPacked()) {
574 uint64_t structAlignment = 1;
575 for (
Type iter : type.getBody()) {
581 if (std::optional<uint64_t> entryResult =
585 return structAlignment;
588 uint64_t LLVMStructType::getABIAlignment(
const DataLayout &dataLayout,
591 StructDLEntryPos::Abi);
595 LLVMStructType::getPreferredAlignment(
const DataLayout &dataLayout,
598 StructDLEntryPos::Preferred);
602 return llvm::cast<DenseIntElementsAttr>(attr)
603 .getValues<uint64_t>()[
static_cast<size_t>(pos)];
606 bool LLVMStructType::areCompatible(
608 DataLayoutSpecInterface newSpec,
610 for (DataLayoutEntryInterface newEntry : newLayout) {
611 if (!newEntry.isTypeEntry())
614 const auto *previousEntry =
615 llvm::find_if(oldLayout, [](DataLayoutEntryInterface entry) {
616 return entry.isTypeEntry();
618 if (previousEntry == oldLayout.end())
622 StructDLEntryPos::Abi);
625 if (abi < newAbi || abi % newAbi != 0)
633 for (DataLayoutEntryInterface entry : entries) {
634 if (!entry.isTypeEntry())
637 auto key = llvm::cast<LLVMStructType>(llvm::cast<Type>(entry.getKey()));
638 auto values = llvm::dyn_cast<DenseIntElementsAttr>(entry.getValue());
639 if (!values || (values.size() != 2 && values.size() != 1)) {
641 <<
"expected layout attribute for "
642 << llvm::cast<Type>(entry.getKey())
643 <<
" to be a dense integer elements attribute of 1 or 2 elements";
645 if (!values.getElementType().isInteger(64))
646 return emitError(loc) <<
"expected i64 entries for " << key;
648 if (key.isIdentified() || !key.getBody().empty()) {
649 return emitError(loc) <<
"unexpected layout attribute for struct " << key;
652 if (values.size() == 1)
657 return emitError(loc) <<
"preferred alignment is expected to be at least "
658 "as large as ABI alignment";
661 return mlir::success();
671 bool LLVM::LLVMTargetExtType::hasProperty(Property prop)
const {
673 uint64_t properties = 0;
677 (LLVMTargetExtType::HasZeroInit | LLVM::LLVMTargetExtType::CanBeGlobal);
679 return (properties & prop) == prop;
682 bool LLVM::LLVMTargetExtType::supportsMemOps()
const {
697 const llvm::fltSemantics &LLVMPPCFP128Type::getFloatSemantics()
const {
698 return APFloat::PPCDoubleDouble();
731 if (
auto intType = llvm::dyn_cast<IntegerType>(type))
732 return intType.isSignless();
735 if (
auto vecType = llvm::dyn_cast<VectorType>(type))
736 return vecType.getRank() == 1;
742 if (!compatibleTypes.insert(type).second)
745 auto isCompatible = [&](
Type type) {
751 .Case<LLVMStructType>([&](
auto structType) {
752 return llvm::all_of(structType.getBody(), isCompatible);
754 .Case<LLVMFunctionType>([&](
auto funcType) {
755 return isCompatible(funcType.getReturnType()) &&
756 llvm::all_of(funcType.getParams(), isCompatible);
758 .Case<IntegerType>([](
auto intType) {
return intType.isSignless(); })
759 .Case<VectorType>([&](
auto vecType) {
760 return vecType.getRank() == 1 &&
761 isCompatible(vecType.getElementType());
763 .Case<LLVMPointerType>([&](
auto pointerType) {
return true; })
764 .Case<LLVMTargetExtType>([&](
auto extType) {
765 return llvm::all_of(extType.getTypeParams(), isCompatible);
770 >([&](
auto containerType) {
771 return isCompatible(containerType.getElementType());
786 >([](
Type) {
return true; })
788 .Default([](
Type) {
return false; });
791 compatibleTypes.erase(type);
797 if (
auto *llvmDialect =
810 return llvm::isa<BFloat16Type, Float16Type, Float32Type, Float64Type,
811 Float80Type, Float128Type, LLVMPPCFP128Type>(type);
815 if (
auto vecType = llvm::dyn_cast<VectorType>(type)) {
816 if (vecType.getRank() != 1)
818 Type elementType = vecType.getElementType();
819 if (
auto intType = llvm::dyn_cast<IntegerType>(elementType))
820 return intType.isSignless();
821 return llvm::isa<BFloat16Type, Float16Type, Float32Type, Float64Type,
822 Float80Type, Float128Type, LLVMPointerType>(elementType);
828 auto vecTy = dyn_cast<VectorType>(type);
829 assert(vecTy &&
"incompatible with LLVM vector type");
830 if (vecTy.isScalable())
831 return llvm::ElementCount::getScalable(vecTy.getNumElements());
832 return llvm::ElementCount::getFixed(vecTy.getNumElements());
836 assert(llvm::isa<VectorType>(vectorType) &&
837 "expected LLVM-compatible vector type");
838 return llvm::cast<VectorType>(vectorType).isScalable();
843 assert(VectorType::isValidElementType(elementType) &&
844 "incompatible element type");
849 const llvm::ElementCount &numElements) {
850 if (numElements.isScalable())
851 return getVectorType(elementType, numElements.getKnownMinValue(),
853 return getVectorType(elementType, numElements.getFixedValue(),
859 "expected a type compatible with the LLVM dialect");
862 .Case<BFloat16Type, Float16Type>(
863 [](
Type) {
return llvm::TypeSize::getFixed(16); })
864 .Case<Float32Type>([](
Type) {
return llvm::TypeSize::getFixed(32); })
865 .Case<Float64Type>([](
Type) {
return llvm::TypeSize::getFixed(64); })
866 .Case<Float80Type>([](
Type) {
return llvm::TypeSize::getFixed(80); })
867 .Case<Float128Type>([](
Type) {
return llvm::TypeSize::getFixed(128); })
868 .Case<IntegerType>([](IntegerType intTy) {
869 return llvm::TypeSize::getFixed(intTy.getWidth());
871 .Case<LLVMPPCFP128Type>(
872 [](
Type) {
return llvm::TypeSize::getFixed(128); })
873 .Case<VectorType>([](VectorType t) {
875 "unexpected incompatible with LLVM vector type");
876 llvm::TypeSize elementSize =
878 return llvm::TypeSize(elementSize.getFixedValue() * t.getNumElements(),
879 elementSize.isScalable());
881 .Default([](
Type ty) {
882 assert((llvm::isa<LLVMVoidType, LLVMLabelType, LLVMMetadataType,
883 LLVMTokenType, LLVMStructType, LLVMArrayType,
884 LLVMPointerType, LLVMFunctionType, LLVMTargetExtType>(
886 "unexpected missing support for primitive type");
887 return llvm::TypeSize::getFixed(0);
895 void LLVMDialect::registerTypes() {
897 #define GET_TYPEDEF_LIST
898 #include "mlir/Dialect/LLVMIR/LLVMTypes.cpp.inc"
static LogicalResult verifyEntries(function_ref< InFlightDiagnostic()> emitError, ArrayRef< DataLayoutEntryInterface > entries, bool allowTypes=true)
Verify entries, with the option to disallow types as keys.
static uint64_t getIndexBitwidth(DataLayoutEntryListRef params)
Returns the bitwidth of the index type if specified in the param list.
static MLIRContext * getContext(OpFoldResult val)
static int64_t getNumElements(Type t)
Compute the total number of elements in the given type, also taking into account nested types.
constexpr static const uint64_t kDefaultPointerAlignment
static void printExtTypeParams(AsmPrinter &p, ArrayRef< Type > typeParams, ArrayRef< unsigned int > intParams)
constexpr static const uint64_t kDefaultPointerSizeBits
static LLVM_ATTRIBUTE_UNUSED OptionalParseResult generatedTypeParser(AsmParser &parser, StringRef *mnemonic, Type &value)
These are unused for now.
static void printFunctionTypes(AsmPrinter &p, ArrayRef< Type > params, bool isVarArg)
static bool isCompatibleImpl(Type type, DenseSet< Type > &compatibleTypes)
static ParseResult parseExtTypeParams(AsmParser &p, SmallVectorImpl< Type > &typeParams, SmallVectorImpl< unsigned int > &intParams)
Parses the parameter list for a target extension type.
static LLVM_ATTRIBUTE_UNUSED LogicalResult generatedTypePrinter(Type def, AsmPrinter &printer)
static constexpr llvm::StringRef kSpirvPrefix
static ParseResult parseFunctionTypes(AsmParser &p, SmallVector< Type > ¶ms, bool &isVarArg)
constexpr static const uint64_t kBitsInByte
static constexpr llvm::StringRef kArmSVCount
static std::optional< uint64_t > getPointerDataLayoutEntry(DataLayoutEntryListRef params, LLVMPointerType type, PtrDLEntryPos pos)
Returns the part of the data layout entry that corresponds to pos for the given type by interpreting ...
static std::optional< uint64_t > getStructDataLayoutEntry(DataLayoutEntryListRef params, LLVMStructType type, StructDLEntryPos pos)
static uint64_t extractStructSpecValue(Attribute attr, StructDLEntryPos pos)
static uint64_t calculateStructAlignment(const DataLayout &dataLayout, DataLayoutEntryListRef params, LLVMStructType type, StructDLEntryPos pos)
static SmallVector< Type > getReturnTypes(SmallVector< func::ReturnOp > returnOps)
Helper function that returns the return types (skipping casts) of the given func.return ops.
static Value max(ImplicitLocOpBuilder &builder, Value value, Value bound)
static Type getElementType(Type type, ArrayRef< int32_t > indices, function_ref< InFlightDiagnostic(StringRef)> emitErrorFn)
Walks the given type hierarchy with the given indices, potentially down to component granularity,...
This base class exposes generic asm parser hooks, usable across the various derived parsers.
virtual OptionalParseResult parseOptionalInteger(APInt &result)=0
Parse an optional integer value from the stream.
virtual ParseResult parseCommaSeparatedList(Delimiter delimiter, function_ref< ParseResult()> parseElementFn, StringRef contextMessage=StringRef())=0
Parse a list of comma-separated items with an optional delimiter.
virtual ParseResult parseRParen()=0
Parse a ) token.
virtual InFlightDiagnostic emitError(SMLoc loc, const Twine &message={})=0
Emit a diagnostic at the specified location and return failure.
virtual ParseResult parseOptionalRParen()=0
Parse a ) token if present.
virtual SMLoc getCurrentLocation()=0
Get the location of the next token and store it into the argument.
virtual ParseResult parseOptionalComma()=0
Parse a , token if present.
virtual ParseResult parseOptionalEllipsis()=0
Parse a ... token if present;.
This base class exposes generic asm printer hooks, usable across the various derived printers.
Attributes are known-constant values of operations.
The main mechanism for performing data layout queries.
std::optional< uint64_t > getTypeIndexBitwidth(Type t) const
Returns the bitwidth that should be used when performing index computations for the given pointer-lik...
llvm::TypeSize getTypeSize(Type t) const
Returns the size of the given type in the current scope.
uint64_t getTypePreferredAlignment(Type t) const
Returns the preferred of the given type in the current scope.
uint64_t getTypeABIAlignment(Type t) const
Returns the required alignment of the given type in the current scope.
llvm::TypeSize getTypeSizeInBits(Type t) const
Returns the size in bits of the given type in the current scope.
The DialectAsmParser has methods for interacting with the asm parser when parsing attributes and type...
This is a pure-virtual base class that exposes the asmprinter hooks necessary to implement a custom p...
This class represents a diagnostic that is inflight and set to be reported.
This class defines the main interface for locations in MLIR and acts as a non-nullable wrapper around...
MLIRContext is the top-level object for a collection of MLIR operations.
Dialect * getLoadedDialect(StringRef name)
Get a registered IR dialect with the given namespace.
This class implements Optional functionality for ParseResult.
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...
MLIRContext * getContext() const
Return the MLIRContext in which this type was uniqued.
void printType(Type type, AsmPrinter &printer)
Prints an LLVM Dialect type.
Type parseType(DialectAsmParser &parser)
Parses an LLVM dialect type.
Type getVectorType(Type elementType, unsigned numElements, bool isScalable=false)
Creates an LLVM dialect-compatible vector type with the given element type and length.
llvm::TypeSize getPrimitiveTypeSizeInBits(Type type)
Returns the size of the given primitive LLVM dialect-compatible type (including vectors) in bits,...
void printPrettyLLVMType(AsmPrinter &p, Type type)
Print any MLIR type or a concise syntax for LLVM types.
bool isScalableVectorType(Type vectorType)
Returns whether a vector type is scalable or not.
ParseResult parsePrettyLLVMType(AsmParser &p, Type &type)
Parse any MLIR type or a concise syntax for LLVM types.
bool isCompatibleVectorType(Type type)
Returns true if the given type is a vector type compatible with the LLVM dialect.
bool isCompatibleOuterType(Type type)
Returns true if the given outer type is compatible with the LLVM dialect without checking its potenti...
PtrDLEntryPos
The positions of different values in the data layout entry for pointers.
std::optional< uint64_t > extractPointerSpecValue(Attribute attr, PtrDLEntryPos pos)
Returns the value that corresponds to named position pos from the data layout entry attr assuming it'...
bool isCompatibleType(Type type)
Returns true if the given type is compatible with the LLVM dialect.
bool isCompatibleFloatingPointType(Type type)
Returns true if the given type is a floating-point type compatible with the LLVM dialect.
llvm::ElementCount getVectorNumElements(Type type)
Returns the element count of any LLVM-compatible vector type.
Include the generated interface declarations.
InFlightDiagnostic emitError(Location loc)
Utility method to emit an error message using this location.
Operation * clone(OpBuilder &b, Operation *op, TypeRange newResultTypes, ValueRange newOperands)
auto get(MLIRContext *context, Ts &&...params)
Helper method that injects context only if needed, this helps unify some of the attribute constructio...
Type parseType(llvm::StringRef typeStr, MLIRContext *context, size_t *numRead=nullptr, bool isKnownNullTerminated=false)
This parses a single MLIR type to an MLIR context if it was valid.
::llvm::MapVector<::mlir::StringAttr, ::mlir::DataLayoutEntryInterface > DataLayoutIdentifiedEntryMap
LogicalResult verify(Operation *op, bool verifyRecursively=true)
Perform (potentially expensive) checks of invariants, used to detect compiler bugs,...