14 #include "llvm/ADT/ScopeExit.h"
15 #include "llvm/Support/Threading.h"
31 return *recursiveStack->second;
39 return *recursiveStackInserted.first->second;
51 : llvmDialect(ctx->getOrLoadDialect<LLVM::LLVMDialect>()),
options(
options),
52 dataLayoutAnalysis(analysis) {
53 assert(
llvmDialect &&
"LLVM IR dialect is not registered");
56 addConversion([&](ComplexType type) {
return convertComplexType(type); });
58 addConversion([&](FunctionType type) {
return convertFunctionType(type); });
59 addConversion([&](IndexType type) {
return convertIndexType(type); });
60 addConversion([&](IntegerType type) {
return convertIntegerType(type); });
61 addConversion([&](MemRefType type) {
return convertMemRefType(type); });
80 -> std::optional<LogicalResult> {
83 results.push_back(type);
87 if (type.isIdentified()) {
89 type.getContext(), (
"_Converted." + type.getName()).str());
92 if (llvm::count(recursiveStack, type)) {
93 results.push_back(convertedType);
96 recursiveStack.push_back(type);
97 auto popConversionCallStack = llvm::make_scope_exit(
98 [&recursiveStack]() { recursiveStack.pop_back(); });
101 convertedElemTypes.reserve(type.getBody().size());
107 if (!convertedType.isInitialized()) {
109 convertedType.setBody(convertedElemTypes, type.isPacked()))) {
112 results.push_back(convertedType);
120 convertedType.isPacked() == type.isPacked()) {
121 results.push_back(convertedType);
129 convertedSubtypes.reserve(type.getBody().size());
134 type.getContext(), convertedSubtypes, type.isPacked()));
137 addConversion([&](LLVM::LLVMArrayType type) -> std::optional<Type> {
138 if (
auto element =
convertType(type.getElementType()))
142 addConversion([&](LLVM::LLVMFunctionType type) -> std::optional<Type> {
144 if (!convertedResType)
148 convertedArgTypes.reserve(type.getNumParams());
161 Location loc) -> std::optional<Value> {
162 if (inputs.size() == 1)
169 Location loc) -> std::optional<Value> {
172 if (inputs.size() == 1)
180 Location loc) -> std::optional<Value> {
181 if (inputs.size() != 1)
184 return builder.
create<UnrealizedConversionCastOp>(loc, resultType, inputs)
189 Location loc) -> std::optional<Value> {
190 if (inputs.size() != 1)
193 return builder.
create<UnrealizedConversionCastOp>(loc, resultType, inputs)
199 [](
BaseMemRefType memref, IntegerAttr addrspace) {
return addrspace; });
212 return options.
dataLayout.getPointerSizeInBits(addressSpace);
215 Type LLVMTypeConverter::convertIndexType(IndexType type)
const {
219 Type LLVMTypeConverter::convertIntegerType(IntegerType type)
const {
223 Type LLVMTypeConverter::convertFloatType(
FloatType type)
const {
234 Type LLVMTypeConverter::convertComplexType(ComplexType type)
const {
235 auto elementType =
convertType(type.getElementType());
237 {elementType, elementType});
242 Type LLVMTypeConverter::convertFunctionType(FunctionType type)
const {
251 FunctionType funcTy,
bool isVariadic,
bool useBarePtrCallConv,
260 if (
failed(funcArgConverter(*
this, type, converted)))
269 funcTy.getNumResults() == 0
280 std::pair<LLVM::LLVMFunctionType, LLVM::LLVMStructType>
284 Type resultType = type.getNumResults() == 0
291 auto structType = dyn_cast<LLVM::LLVMStructType>(resultType);
295 inputs.push_back(ptrType);
299 for (
Type t : type.getInputs()) {
303 if (isa<MemRefType, UnrankedMemRefType>(t))
305 inputs.push_back(converted);
340 LLVMTypeConverter::getMemRefDescriptorFields(MemRefType type,
341 bool unpackAggregates)
const {
345 "conversion to strided form failed either due to non-strided layout "
346 "maps (which should have been normalized away) or other reasons");
355 if (
failed(addressSpace)) {
357 "conversion of memref memory space ")
358 << type.getMemorySpace()
359 <<
" to integer address space "
360 "failed. Consider adding memory space conversions.";
368 auto rank = type.getRank();
372 if (unpackAggregates)
373 results.insert(results.end(), 2 * rank, indexTy);
390 Type LLVMTypeConverter::convertMemRefType(MemRefType type)
const {
394 getMemRefDescriptorFields(type,
false);
408 LLVMTypeConverter::getUnrankedMemRefDescriptorFields()
const {
420 Type LLVMTypeConverter::convertUnrankedMemRefType(
425 getUnrankedMemRefDescriptorFields());
432 std::optional<Attribute> converted =
438 if (
auto explicitSpace = llvm::dyn_cast_if_present<IntegerAttr>(*converted))
439 return explicitSpace.getInt();
445 if (isa<UnrankedMemRefType>(type))
451 auto memrefTy = cast<MemRefType>(type);
452 if (!memrefTy.hasStaticShape())
460 for (int64_t stride : strides)
461 if (ShapedType::isDynamic(stride))
464 return !ShapedType::isDynamic(offset);
487 FailureOr<Type> LLVMTypeConverter::convertVectorType(VectorType type)
const {
488 auto elementType =
convertType(type.getElementType());
491 if (type.getShape().empty())
494 type.getScalableDims().back());
496 "expected vector type compatible with the LLVM dialect");
498 if (llvm::is_contained(type.getScalableDims().drop_back(),
true))
500 auto shape = type.getShape();
501 for (
int i = shape.size() - 2; i >= 0; --i)
512 Type type,
bool useBarePtrCallConv)
const {
513 if (useBarePtrCallConv)
514 if (
auto memrefTy = dyn_cast<BaseMemRefType>(type))
515 return convertMemRefToBarePtr(memrefTy);
526 assert(stdTypes.size() == values.size() &&
527 "The number of types and values doesn't match");
528 for (
unsigned i = 0, end = values.size(); i < end; ++i)
529 if (
auto memrefTy = dyn_cast<MemRefType>(stdTypes[i]))
531 memrefTy, values[i]);
539 assert(!types.empty() &&
"expected non-empty list of type");
540 if (types.size() == 1)
544 resultTypes.reserve(types.size());
545 for (
Type type : types) {
549 resultTypes.push_back(converted);
560 bool useBarePtrCallConv)
const {
561 assert(!types.empty() &&
"expected non-empty list of type");
564 if (types.size() == 1)
568 resultTypes.reserve(types.size());
569 for (
auto t : types) {
573 resultTypes.push_back(converted);
587 builder.
create<LLVM::AllocaOp>(loc, ptrType, operand.
getType(), one);
589 builder.
create<LLVM::StoreOp>(loc, operand, allocated);
596 bool useBarePtrCallConv)
const {
598 promotedOperands.reserve(operands.size());
600 for (
auto it : llvm::zip(opOperands, operands)) {
601 auto operand = std::get<0>(it);
602 auto llvmOperand = std::get<1>(it);
604 if (useBarePtrCallConv) {
607 if (dyn_cast<MemRefType>(operand.getType())) {
610 }
else if (isa<UnrankedMemRefType>(operand.getType())) {
611 llvm_unreachable(
"Unranked memrefs are not supported");
614 if (isa<UnrankedMemRefType>(operand.getType())) {
619 if (
auto memrefType = dyn_cast<MemRefType>(operand.getType())) {
626 promotedOperands.push_back(llvmOperand);
628 return promotedOperands;
638 if (
auto memref = dyn_cast<MemRefType>(type)) {
642 converter.getMemRefDescriptorFields(memref,
true);
643 if (converted.empty())
645 result.append(converted.begin(), converted.end());
648 if (isa<UnrankedMemRefType>(type)) {
649 auto converted = converter.getUnrankedMemRefDescriptorFields();
650 if (converted.empty())
652 result.append(converted.begin(), converted.end());
658 result.push_back(converted);
672 result.push_back(llvmTy);
static llvm::ManagedStatic< PassManagerOptions > options
This class provides a shared interface for ranked and unranked memref types.
Attribute getMemorySpace() const
Returns the memory space in which data referred to by this memref resides.
Type getElementType() const
Returns the element type of this memref type.
IntegerAttr getIndexAttr(int64_t value)
MLIRContext * getContext() const
This class implements a pattern rewriter for use with ConversionPatterns.
Stores data layout objects for each operation that specifies the data layout above and below the give...
The main mechanism for performing data layout queries.
llvm::TypeSize getTypeSize(Type t) const
Returns the size of the given type in the current scope.
This class provides support for representing a failure result, or a valid value of type T.
unsigned getWidth()
Return the bitwidth of this float type.
Conversion from types to the LLVM IR dialect.
LLVM::LLVMDialect * llvmDialect
Pointer to the LLVM dialect.
llvm::sys::SmartRWMutex< true > callStackMutex
Type packOperationResults(TypeRange types) const
Convert a non-empty list of types of values produced by an operation into an LLVM-compatible type.
LLVM::LLVMDialect * getDialect() const
Returns the LLVM dialect.
Type packFunctionResults(TypeRange types, bool useBarePointerCallConv=false) const
Convert a non-empty list of types to be returned from a function into an LLVM-compatible type.
unsigned getUnrankedMemRefDescriptorSize(UnrankedMemRefType type, const DataLayout &layout) const
Returns the size of the unranked memref descriptor object in bytes.
Type convertFunctionSignature(FunctionType funcTy, bool isVariadic, bool useBarePtrCallConv, SignatureConversion &result) const
Convert a function type.
void promoteBarePtrsToDescriptors(ConversionPatternRewriter &rewriter, Location loc, ArrayRef< Type > stdTypes, SmallVectorImpl< Value > &values) const
Promote the bare pointers in 'values' that resulted from memrefs to descriptors.
DenseMap< uint64_t, std::unique_ptr< SmallVector< Type > > > conversionCallStack
SmallVector< Type > & getCurrentThreadRecursiveStack()
Value promoteOneMemRefDescriptor(Location loc, Value operand, OpBuilder &builder) const
Promote the LLVM struct representation of one MemRef descriptor to stack and use pointer to struct to...
Type convertCallingConventionType(Type type, bool useBarePointerCallConv=false) const
Convert a type in the context of the default or bare pointer calling convention.
LogicalResult convertType(Type t, SmallVectorImpl< Type > &results) const
Convert the given type.
SmallVector< Value, 4 > promoteOperands(Location loc, ValueRange opOperands, ValueRange operands, OpBuilder &builder, bool useBarePtrCallConv=false) const
Promote the LLVM representation of all operands including promoting MemRef descriptors to stack and u...
LLVMTypeConverter(MLIRContext *ctx, const DataLayoutAnalysis *analysis=nullptr)
Create an LLVMTypeConverter using the default LowerToLLVMOptions.
unsigned getPointerBitwidth(unsigned addressSpace=0) const
Gets the pointer bitwidth.
FailureOr< unsigned > getMemRefAddressSpace(BaseMemRefType type) const
Return the LLVM address space corresponding to the memory space of the memref type type or failure if...
static bool canConvertToBarePtr(BaseMemRefType type)
Check if a memref type can be converted to a bare pointer.
MLIRContext & getContext() const
Returns the MLIR context.
unsigned getMemRefDescriptorSize(MemRefType type, const DataLayout &layout) const
Returns the size of the memref descriptor object in bytes.
std::pair< LLVM::LLVMFunctionType, LLVM::LLVMStructType > convertFunctionTypeCWrapper(FunctionType type) const
Converts the function type to a C-compatible format, in particular using pointers to memref descripto...
unsigned getIndexTypeBitwidth() const
Gets the bitwidth of the index type when converted to LLVM.
Type getIndexType() const
Gets the LLVM representation of the index type.
friend LogicalResult structFuncArgTypeConverter(const LLVMTypeConverter &converter, Type type, SmallVectorImpl< Type > &result)
Give structFuncArgTypeConverter access to memref-specific functions.
LLVM dialect structure type representing a collection of different-typed elements manipulated togethe...
static LLVMStructType getLiteral(MLIRContext *context, ArrayRef< Type > types, bool isPacked=false)
Gets or creates a literal struct with the given body in the provided context.
static LLVMStructType getIdentified(MLIRContext *context, StringRef name)
Gets or creates an identified struct with the given name in the provided context.
This class defines the main interface for locations in MLIR and acts as a non-nullable wrapper around...
Options to control the LLVM lowering.
llvm::DataLayout dataLayout
The data layout of the module to produce.
MLIRContext is the top-level object for a collection of MLIR operations.
Helper class to produce LLVM dialect operations extracting or inserting elements of a MemRef descript...
static Value pack(OpBuilder &builder, Location loc, const LLVMTypeConverter &converter, MemRefType type, ValueRange values)
Builds IR populating a MemRef descriptor structure from a list of individual values composing that de...
Value alignedPtr(OpBuilder &builder, Location loc)
Builds IR extracting the aligned pointer from the descriptor.
static void unpack(OpBuilder &builder, Location loc, Value packed, MemRefType type, SmallVectorImpl< Value > &results)
Builds IR extracting individual elements of a MemRef descriptor structure and returning them as resul...
static MemRefDescriptor fromStaticShape(OpBuilder &builder, Location loc, const LLVMTypeConverter &typeConverter, MemRefType type, Value memory)
Builds IR creating a MemRef descriptor that represents type and populates it with static shape and st...
This class helps build Operations.
Operation * create(const OperationState &state)
Creates an operation given the fields represented as an OperationState.
OpResult getResult(unsigned idx)
Get the 'idx'th result of this operation.
This class provides all of the information necessary to convert a type signature.
void addInputs(unsigned origInputNo, ArrayRef< Type > types)
Remap an input of the original signature with a new set of types.
ArrayRef< Type > getConvertedTypes() const
Return the argument types for the new signature.
std::optional< Attribute > convertTypeAttribute(Type type, Attribute attr) const
Convert an attribute present attr from within the type type using the registered conversion functions...
void addConversion(FnT &&callback)
Register a conversion function.
void addArgumentMaterialization(FnT &&callback)
Register a materialization function, which must be convertible to the following form: std::optional<V...
void addSourceMaterialization(FnT &&callback)
This method registers a materialization that will be called when converting a legal type to an illega...
void addTypeAttributeConversion(FnT &&callback)
Register a conversion function for attributes within types.
void addTargetMaterialization(FnT &&callback)
This method registers a materialization that will be called when converting type from an illegal,...
LogicalResult convertTypes(TypeRange types, SmallVectorImpl< Type > &results) const
Convert the given set of types, filling 'results' as necessary.
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.
bool isFloat8E4M3FN() const
bool isFloat8E4M3FNUZ() const
bool isFloat8E4M3B11FNUZ() const
bool isFloat8E5M2() const
bool isFloat8E5M2FNUZ() const
static Value pack(OpBuilder &builder, Location loc, const LLVMTypeConverter &converter, UnrankedMemRefType type, ValueRange values)
Builds IR populating an unranked MemRef descriptor structure from a list of individual constituent va...
static void unpack(OpBuilder &builder, Location loc, Value packed, SmallVectorImpl< Value > &results)
Builds IR extracting individual elements that compose an unranked memref descriptor and returns them ...
This class provides an abstraction over the different types of ranges over Values.
This class represents an instance of an SSA value in the MLIR system, representing a computable value...
Type getType() const
Return the type of this value.
bool isCompatibleVectorType(Type type)
Returns true if the given type is a vector type compatible with the LLVM dialect.
bool isCompatibleType(Type type)
Returns true if the given type is compatible with the LLVM dialect.
constexpr void enumerate(std::tuple< Tys... > &tuple, CallbackT &&callback)
llvm::TypeSize divideCeil(llvm::TypeSize numerator, uint64_t denominator)
Divides the known min value of the numerator by the denominator and rounds the result up to the next ...
Include the generated interface declarations.
LogicalResult failure(bool isFailure=true)
Utility function to generate a LogicalResult.
LogicalResult barePtrFuncArgTypeConverter(const LLVMTypeConverter &converter, Type type, SmallVectorImpl< Type > &result)
Callback to convert function argument types.
InFlightDiagnostic emitError(Location loc)
Utility method to emit an error message using this location.
LogicalResult getStridesAndOffset(MemRefType t, SmallVectorImpl< int64_t > &strides, int64_t &offset)
Returns the strides of the MemRef if the layout map is in strided form.
LogicalResult structFuncArgTypeConverter(const LLVMTypeConverter &converter, Type type, SmallVectorImpl< Type > &result)
Callback to convert function argument types.
LogicalResult success(bool isSuccess=true)
Utility function to generate a LogicalResult.
auto get(MLIRContext *context, Ts &&...params)
Helper method that injects context only if needed, this helps unify some of the attribute constructio...
bool isStrided(MemRefType t)
Return "true" if the layout for t is compatible with strided semantics.
bool failed(LogicalResult result)
Utility function that returns true if the provided LogicalResult corresponds to a failure value.
This class represents an efficient way to signal success or failure.