[Mlir-commits] [mlir] b28a296 - [MLIR][MemRefToLLVM] Remove typed pointer support (#70909)
llvmlistbot at llvm.org
llvmlistbot at llvm.org
Wed Nov 1 23:36:02 PDT 2023
Author: Christian Ulmann
Date: 2023-11-02T07:35:58+01:00
New Revision: b28a296cdfb6309fed328e5a299d392a0a841ce1
URL: https://github.com/llvm/llvm-project/commit/b28a296cdfb6309fed328e5a299d392a0a841ce1
DIFF: https://github.com/llvm/llvm-project/commit/b28a296cdfb6309fed328e5a299d392a0a841ce1.diff
LOG: [MLIR][MemRefToLLVM] Remove typed pointer support (#70909)
This commit removes the support for lowering MemRefToLLVM to LLVM
dialect with typed pointers. Typed pointers have been deprecated for a
while now and it's planned to soon remove them from the LLVM dialect.
Related PSA:
https://discourse.llvm.org/t/psa-removal-of-typed-pointers-from-the-llvm-dialect/74502
Added:
Modified:
mlir/include/mlir/Conversion/LLVMCommon/MemRefBuilder.h
mlir/include/mlir/Conversion/Passes.td
mlir/include/mlir/Dialect/LLVMIR/FunctionCallUtils.h
mlir/lib/Conversion/LLVMCommon/MemRefBuilder.cpp
mlir/lib/Conversion/MemRefToLLVM/MemRefToLLVM.cpp
mlir/test/Conversion/MemRefToLLVM/convert-alloca-scope.mlir
mlir/test/Conversion/MemRefToLLVM/convert-dynamic-memref-ops.mlir
mlir/test/Conversion/MemRefToLLVM/convert-static-memref-ops.mlir
mlir/test/Conversion/MemRefToLLVM/expand-then-convert-to-llvm.mlir
mlir/test/Conversion/MemRefToLLVM/generic-functions.mlir
mlir/test/Conversion/MemRefToLLVM/memref-to-llvm.mlir
Removed:
mlir/test/Conversion/MemRefToLLVM/typed-pointers.mlir
################################################################################
diff --git a/mlir/include/mlir/Conversion/LLVMCommon/MemRefBuilder.h b/mlir/include/mlir/Conversion/LLVMCommon/MemRefBuilder.h
index ef8215d332c463c..e97675f37e10c28 100644
--- a/mlir/include/mlir/Conversion/LLVMCommon/MemRefBuilder.h
+++ b/mlir/include/mlir/Conversion/LLVMCommon/MemRefBuilder.h
@@ -120,8 +120,6 @@ class MemRefDescriptor : public StructBuilder {
static unsigned getNumUnpackedValues(MemRefType type);
private:
- bool useOpaquePointers();
-
// Cached index type.
Type indexType;
};
diff --git a/mlir/include/mlir/Conversion/Passes.td b/mlir/include/mlir/Conversion/Passes.td
index 93c9ed15340b97d..dae13bfecfafea4 100644
--- a/mlir/include/mlir/Conversion/Passes.td
+++ b/mlir/include/mlir/Conversion/Passes.td
@@ -746,10 +746,7 @@ def FinalizeMemRefToLLVMConversionPass :
"bool",
/*default=*/"false",
"Use generic allocation and deallocation functions instead of the "
- "classic 'malloc', 'aligned_alloc' and 'free' functions">,
- Option<"useOpaquePointers", "use-opaque-pointers", "bool",
- /*default=*/"true", "Generate LLVM IR using opaque pointers "
- "instead of typed pointers">
+ "classic 'malloc', 'aligned_alloc' and 'free' functions">
];
}
diff --git a/mlir/include/mlir/Dialect/LLVMIR/FunctionCallUtils.h b/mlir/include/mlir/Dialect/LLVMIR/FunctionCallUtils.h
index 05320c0c7186907..7289c3ac6ff7e1e 100644
--- a/mlir/include/mlir/Dialect/LLVMIR/FunctionCallUtils.h
+++ b/mlir/include/mlir/Dialect/LLVMIR/FunctionCallUtils.h
@@ -61,7 +61,7 @@ LLVM::LLVMFuncOp lookupOrCreateGenericAlignedAllocFn(ModuleOp moduleOp,
Type indexType,
bool opaquePointers);
LLVM::LLVMFuncOp lookupOrCreateGenericFreeFn(ModuleOp moduleOp,
- bool opaquePointers);
+ bool opaquePointers = true);
LLVM::LLVMFuncOp lookupOrCreateMemRefCopyFn(ModuleOp moduleOp, Type indexType,
Type unrankedDescriptorType);
diff --git a/mlir/lib/Conversion/LLVMCommon/MemRefBuilder.cpp b/mlir/lib/Conversion/LLVMCommon/MemRefBuilder.cpp
index 0a3c9a57eec95d3..023fd6244ce1afb 100644
--- a/mlir/lib/Conversion/LLVMCommon/MemRefBuilder.cpp
+++ b/mlir/lib/Conversion/LLVMCommon/MemRefBuilder.cpp
@@ -53,8 +53,7 @@ MemRefDescriptor MemRefDescriptor::fromStaticShape(
// Extract all strides and offsets and verify they are static.
auto [strides, offset] = getStridesAndOffset(type);
- assert(!ShapedType::isDynamic(offset) &&
- "expected static offset");
+ assert(!ShapedType::isDynamic(offset) && "expected static offset");
assert(!llvm::any_of(strides, ShapedType::isDynamic) &&
"expected static strides");
@@ -134,27 +133,19 @@ Value MemRefDescriptor::size(OpBuilder &builder, Location loc, Value pos,
int64_t rank) {
auto arrayTy = LLVM::LLVMArrayType::get(indexType, rank);
- LLVM::LLVMPointerType indexPtrTy;
- LLVM::LLVMPointerType arrayPtrTy;
-
- if (useOpaquePointers()) {
- arrayPtrTy = indexPtrTy = LLVM::LLVMPointerType::get(builder.getContext());
- } else {
- indexPtrTy = LLVM::LLVMPointerType::get(indexType);
- arrayPtrTy = LLVM::LLVMPointerType::get(arrayTy);
- }
+ auto ptrTy = LLVM::LLVMPointerType::get(builder.getContext());
// Copy size values to stack-allocated memory.
auto one = createIndexAttrConstant(builder, loc, indexType, 1);
auto sizes = builder.create<LLVM::ExtractValueOp>(
loc, value, llvm::ArrayRef<int64_t>({kSizePosInMemRefDescriptor}));
- auto sizesPtr = builder.create<LLVM::AllocaOp>(loc, arrayPtrTy, arrayTy, one,
+ auto sizesPtr = builder.create<LLVM::AllocaOp>(loc, ptrTy, arrayTy, one,
/*alignment=*/0);
builder.create<LLVM::StoreOp>(loc, sizes, sizesPtr);
// Load an return size value of interest.
- auto resultPtr = builder.create<LLVM::GEPOp>(
- loc, indexPtrTy, arrayTy, sizesPtr, ArrayRef<LLVM::GEPArg>{0, pos});
+ auto resultPtr = builder.create<LLVM::GEPOp>(loc, ptrTy, arrayTy, sizesPtr,
+ ArrayRef<LLVM::GEPArg>{0, pos});
return builder.create<LLVM::LoadOp>(loc, indexType, resultPtr);
}
@@ -273,10 +264,6 @@ unsigned MemRefDescriptor::getNumUnpackedValues(MemRefType type) {
return 3 + 2 * type.getRank();
}
-bool MemRefDescriptor::useOpaquePointers() {
- return getElementPtrType().isOpaque();
-}
-
//===----------------------------------------------------------------------===//
// MemRefDescriptorView implementation.
//===----------------------------------------------------------------------===//
@@ -413,44 +400,20 @@ void UnrankedMemRefDescriptor::computeSizes(
Value UnrankedMemRefDescriptor::allocatedPtr(
OpBuilder &builder, Location loc, Value memRefDescPtr,
LLVM::LLVMPointerType elemPtrType) {
-
- Value elementPtrPtr;
- if (elemPtrType.isOpaque())
- elementPtrPtr = memRefDescPtr;
- else
- elementPtrPtr = builder.create<LLVM::BitcastOp>(
- loc, LLVM::LLVMPointerType::get(elemPtrType), memRefDescPtr);
-
- return builder.create<LLVM::LoadOp>(loc, elemPtrType, elementPtrPtr);
+ return builder.create<LLVM::LoadOp>(loc, elemPtrType, memRefDescPtr);
}
void UnrankedMemRefDescriptor::setAllocatedPtr(
OpBuilder &builder, Location loc, Value memRefDescPtr,
LLVM::LLVMPointerType elemPtrType, Value allocatedPtr) {
- Value elementPtrPtr;
- if (elemPtrType.isOpaque())
- elementPtrPtr = memRefDescPtr;
- else
- elementPtrPtr = builder.create<LLVM::BitcastOp>(
- loc, LLVM::LLVMPointerType::get(elemPtrType), memRefDescPtr);
-
- builder.create<LLVM::StoreOp>(loc, allocatedPtr, elementPtrPtr);
+ builder.create<LLVM::StoreOp>(loc, allocatedPtr, memRefDescPtr);
}
static std::pair<Value, Type>
castToElemPtrPtr(OpBuilder &builder, Location loc, Value memRefDescPtr,
LLVM::LLVMPointerType elemPtrType) {
- Value elementPtrPtr;
- Type elemPtrPtrType;
- if (elemPtrType.isOpaque()) {
- elementPtrPtr = memRefDescPtr;
- elemPtrPtrType = LLVM::LLVMPointerType::get(builder.getContext());
- } else {
- elemPtrPtrType = LLVM::LLVMPointerType::get(elemPtrType);
- elementPtrPtr =
- builder.create<LLVM::BitcastOp>(loc, elemPtrPtrType, memRefDescPtr);
- }
- return {elementPtrPtr, elemPtrPtrType};
+ auto elemPtrPtrType = LLVM::LLVMPointerType::get(builder.getContext());
+ return {memRefDescPtr, elemPtrPtrType};
}
Value UnrankedMemRefDescriptor::alignedPtr(
@@ -483,16 +446,8 @@ Value UnrankedMemRefDescriptor::offsetBasePtr(
auto [elementPtrPtr, elemPtrPtrType] =
castToElemPtrPtr(builder, loc, memRefDescPtr, elemPtrType);
- Value offsetGep =
- builder.create<LLVM::GEPOp>(loc, elemPtrPtrType, elemPtrType,
- elementPtrPtr, ArrayRef<LLVM::GEPArg>{2});
-
- if (!elemPtrType.isOpaque()) {
- offsetGep = builder.create<LLVM::BitcastOp>(
- loc, LLVM::LLVMPointerType::get(typeConverter.getIndexType()),
- offsetGep);
- }
- return offsetGep;
+ return builder.create<LLVM::GEPOp>(loc, elemPtrPtrType, elemPtrType,
+ elementPtrPtr, ArrayRef<LLVM::GEPArg>{2});
}
Value UnrankedMemRefDescriptor::offset(OpBuilder &builder, Location loc,
@@ -521,19 +476,8 @@ Value UnrankedMemRefDescriptor::sizeBasePtr(
Type indexTy = typeConverter.getIndexType();
Type structTy = LLVM::LLVMStructType::getLiteral(
indexTy.getContext(), {elemPtrType, elemPtrType, indexTy, indexTy});
- Value structPtr;
- if (elemPtrType.isOpaque()) {
- structPtr = memRefDescPtr;
- } else {
- Type structPtrTy = LLVM::LLVMPointerType::get(structTy);
- structPtr =
- builder.create<LLVM::BitcastOp>(loc, structPtrTy, memRefDescPtr);
- }
-
- auto resultType = elemPtrType.isOpaque()
- ? LLVM::LLVMPointerType::get(indexTy.getContext())
- : LLVM::LLVMPointerType::get(indexTy);
- return builder.create<LLVM::GEPOp>(loc, resultType, structTy, structPtr,
+ auto resultType = LLVM::LLVMPointerType::get(builder.getContext());
+ return builder.create<LLVM::GEPOp>(loc, resultType, structTy, memRefDescPtr,
ArrayRef<LLVM::GEPArg>{0, 3});
}
diff --git a/mlir/lib/Conversion/MemRefToLLVM/MemRefToLLVM.cpp b/mlir/lib/Conversion/MemRefToLLVM/MemRefToLLVM.cpp
index e9efcedec0e14e4..91b1210efec23e0 100644
--- a/mlir/lib/Conversion/MemRefToLLVM/MemRefToLLVM.cpp
+++ b/mlir/lib/Conversion/MemRefToLLVM/MemRefToLLVM.cpp
@@ -46,10 +46,9 @@ LLVM::LLVMFuncOp getFreeFn(const LLVMTypeConverter *typeConverter,
bool useGenericFn = typeConverter->getOptions().useGenericFunctions;
if (useGenericFn)
- return LLVM::lookupOrCreateGenericFreeFn(
- module, typeConverter->useOpaquePointers());
+ return LLVM::lookupOrCreateGenericFreeFn(module);
- return LLVM::lookupOrCreateFreeFn(module, typeConverter->useOpaquePointers());
+ return LLVM::lookupOrCreateFreeFn(module);
}
struct AllocOpLowering : public AllocLikeOpLLVMLowering {
@@ -108,7 +107,7 @@ struct AllocaOpLowering : public AllocLikeOpLLVMLowering {
unsigned addrSpace =
*getTypeConverter()->getMemRefAddressSpace(allocaOp.getType());
auto elementPtrType =
- getTypeConverter()->getPointerType(elementType, addrSpace);
+ LLVM::LLVMPointerType::get(rewriter.getContext(), addrSpace);
auto allocatedElementPtr =
rewriter.create<LLVM::AllocaOp>(loc, elementPtrType, elementType, size,
@@ -232,10 +231,8 @@ struct DeallocOpLowering : public ConvertOpToLLVMPattern<memref::DeallocOp> {
Value allocatedPtr;
if (auto unrankedTy =
llvm::dyn_cast<UnrankedMemRefType>(op.getMemref().getType())) {
- Type elementType = unrankedTy.getElementType();
- Type llvmElementTy = getTypeConverter()->convertType(elementType);
- LLVM::LLVMPointerType elementPtrTy = getTypeConverter()->getPointerType(
- llvmElementTy, unrankedTy.getMemorySpaceAsInt());
+ auto elementPtrTy = LLVM::LLVMPointerType::get(
+ rewriter.getContext(), unrankedTy.getMemorySpaceAsInt());
allocatedPtr = UnrankedMemRefDescriptor::allocatedPtr(
rewriter, op.getLoc(),
UnrankedMemRefDescriptor(adaptor.getMemref())
@@ -245,10 +242,6 @@ struct DeallocOpLowering : public ConvertOpToLLVMPattern<memref::DeallocOp> {
allocatedPtr = MemRefDescriptor(adaptor.getMemref())
.allocatedPtr(rewriter, op.getLoc());
}
- if (!getTypeConverter()->useOpaquePointers())
- allocatedPtr = rewriter.create<LLVM::BitcastOp>(
- op.getLoc(), getVoidPtrType(), allocatedPtr);
-
rewriter.replaceOpWithNewOp<LLVM::CallOp>(op, freeFunc, allocatedPtr);
return success();
}
@@ -306,19 +299,12 @@ struct DimOpLowering : public ConvertOpToLLVMPattern<memref::DimOp> {
Value underlyingRankedDesc = unrankedDesc.memRefDescPtr(rewriter, loc);
Type elementType = typeConverter->convertType(scalarMemRefType);
- Value scalarMemRefDescPtr;
- if (getTypeConverter()->useOpaquePointers())
- scalarMemRefDescPtr = underlyingRankedDesc;
- else
- scalarMemRefDescPtr = rewriter.create<LLVM::BitcastOp>(
- loc, LLVM::LLVMPointerType::get(elementType, addressSpace),
- underlyingRankedDesc);
// Get pointer to offset field of memref<element_type> descriptor.
- Type indexPtrTy = getTypeConverter()->getPointerType(
- getTypeConverter()->getIndexType(), addressSpace);
+ auto indexPtrTy =
+ LLVM::LLVMPointerType::get(rewriter.getContext(), addressSpace);
Value offsetPtr = rewriter.create<LLVM::GEPOp>(
- loc, indexPtrTy, elementType, scalarMemRefDescPtr,
+ loc, indexPtrTy, elementType, underlyingRankedDesc,
ArrayRef<LLVM::GEPArg>{0, 2});
// The size value that we have to extract can be obtained using GEPop with
@@ -569,18 +555,14 @@ struct GetGlobalMemrefOpLowering : public AllocLikeOpLLVMLowering {
unsigned memSpace = *maybeAddressSpace;
Type arrayTy = convertGlobalMemrefTypeToLLVM(type, *getTypeConverter());
- Type resTy = getTypeConverter()->getPointerType(arrayTy, memSpace);
+ auto ptrTy = LLVM::LLVMPointerType::get(rewriter.getContext(), memSpace);
auto addressOf =
- rewriter.create<LLVM::AddressOfOp>(loc, resTy, getGlobalOp.getName());
+ rewriter.create<LLVM::AddressOfOp>(loc, ptrTy, getGlobalOp.getName());
// Get the address of the first element in the array by creating a GEP with
// the address of the GV as the base, and (rank + 1) number of 0 indices.
- Type elementType = typeConverter->convertType(type.getElementType());
- Type elementPtrType =
- getTypeConverter()->getPointerType(elementType, memSpace);
-
auto gep = rewriter.create<LLVM::GEPOp>(
- loc, elementPtrType, arrayTy, addressOf,
+ loc, ptrTy, arrayTy, addressOf,
SmallVector<LLVM::GEPArg>(type.getRank() + 1, 0));
// We do not expect the memref obtained using `memref.get_global` to be
@@ -590,7 +572,7 @@ struct GetGlobalMemrefOpLowering : public AllocLikeOpLLVMLowering {
Value deadBeefConst =
createIndexAttrConstant(rewriter, op->getLoc(), intPtrType, 0xdeadbeef);
auto deadBeefPtr =
- rewriter.create<LLVM::IntToPtrOp>(loc, elementPtrType, deadBeefConst);
+ rewriter.create<LLVM::IntToPtrOp>(loc, ptrTy, deadBeefConst);
// Both allocated and aligned pointers are same. We could potentially stash
// a nullptr for the allocated pointer since we do not expect any dealloc.
@@ -734,13 +716,6 @@ struct MemRefCastOpLowering : public ConvertOpToLLVMPattern<memref::CastOp> {
auto ptr = getTypeConverter()->promoteOneMemRefDescriptor(
loc, adaptor.getSource(), rewriter);
- // voidptr = BitCastOp srcType* to void*
- Value voidPtr;
- if (getTypeConverter()->useOpaquePointers())
- voidPtr = ptr;
- else
- voidPtr = rewriter.create<LLVM::BitcastOp>(loc, getVoidPtrType(), ptr);
-
// rank = ConstantOp srcRank
auto rankVal = rewriter.create<LLVM::ConstantOp>(
loc, getIndexType(), rewriter.getIndexAttr(rank));
@@ -749,8 +724,8 @@ struct MemRefCastOpLowering : public ConvertOpToLLVMPattern<memref::CastOp> {
UnrankedMemRefDescriptor::undef(rewriter, loc, targetStructType);
// d1 = InsertValueOp undef, rank, 0
memRefDesc.setRank(rewriter, loc, rankVal);
- // d2 = InsertValueOp d1, voidptr, 1
- memRefDesc.setMemRefDescPtr(rewriter, loc, voidPtr);
+ // d2 = InsertValueOp d1, ptr, 1
+ memRefDesc.setMemRefDescPtr(rewriter, loc, ptr);
rewriter.replaceOp(memRefCastOp, (Value)memRefDesc);
} else if (isa<UnrankedMemRefType>(srcType) && isa<MemRefType>(dstType)) {
@@ -760,17 +735,9 @@ struct MemRefCastOpLowering : public ConvertOpToLLVMPattern<memref::CastOp> {
UnrankedMemRefDescriptor memRefDesc(adaptor.getSource());
// ptr = ExtractValueOp src, 1
auto ptr = memRefDesc.memRefDescPtr(rewriter, loc);
- // castPtr = BitCastOp i8* to structTy*
- Value castPtr;
- if (getTypeConverter()->useOpaquePointers())
- castPtr = ptr;
- else
- castPtr = rewriter.create<LLVM::BitcastOp>(
- loc, LLVM::LLVMPointerType::get(targetStructType), ptr);
- // struct = LoadOp castPtr
- auto loadOp =
- rewriter.create<LLVM::LoadOp>(loc, targetStructType, castPtr);
+ // struct = LoadOp ptr
+ auto loadOp = rewriter.create<LLVM::LoadOp>(loc, targetStructType, ptr);
rewriter.replaceOp(memRefCastOp, loadOp.getResult());
} else {
llvm_unreachable("Unsupported unranked memref to unranked memref cast");
@@ -841,17 +808,10 @@ struct MemRefCopyOpLowering : public ConvertOpToLLVMPattern<memref::CopyOp> {
auto ptr =
typeConverter->promoteOneMemRefDescriptor(loc, ranked, rewriter);
- Value voidPtr;
- if (getTypeConverter()->useOpaquePointers())
- voidPtr = ptr;
- else
- voidPtr = rewriter.create<LLVM::BitcastOp>(loc, getVoidPtrType(), ptr);
-
auto unrankedType =
UnrankedMemRefType::get(type.getElementType(), type.getMemorySpace());
- return UnrankedMemRefDescriptor::pack(rewriter, loc, *typeConverter,
- unrankedType,
- ValueRange{rank, voidPtr});
+ return UnrankedMemRefDescriptor::pack(
+ rewriter, loc, *typeConverter, unrankedType, ValueRange{rank, ptr});
};
// Save stack position before promoting descriptors
@@ -871,7 +831,7 @@ struct MemRefCopyOpLowering : public ConvertOpToLLVMPattern<memref::CopyOp> {
auto one = rewriter.create<LLVM::ConstantOp>(loc, getIndexType(),
rewriter.getIndexAttr(1));
auto promote = [&](Value desc) {
- Type ptrType = getTypeConverter()->getPointerType(desc.getType());
+ auto ptrType = LLVM::LLVMPointerType::get(rewriter.getContext());
auto allocated =
rewriter.create<LLVM::AllocaOp>(loc, ptrType, desc.getType(), one);
rewriter.create<LLVM::StoreOp>(loc, desc, allocated);
@@ -983,12 +943,10 @@ struct MemorySpaceCastOpLowering
result.setMemRefDescPtr(rewriter, loc, resultUnderlyingDesc);
// Copy pointers, performing address space casts.
- Type llvmElementType =
- typeConverter->convertType(sourceType.getElementType());
- LLVM::LLVMPointerType sourceElemPtrType =
- getTypeConverter()->getPointerType(llvmElementType, sourceAddrSpace);
+ auto sourceElemPtrType =
+ LLVM::LLVMPointerType::get(rewriter.getContext(), sourceAddrSpace);
auto resultElemPtrType =
- getTypeConverter()->getPointerType(llvmElementType, resultAddrSpace);
+ LLVM::LLVMPointerType::get(rewriter.getContext(), resultAddrSpace);
Value allocatedPtr = sourceDesc.allocatedPtr(
rewriter, loc, sourceUnderlyingDesc, sourceElemPtrType);
@@ -1053,10 +1011,8 @@ static void extractPointersAndOffset(Location loc,
// These will all cause assert()s on unconvertible types.
unsigned memorySpace = *typeConverter.getMemRefAddressSpace(
cast<UnrankedMemRefType>(operandType));
- Type elementType = cast<UnrankedMemRefType>(operandType).getElementType();
- Type llvmElementType = typeConverter.convertType(elementType);
- LLVM::LLVMPointerType elementPtrType =
- typeConverter.getPointerType(llvmElementType, memorySpace);
+ auto elementPtrType =
+ LLVM::LLVMPointerType::get(rewriter.getContext(), memorySpace);
// Extract pointer to the underlying ranked memref descriptor and cast it to
// ElemType**.
@@ -1254,7 +1210,6 @@ struct MemRefReshapeOpLowering
auto targetType = cast<UnrankedMemRefType>(reshapeOp.getResult().getType());
unsigned addressSpace =
*getTypeConverter()->getMemRefAddressSpace(targetType);
- Type elementType = targetType.getElementType();
// Create the unranked memref descriptor that holds the ranked one. The
// inner descriptor is allocated on stack.
@@ -1276,9 +1231,8 @@ struct MemRefReshapeOpLowering
&allocatedPtr, &alignedPtr, &offset);
// Set pointers and offset.
- Type llvmElementType = typeConverter->convertType(elementType);
- LLVM::LLVMPointerType elementPtrType =
- getTypeConverter()->getPointerType(llvmElementType, addressSpace);
+ auto elementPtrType =
+ LLVM::LLVMPointerType::get(rewriter.getContext(), addressSpace);
UnrankedMemRefDescriptor::setAllocatedPtr(rewriter, loc, underlyingDescPtr,
elementPtrType, allocatedPtr);
@@ -1328,7 +1282,7 @@ struct MemRefReshapeOpLowering
rewriter.setInsertionPointToStart(bodyBlock);
// Copy size from shape to descriptor.
- Type llvmIndexPtrType = getTypeConverter()->getPointerType(indexType);
+ auto llvmIndexPtrType = LLVM::LLVMPointerType::get(rewriter.getContext());
Value sizeLoadGep = rewriter.create<LLVM::GEPOp>(
loc, llvmIndexPtrType,
typeConverter->convertType(shapeMemRefType.getElementType()),
@@ -1430,9 +1384,9 @@ class TransposeOpLowering : public ConvertOpToLLVMPattern<memref::TransposeOp> {
targetMemRef.setOffset(rewriter, loc, viewMemRef.offset(rewriter, loc));
// Iterate over the dimensions and apply size/stride permutation:
- // When enumerating the results of the permutation map, the enumeration index
- // is the index into the target dimensions and the DimExpr points to the
- // dimension of the source memref.
+ // When enumerating the results of the permutation map, the enumeration
+ // index is the index into the target dimensions and the DimExpr points to
+ // the dimension of the source memref.
for (const auto &en :
llvm::enumerate(transposeOp.getPermutation().getResults())) {
int targetPos = en.index();
@@ -1523,17 +1477,7 @@ struct ViewOpLowering : public ConvertOpToLLVMPattern<memref::ViewOp> {
// Field 1: Copy the allocated pointer, used for malloc/free.
Value allocatedPtr = sourceMemRef.allocatedPtr(rewriter, loc);
auto srcMemRefType = cast<MemRefType>(viewOp.getSource().getType());
- unsigned sourceMemorySpace =
- *getTypeConverter()->getMemRefAddressSpace(srcMemRefType);
- Value bitcastPtr;
- if (getTypeConverter()->useOpaquePointers())
- bitcastPtr = allocatedPtr;
- else
- bitcastPtr = rewriter.create<LLVM::BitcastOp>(
- loc, LLVM::LLVMPointerType::get(targetElementTy, sourceMemorySpace),
- allocatedPtr);
-
- targetMemRef.setAllocatedPtr(rewriter, loc, bitcastPtr);
+ targetMemRef.setAllocatedPtr(rewriter, loc, allocatedPtr);
// Field 2: Copy the actual aligned pointer to payload.
Value alignedPtr = sourceMemRef.alignedPtr(rewriter, loc);
@@ -1542,15 +1486,7 @@ struct ViewOpLowering : public ConvertOpToLLVMPattern<memref::ViewOp> {
typeConverter->convertType(srcMemRefType.getElementType()), alignedPtr,
adaptor.getByteShift());
- if (getTypeConverter()->useOpaquePointers()) {
- bitcastPtr = alignedPtr;
- } else {
- bitcastPtr = rewriter.create<LLVM::BitcastOp>(
- loc, LLVM::LLVMPointerType::get(targetElementTy, sourceMemorySpace),
- alignedPtr);
- }
-
- targetMemRef.setAlignedPtr(rewriter, loc, bitcastPtr);
+ targetMemRef.setAlignedPtr(rewriter, loc, alignedPtr);
Type indexType = getIndexType();
// Field 3: The offset in the resulting type must be 0. This is
@@ -1766,7 +1702,6 @@ struct FinalizeMemRefToLLVMConversionPass
: LowerToLLVMOptions::AllocLowering::Malloc);
options.useGenericFunctions = useGenericFunctions;
- options.useOpaquePointers = useOpaquePointers;
if (indexBitwidth != kDeriveIndexBitwidthFromDataLayout)
options.overrideIndexBitwidth(indexBitwidth);
diff --git a/mlir/test/Conversion/MemRefToLLVM/convert-alloca-scope.mlir b/mlir/test/Conversion/MemRefToLLVM/convert-alloca-scope.mlir
index 5cc9b33d21f1748..5fb3059626cdc1c 100644
--- a/mlir/test/Conversion/MemRefToLLVM/convert-alloca-scope.mlir
+++ b/mlir/test/Conversion/MemRefToLLVM/convert-alloca-scope.mlir
@@ -1,4 +1,4 @@
-// RUN: mlir-opt -finalize-memref-to-llvm='use-opaque-pointers=1' %s | FileCheck %s
+// RUN: mlir-opt -finalize-memref-to-llvm %s | FileCheck %s
// CHECK-LABEL: @empty
func.func @empty() {
diff --git a/mlir/test/Conversion/MemRefToLLVM/convert-dynamic-memref-ops.mlir b/mlir/test/Conversion/MemRefToLLVM/convert-dynamic-memref-ops.mlir
index ea6a235857e6362..66dc30127ae741f 100644
--- a/mlir/test/Conversion/MemRefToLLVM/convert-dynamic-memref-ops.mlir
+++ b/mlir/test/Conversion/MemRefToLLVM/convert-dynamic-memref-ops.mlir
@@ -1,6 +1,6 @@
-// RUN: mlir-opt -split-input-file -finalize-memref-to-llvm='use-opaque-pointers=1' %s | FileCheck %s
-// RUN: mlir-opt -split-input-file -finalize-memref-to-llvm='use-aligned-alloc=1 use-opaque-pointers=1' %s | FileCheck %s --check-prefix=ALIGNED-ALLOC
-// RUN: mlir-opt -split-input-file -finalize-memref-to-llvm='index-bitwidth=32 use-opaque-pointers=1' %s | FileCheck --check-prefix=CHECK32 %s
+// RUN: mlir-opt -split-input-file -finalize-memref-to-llvm %s | FileCheck %s
+// RUN: mlir-opt -split-input-file -finalize-memref-to-llvm='use-aligned-alloc=1' %s | FileCheck %s --check-prefix=ALIGNED-ALLOC
+// RUN: mlir-opt -split-input-file -finalize-memref-to-llvm='index-bitwidth=32' %s | FileCheck --check-prefix=CHECK32 %s
// CHECK-LABEL: func @mixed_alloc(
// CHECK: %[[Marg:.*]]: index, %[[Narg:.*]]: index)
diff --git a/mlir/test/Conversion/MemRefToLLVM/convert-static-memref-ops.mlir b/mlir/test/Conversion/MemRefToLLVM/convert-static-memref-ops.mlir
index 35a6358d8f58b08..f1600d43e7bfb30 100644
--- a/mlir/test/Conversion/MemRefToLLVM/convert-static-memref-ops.mlir
+++ b/mlir/test/Conversion/MemRefToLLVM/convert-static-memref-ops.mlir
@@ -1,4 +1,4 @@
-// RUN: mlir-opt -finalize-memref-to-llvm='use-opaque-pointers=1' -split-input-file %s | FileCheck %s
+// RUN: mlir-opt -finalize-memref-to-llvm -split-input-file %s | FileCheck %s
// CHECK-LABEL: func @zero_d_alloc()
func.func @zero_d_alloc() -> memref<f32> {
diff --git a/mlir/test/Conversion/MemRefToLLVM/expand-then-convert-to-llvm.mlir b/mlir/test/Conversion/MemRefToLLVM/expand-then-convert-to-llvm.mlir
index 0e655b5464d9617..eb45112b117c0d6 100644
--- a/mlir/test/Conversion/MemRefToLLVM/expand-then-convert-to-llvm.mlir
+++ b/mlir/test/Conversion/MemRefToLLVM/expand-then-convert-to-llvm.mlir
@@ -1,4 +1,4 @@
-// RUN: mlir-opt -expand-strided-metadata -finalize-memref-to-llvm='use-opaque-pointers=1' -lower-affine -convert-arith-to-llvm -cse %s -split-input-file | FileCheck %s
+// RUN: mlir-opt -expand-strided-metadata -finalize-memref-to-llvm -lower-affine -convert-arith-to-llvm -cse %s -split-input-file | FileCheck %s
//
// This test demonstrates a full "memref to llvm" pipeline where
// we first expand some of the memref operations (using affine,
diff --git a/mlir/test/Conversion/MemRefToLLVM/generic-functions.mlir b/mlir/test/Conversion/MemRefToLLVM/generic-functions.mlir
index d5ac0b0da979dcb..9256461eadcb306 100644
--- a/mlir/test/Conversion/MemRefToLLVM/generic-functions.mlir
+++ b/mlir/test/Conversion/MemRefToLLVM/generic-functions.mlir
@@ -1,7 +1,7 @@
-// RUN: mlir-opt -pass-pipeline="builtin.module(finalize-memref-to-llvm{use-generic-functions=1 use-opaque-pointers=1})" -split-input-file %s \
+// RUN: mlir-opt -pass-pipeline="builtin.module(finalize-memref-to-llvm{use-generic-functions=1})" -split-input-file %s \
// RUN: | FileCheck %s --check-prefix="CHECK-NOTALIGNED"
-// RUN: mlir-opt -pass-pipeline="builtin.module(finalize-memref-to-llvm{use-generic-functions=1 use-aligned-alloc=1 use-opaque-pointers=1})" -split-input-file %s \
+// RUN: mlir-opt -pass-pipeline="builtin.module(finalize-memref-to-llvm{use-generic-functions=1 use-aligned-alloc=1})" -split-input-file %s \
// RUN: | FileCheck %s --check-prefix="CHECK-ALIGNED"
// CHECK-LABEL: func @alloc()
diff --git a/mlir/test/Conversion/MemRefToLLVM/memref-to-llvm.mlir b/mlir/test/Conversion/MemRefToLLVM/memref-to-llvm.mlir
index ae487ef6694745d..3b3a51d609be972 100644
--- a/mlir/test/Conversion/MemRefToLLVM/memref-to-llvm.mlir
+++ b/mlir/test/Conversion/MemRefToLLVM/memref-to-llvm.mlir
@@ -1,5 +1,5 @@
-// RUN: mlir-opt -finalize-memref-to-llvm='use-opaque-pointers=1' %s -split-input-file | FileCheck %s
-// RUN: mlir-opt -finalize-memref-to-llvm='index-bitwidth=32 use-opaque-pointers=1' %s -split-input-file | FileCheck --check-prefix=CHECK32 %s
+// RUN: mlir-opt -finalize-memref-to-llvm %s -split-input-file | FileCheck %s
+// RUN: mlir-opt -finalize-memref-to-llvm='index-bitwidth=32' %s -split-input-file | FileCheck --check-prefix=CHECK32 %s
// Same below, but using the `ConvertToLLVMPatternInterface` entry point
// and the generic `convert-to-llvm` pass. This produces slightly
diff erent IR
diff --git a/mlir/test/Conversion/MemRefToLLVM/typed-pointers.mlir b/mlir/test/Conversion/MemRefToLLVM/typed-pointers.mlir
deleted file mode 100644
index 19d053ee7813bcb..000000000000000
--- a/mlir/test/Conversion/MemRefToLLVM/typed-pointers.mlir
+++ /dev/null
@@ -1,376 +0,0 @@
-// RUN: mlir-opt -finalize-memref-to-llvm='use-opaque-pointers=0' %s -split-input-file | FileCheck %s
-// RUN: mlir-opt -finalize-memref-to-llvm='index-bitwidth=32 use-opaque-pointers=0' -split-input-file %s | FileCheck --check-prefix=CHECK32 %s
-
-// CHECK-LABEL: func @view(
-// CHECK: %[[ARG1F:.*]]: index, %[[ARG2F:.*]]: index
-func.func @view(%arg1 : index, %arg2 : index) {
- // CHECK: %[[ARG2:.*]] = builtin.unrealized_conversion_cast %[[ARG2F:.*]]
- // CHECK: %[[ARG1:.*]] = builtin.unrealized_conversion_cast %[[ARG1F:.*]]
- // CHECK: llvm.mlir.constant(2048 : index) : i64
- // CHECK: llvm.mlir.undef : !llvm.struct<(ptr<i8>, ptr<i8>, i64, array<1 x i64>, array<1 x i64>)>
- %0 = memref.alloc() : memref<2048xi8>
-
- // CHECK: llvm.mlir.undef : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
- // CHECK: %[[BASE_PTR_2:.*]] = llvm.extractvalue %{{.*}}[1] : !llvm.struct<(ptr<i8>, ptr<i8>, i64, array<1 x i64>, array<1 x i64>)>
- // CHECK: %[[SHIFTED_BASE_PTR_2:.*]] = llvm.getelementptr %[[BASE_PTR_2]][%[[ARG2]]] : (!llvm.ptr<i8>, i64) -> !llvm.ptr<i8>
- // CHECK: %[[CAST_SHIFTED_BASE_PTR_2:.*]] = llvm.bitcast %[[SHIFTED_BASE_PTR_2]] : !llvm.ptr<i8> to !llvm.ptr<f32>
- // CHECK: llvm.insertvalue %[[CAST_SHIFTED_BASE_PTR_2]], %{{.*}}[1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
- // CHECK: %[[C0_2:.*]] = llvm.mlir.constant(0 : index) : i64
- // CHECK: llvm.insertvalue %[[C0_2]], %{{.*}}[2] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
- // CHECK: llvm.insertvalue %[[ARG1]], %{{.*}}[3, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
- // CHECK: llvm.mlir.constant(1 : index) : i64
- // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[4, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
- // CHECK: llvm.mlir.constant(4 : index) : i64
- // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[3, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
- // CHECK: llvm.mul %{{.*}}, %[[ARG1]]
- // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[4, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
- %1 = memref.view %0[%arg2][%arg1] : memref<2048xi8> to memref<4x?xf32>
- return
-}
-
-// -----
-
-// CHECK: llvm.mlir.global external @gv0() {addr_space = 0 : i32} : !llvm.array<2 x f32> {
-// CHECK-NEXT: %0 = llvm.mlir.undef : !llvm.array<2 x f32>
-// CHECK-NEXT: llvm.return %0 : !llvm.array<2 x f32>
-// CHECK-NEXT: }
-memref.global @gv0 : memref<2xf32> = uninitialized
-
-// CHECK-LABEL: func @get_gv0_memref
-func.func @get_gv0_memref() {
- %0 = memref.get_global @gv0 : memref<2xf32>
- // CHECK: %[[DIM:.*]] = llvm.mlir.constant(2 : index) : i64
- // CHECK: %[[STRIDE:.*]] = llvm.mlir.constant(1 : index) : i64
- // CHECK: %[[ADDR:.*]] = llvm.mlir.addressof @gv0 : !llvm.ptr<array<2 x f32>>
- // CHECK: %[[GEP:.*]] = llvm.getelementptr %[[ADDR]][0, 0] : (!llvm.ptr<array<2 x f32>>) -> !llvm.ptr<f32>
- // CHECK: %[[DEADBEEF:.*]] = llvm.mlir.constant(3735928559 : index) : i64
- // CHECK: %[[DEADBEEFPTR:.*]] = llvm.inttoptr %[[DEADBEEF]] : i64 to !llvm.ptr<f32>
- // CHECK: llvm.mlir.undef : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<1 x i64>, array<1 x i64>)>
- // CHECK: llvm.insertvalue %[[DEADBEEFPTR]], {{.*}}[0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<1 x i64>, array<1 x i64>)>
- // CHECK: llvm.insertvalue %[[GEP]], {{.*}}[1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<1 x i64>, array<1 x i64>)>
- // CHECK: %[[OFFSET:.*]] = llvm.mlir.constant(0 : index) : i64
- // CHECK: llvm.insertvalue %[[OFFSET]], {{.*}}[2] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<1 x i64>, array<1 x i64>)>
- // CHECK: llvm.insertvalue %[[DIM]], {{.*}}[3, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<1 x i64>, array<1 x i64>)>
- // CHECK: llvm.insertvalue %[[STRIDE]], {{.*}}[4, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<1 x i64>, array<1 x i64>)>
- return
-}
-
-// -----
-
-// CHECK-LABEL: func @memref_copy_unranked
-func.func @memref_copy_unranked() {
- %0 = memref.alloc() : memref<2xi1>
- // CHECK: llvm.mlir.constant(2 : index) : i64
- // CHECK: llvm.mlir.undef : !llvm.struct<(ptr<i1>, ptr<i1>, i64, array<1 x i64>, array<1 x i64>)>
- %1 = memref.cast %0 : memref<2xi1> to memref<*xi1>
- %2 = memref.alloc() : memref<2xi1>
- // CHECK: llvm.mlir.constant(2 : index) : i64
- // CHECK: llvm.mlir.undef : !llvm.struct<(ptr<i1>, ptr<i1>, i64, array<1 x i64>, array<1 x i64>)>
- %3 = memref.cast %2 : memref<2xi1> to memref<*xi1>
- memref.copy %1, %3 : memref<*xi1> to memref<*xi1>
- // CHECK: [[ONE:%.*]] = llvm.mlir.constant(1 : index) : i64
- // CHECK: [[ALLOCA:%.*]] = llvm.alloca %35 x !llvm.struct<(ptr<i1>, ptr<i1>, i64, array<1 x i64>, array<1 x i64>)> : (i64) -> !llvm.ptr<struct<(ptr<i1>, ptr<i1>, i64, array<1 x i64>, array<1 x i64>)>>
- // CHECK: llvm.store {{%.*}}, [[ALLOCA]] : !llvm.ptr<struct<(ptr<i1>, ptr<i1>, i64, array<1 x i64>, array<1 x i64>)>>
- // CHECK: [[BITCAST:%.*]] = llvm.bitcast [[ALLOCA]] : !llvm.ptr<struct<(ptr<i1>, ptr<i1>, i64, array<1 x i64>, array<1 x i64>)>> to !llvm.ptr<i8>
- // CHECK: [[RANK:%.*]] = llvm.mlir.constant(1 : index) : i64
- // CHECK: [[UNDEF:%.*]] = llvm.mlir.undef : !llvm.struct<(i64, ptr<i8>)>
- // CHECK: [[INSERT:%.*]] = llvm.insertvalue [[RANK]], [[UNDEF]][0] : !llvm.struct<(i64, ptr<i8>)>
- // CHECK: [[INSERT2:%.*]] = llvm.insertvalue [[BITCAST]], [[INSERT]][1] : !llvm.struct<(i64, ptr<i8>)>
- // CHECK: [[STACKSAVE:%.*]] = llvm.intr.stacksave : !llvm.ptr<i8>
- // CHECK: [[RANK2:%.*]] = llvm.mlir.constant(1 : index) : i64
- // CHECK: [[ALLOCA2:%.*]] = llvm.alloca [[RANK2]] x !llvm.struct<(i64, ptr<i8>)> : (i64) -> !llvm.ptr<struct<(i64, ptr<i8>)>>
- // CHECK: llvm.store {{%.*}}, [[ALLOCA2]] : !llvm.ptr<struct<(i64, ptr<i8>)>>
- // CHECK: [[ALLOCA3:%.*]] = llvm.alloca [[RANK2]] x !llvm.struct<(i64, ptr<i8>)> : (i64) -> !llvm.ptr<struct<(i64, ptr<i8>)>>
- // CHECK: llvm.store [[INSERT2]], [[ALLOCA3]] : !llvm.ptr<struct<(i64, ptr<i8>)>>
- // CHECK: [[SIZEPTR:%.*]] = llvm.getelementptr {{%.*}}[1] : (!llvm.ptr<i1>) -> !llvm.ptr<i1>
- // CHECK: [[SIZE:%.*]] = llvm.ptrtoint [[SIZEPTR]] : !llvm.ptr<i1> to i64
- // CHECK: llvm.call @memrefCopy([[SIZE]], [[ALLOCA2]], [[ALLOCA3]]) : (i64, !llvm.ptr<struct<(i64, ptr<i8>)>>, !llvm.ptr<struct<(i64, ptr<i8>)>>) -> ()
- // CHECK: llvm.intr.stackrestore [[STACKSAVE]]
- return
-}
-
-// -----
-
-// CHECK-LABEL: func @mixed_alloc(
-// CHECK: %[[Marg:.*]]: index, %[[Narg:.*]]: index)
-func.func @mixed_alloc(%arg0: index, %arg1: index) -> memref<?x42x?xf32> {
-// CHECK-DAG: %[[M:.*]] = builtin.unrealized_conversion_cast %[[Marg]]
-// CHECK-DAG: %[[N:.*]] = builtin.unrealized_conversion_cast %[[Narg]]
-// CHECK: %[[c42:.*]] = llvm.mlir.constant(42 : index) : i64
-// CHECK-NEXT: %[[one:.*]] = llvm.mlir.constant(1 : index) : i64
-// CHECK-NEXT: %[[st0:.*]] = llvm.mul %[[N]], %[[c42]] : i64
-// CHECK-NEXT: %[[sz:.*]] = llvm.mul %[[st0]], %[[M]] : i64
-// CHECK-NEXT: %[[null:.*]] = llvm.mlir.zero : !llvm.ptr<f32>
-// CHECK-NEXT: %[[gep:.*]] = llvm.getelementptr %[[null]][%[[sz]]] : (!llvm.ptr<f32>, i64) -> !llvm.ptr<f32>
-// CHECK-NEXT: %[[sz_bytes:.*]] = llvm.ptrtoint %[[gep]] : !llvm.ptr<f32> to i64
-// CHECK-NEXT: llvm.call @malloc(%[[sz_bytes]]) : (i64) -> !llvm.ptr<i8>
-// CHECK-NEXT: llvm.bitcast %{{.*}} : !llvm.ptr<i8> to !llvm.ptr<f32>
-// CHECK-NEXT: llvm.mlir.undef : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<3 x i64>, array<3 x i64>)>
-// CHECK-NEXT: llvm.insertvalue %{{.*}}, %{{.*}}[0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<3 x i64>, array<3 x i64>)>
-// CHECK-NEXT: llvm.insertvalue %{{.*}}, %{{.*}}[1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<3 x i64>, array<3 x i64>)>
-// CHECK-NEXT: %[[off:.*]] = llvm.mlir.constant(0 : index) : i64
-// CHECK-NEXT: llvm.insertvalue %[[off]], %{{.*}}[2] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<3 x i64>, array<3 x i64>)>
-// CHECK-NEXT: llvm.insertvalue %[[M]], %{{.*}}[3, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<3 x i64>, array<3 x i64>)>
-// CHECK-NEXT: llvm.insertvalue %[[c42]], %{{.*}}[3, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<3 x i64>, array<3 x i64>)>
-// CHECK-NEXT: llvm.insertvalue %[[N]], %{{.*}}[3, 2] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<3 x i64>, array<3 x i64>)>
-// CHECK-NEXT: llvm.insertvalue %[[st0]], %{{.*}}[4, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<3 x i64>, array<3 x i64>)>
-// CHECK-NEXT: llvm.insertvalue %[[N]], %{{.*}}[4, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<3 x i64>, array<3 x i64>)>
-// CHECK-NEXT: llvm.insertvalue %[[one]], %{{.*}}[4, 2] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<3 x i64>, array<3 x i64>)>
- %0 = memref.alloc(%arg0, %arg1) : memref<?x42x?xf32>
- return %0 : memref<?x42x?xf32>
-}
-
-// -----
-
-// CHECK-LABEL: func @mixed_dealloc
-func.func @mixed_dealloc(%arg0: memref<?x42x?xf32>) {
-// CHECK: %[[ptr:.*]] = llvm.extractvalue %{{.*}}[0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<3 x i64>, array<3 x i64>)>
-// CHECK-NEXT: %[[ptri8:.*]] = llvm.bitcast %[[ptr]] : !llvm.ptr<f32> to !llvm.ptr<i8>
-// CHECK-NEXT: llvm.call @free(%[[ptri8]]) : (!llvm.ptr<i8>) -> ()
- memref.dealloc %arg0 : memref<?x42x?xf32>
- return
-}
-
-// -----
-
-// CHECK-LABEL: func @dynamic_alloc(
-// CHECK: %[[Marg:.*]]: index, %[[Narg:.*]]: index)
-func.func @dynamic_alloc(%arg0: index, %arg1: index) -> memref<?x?xf32> {
-// CHECK-DAG: %[[M:.*]] = builtin.unrealized_conversion_cast %[[Marg]]
-// CHECK-DAG: %[[N:.*]] = builtin.unrealized_conversion_cast %[[Narg]]
-// CHECK-NEXT: %[[one:.*]] = llvm.mlir.constant(1 : index) : i64
-// CHECK-NEXT: %[[sz:.*]] = llvm.mul %[[N]], %[[M]] : i64
-// CHECK-NEXT: %[[null:.*]] = llvm.mlir.zero : !llvm.ptr<f32>
-// CHECK-NEXT: %[[gep:.*]] = llvm.getelementptr %[[null]][%[[sz]]] : (!llvm.ptr<f32>, i64) -> !llvm.ptr<f32>
-// CHECK-NEXT: %[[sz_bytes:.*]] = llvm.ptrtoint %[[gep]] : !llvm.ptr<f32> to i64
-// CHECK-NEXT: llvm.call @malloc(%[[sz_bytes]]) : (i64) -> !llvm.ptr<i8>
-// CHECK-NEXT: llvm.bitcast %{{.*}} : !llvm.ptr<i8> to !llvm.ptr<f32>
-// CHECK-NEXT: llvm.mlir.undef : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
-// CHECK-NEXT: llvm.insertvalue %{{.*}}, %{{.*}}[0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
-// CHECK-NEXT: llvm.insertvalue %{{.*}}, %{{.*}}[1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
-// CHECK-NEXT: %[[off:.*]] = llvm.mlir.constant(0 : index) : i64
-// CHECK-NEXT: llvm.insertvalue %[[off]], %{{.*}}[2] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
-// CHECK-NEXT: llvm.insertvalue %[[M]], %{{.*}}[3, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
-// CHECK-NEXT: llvm.insertvalue %[[N]], %{{.*}}[3, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
-// CHECK-NEXT: llvm.insertvalue %[[N]], %{{.*}}[4, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
-// CHECK-NEXT: llvm.insertvalue %[[one]], %{{.*}}[4, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
- %0 = memref.alloc(%arg0, %arg1) : memref<?x?xf32>
- return %0 : memref<?x?xf32>
-}
-
-// -----
-
-// CHECK-LABEL: func @dynamic_dealloc
-func.func @dynamic_dealloc(%arg0: memref<?x?xf32>) {
-// CHECK: %[[ptr:.*]] = llvm.extractvalue %{{.*}}[0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
-// CHECK-NEXT: %[[ptri8:.*]] = llvm.bitcast %[[ptr]] : !llvm.ptr<f32> to !llvm.ptr<i8>
-// CHECK-NEXT: llvm.call @free(%[[ptri8]]) : (!llvm.ptr<i8>) -> ()
- memref.dealloc %arg0 : memref<?x?xf32>
- return
-}
-
-// -----
-
-// CHECK-LABEL: func @memref_cast_static_to_dynamic
-func.func @memref_cast_static_to_dynamic(%static : memref<10x42xf32>) {
-// CHECK-NOT: llvm.bitcast
- %0 = memref.cast %static : memref<10x42xf32> to memref<?x?xf32>
- return
-}
-
-// -----
-
-// CHECK-LABEL: func @memref_cast_static_to_mixed
-func.func @memref_cast_static_to_mixed(%static : memref<10x42xf32>) {
-// CHECK-NOT: llvm.bitcast
- %0 = memref.cast %static : memref<10x42xf32> to memref<?x42xf32>
- return
-}
-
-// -----
-
-// CHECK-LABEL: func @memref_cast_dynamic_to_static
-func.func @memref_cast_dynamic_to_static(%dynamic : memref<?x?xf32>) {
-// CHECK-NOT: llvm.bitcast
- %0 = memref.cast %dynamic : memref<?x?xf32> to memref<10x12xf32>
- return
-}
-
-// -----
-
-// CHECK-LABEL: func @memref_cast_dynamic_to_mixed
-func.func @memref_cast_dynamic_to_mixed(%dynamic : memref<?x?xf32>) {
-// CHECK-NOT: llvm.bitcast
- %0 = memref.cast %dynamic : memref<?x?xf32> to memref<?x12xf32>
- return
-}
-
-// -----
-
-// CHECK-LABEL: func @memref_cast_mixed_to_dynamic
-func.func @memref_cast_mixed_to_dynamic(%mixed : memref<42x?xf32>) {
-// CHECK-NOT: llvm.bitcast
- %0 = memref.cast %mixed : memref<42x?xf32> to memref<?x?xf32>
- return
-}
-
-// -----
-
-// CHECK-LABEL: func @memref_cast_mixed_to_static
-func.func @memref_cast_mixed_to_static(%mixed : memref<42x?xf32>) {
-// CHECK-NOT: llvm.bitcast
- %0 = memref.cast %mixed : memref<42x?xf32> to memref<42x1xf32>
- return
-}
-
-// -----
-
-// CHECK-LABEL: func @memref_cast_mixed_to_mixed
-func.func @memref_cast_mixed_to_mixed(%mixed : memref<42x?xf32>) {
-// CHECK-NOT: llvm.bitcast
- %0 = memref.cast %mixed : memref<42x?xf32> to memref<?x1xf32>
- return
-}
-
-// -----
-
-// CHECK-LABEL: func @memref_cast_ranked_to_unranked
-// CHECK32-LABEL: func @memref_cast_ranked_to_unranked
-func.func @memref_cast_ranked_to_unranked(%arg : memref<42x2x?xf32>) {
-// CHECK-DAG: %[[c:.*]] = llvm.mlir.constant(1 : index) : i64
-// CHECK-DAG: %[[p:.*]] = llvm.alloca %[[c]] x !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<3 x i64>, array<3 x i64>)> : (i64) -> !llvm.ptr<struct<(ptr<f32>, ptr<f32>, i64, array<3 x i64>, array<3 x i64>)>>
-// CHECK-DAG: llvm.store %{{.*}}, %[[p]] : !llvm.ptr<struct<(ptr<f32>, ptr<f32>, i64, array<3 x i64>, array<3 x i64>)>>
-// CHECK-DAG: %[[p2:.*]] = llvm.bitcast %[[p]] : !llvm.ptr<struct<(ptr<f32>, ptr<f32>, i64, array<3 x i64>, array<3 x i64>)>> to !llvm.ptr<i8>
-// CHECK-DAG: %[[r:.*]] = llvm.mlir.constant(3 : index) : i64
-// CHECK : llvm.mlir.undef : !llvm.struct<(i64, ptr<i8>)>
-// CHECK-DAG: llvm.insertvalue %[[r]], %{{.*}}[0] : !llvm.struct<(i64, ptr<i8>)>
-// CHECK-DAG: llvm.insertvalue %[[p2]], %{{.*}}[1] : !llvm.struct<(i64, ptr<i8>)>
-// CHECK32-DAG: %[[c:.*]] = llvm.mlir.constant(1 : index) : i64
-// CHECK32-DAG: %[[p:.*]] = llvm.alloca %[[c]] x !llvm.struct<(ptr<f32>, ptr<f32>, i32, array<3 x i32>, array<3 x i32>)> : (i64) -> !llvm.ptr<struct<(ptr<f32>, ptr<f32>, i32, array<3 x i32>, array<3 x i32>)>>
-// CHECK32-DAG: llvm.store %{{.*}}, %[[p]] : !llvm.ptr<struct<(ptr<f32>, ptr<f32>, i32, array<3 x i32>, array<3 x i32>)>>
-// CHECK32-DAG: %[[p2:.*]] = llvm.bitcast %[[p]] : !llvm.ptr<struct<(ptr<f32>, ptr<f32>, i32, array<3 x i32>, array<3 x i32>)>> to !llvm.ptr<i8>
-// CHECK32-DAG: %[[r:.*]] = llvm.mlir.constant(3 : index) : i32
-// CHECK32 : llvm.mlir.undef : !llvm.struct<(i32, ptr<i8>)>
-// CHECK32-DAG: llvm.insertvalue %[[r]], %{{.*}}[0] : !llvm.struct<(i32, ptr<i8>)>
-// CHECK32-DAG: llvm.insertvalue %[[p2]], %{{.*}}[1] : !llvm.struct<(i32, ptr<i8>)>
- %0 = memref.cast %arg : memref<42x2x?xf32> to memref<*xf32>
- return
-}
-
-// -----
-
-// CHECK-LABEL: func @memref_cast_unranked_to_ranked
-func.func @memref_cast_unranked_to_ranked(%arg : memref<*xf32>) {
-// CHECK: %[[p:.*]] = llvm.extractvalue %{{.*}}[1] : !llvm.struct<(i64, ptr<i8>)>
-// CHECK-NEXT: llvm.bitcast %[[p]] : !llvm.ptr<i8> to !llvm.ptr<struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>>
- %0 = memref.cast %arg : memref<*xf32> to memref<?x?x10x2xf32>
- return
-}
-
-// -----
-
-// CHECK-LABEL: @memref_reinterpret_cast_unranked_to_dynamic_shape
-func.func @memref_reinterpret_cast_unranked_to_dynamic_shape(%offset: index,
- %size_0 : index,
- %size_1 : index,
- %stride_0 : index,
- %stride_1 : index,
- %input : memref<*xf32>) {
- %output = memref.reinterpret_cast %input to
- offset: [%offset], sizes: [%size_0, %size_1],
- strides: [%stride_0, %stride_1]
- : memref<*xf32> to memref<?x?xf32, strided<[?, ?], offset: ?>>
- return
-}
-// CHECK-SAME: ([[OFFSETarg:%[a-z,0-9]+]]: index,
-// CHECK-SAME: [[SIZE_0arg:%[a-z,0-9]+]]: index, [[SIZE_1arg:%[a-z,0-9]+]]: index,
-// CHECK-SAME: [[STRIDE_0arg:%[a-z,0-9]+]]: index, [[STRIDE_1arg:%[a-z,0-9]+]]: index,
-// CHECK-DAG: [[OFFSET:%.*]] = builtin.unrealized_conversion_cast [[OFFSETarg]]
-// CHECK-DAG: [[SIZE_0:%.*]] = builtin.unrealized_conversion_cast [[SIZE_0arg]]
-// CHECK-DAG: [[SIZE_1:%.*]] = builtin.unrealized_conversion_cast [[SIZE_1arg]]
-// CHECK-DAG: [[STRIDE_0:%.*]] = builtin.unrealized_conversion_cast [[STRIDE_0arg]]
-// CHECK-DAG: [[STRIDE_1:%.*]] = builtin.unrealized_conversion_cast [[STRIDE_1arg]]
-// CHECK-DAG: [[INPUT:%.*]] = builtin.unrealized_conversion_cast
-// CHECK: [[OUT_0:%.*]] = llvm.mlir.undef : [[TY:!.*]]
-// CHECK: [[DESCRIPTOR:%.*]] = llvm.extractvalue [[INPUT]][1] : !llvm.struct<(i64, ptr<i8>)>
-// CHECK: [[BASE_PTR_PTR:%.*]] = llvm.bitcast [[DESCRIPTOR]] : !llvm.ptr<i8> to !llvm.ptr<ptr<f32>>
-// CHECK: [[BASE_PTR:%.*]] = llvm.load [[BASE_PTR_PTR]] : !llvm.ptr<ptr<f32>>
-// CHECK: [[BASE_PTR_PTR_:%.*]] = llvm.bitcast [[DESCRIPTOR]] : !llvm.ptr<i8> to !llvm.ptr<ptr<f32>>
-// CHECK: [[ALIGNED_PTR_PTR:%.*]] = llvm.getelementptr [[BASE_PTR_PTR_]]{{\[}}1]
-// CHECK-SAME: : (!llvm.ptr<ptr<f32>>) -> !llvm.ptr<ptr<f32>>
-// CHECK: [[ALIGNED_PTR:%.*]] = llvm.load [[ALIGNED_PTR_PTR]] : !llvm.ptr<ptr<f32>>
-// CHECK: [[OUT_1:%.*]] = llvm.insertvalue [[BASE_PTR]], [[OUT_0]][0] : [[TY]]
-// CHECK: [[OUT_2:%.*]] = llvm.insertvalue [[ALIGNED_PTR]], [[OUT_1]][1] : [[TY]]
-// CHECK: [[OUT_3:%.*]] = llvm.insertvalue [[OFFSET]], [[OUT_2]][2] : [[TY]]
-// CHECK: [[OUT_4:%.*]] = llvm.insertvalue [[SIZE_0]], [[OUT_3]][3, 0] : [[TY]]
-// CHECK: [[OUT_5:%.*]] = llvm.insertvalue [[STRIDE_0]], [[OUT_4]][4, 0] : [[TY]]
-// CHECK: [[OUT_6:%.*]] = llvm.insertvalue [[SIZE_1]], [[OUT_5]][3, 1] : [[TY]]
-// CHECK: [[OUT_7:%.*]] = llvm.insertvalue [[STRIDE_1]], [[OUT_6]][4, 1] : [[TY]]
-
-// -----
-
-// CHECK-LABEL: @memref_reshape
-func.func @memref_reshape(%input : memref<2x3xf32>, %shape : memref<?xindex>) {
- %output = memref.reshape %input(%shape)
- : (memref<2x3xf32>, memref<?xindex>) -> memref<*xf32>
- return
-}
-// CHECK: [[INPUT:%.*]] = builtin.unrealized_conversion_cast %{{.*}} to [[INPUT_TY:!.*]]
-// CHECK: [[SHAPE:%.*]] = builtin.unrealized_conversion_cast %{{.*}} to [[SHAPE_TY:!.*]]
-// CHECK: [[RANK:%.*]] = llvm.extractvalue [[SHAPE]][3, 0] : [[SHAPE_TY]]
-// CHECK: [[UNRANKED_OUT_O:%.*]] = llvm.mlir.undef : !llvm.struct<(i64, ptr<i8>)>
-// CHECK: [[UNRANKED_OUT_1:%.*]] = llvm.insertvalue [[RANK]], [[UNRANKED_OUT_O]][0] : !llvm.struct<(i64, ptr<i8>)>
-
-// Compute size in bytes to allocate result ranked descriptor
-// CHECK: [[C1:%.*]] = llvm.mlir.constant(1 : index) : i64
-// CHECK: [[C2:%.*]] = llvm.mlir.constant(2 : index) : i64
-// CHECK: [[INDEX_SIZE:%.*]] = llvm.mlir.constant(8 : index) : i64
-// CHECK: [[PTR_SIZE:%.*]] = llvm.mlir.constant(8 : index) : i64
-// CHECK: [[DOUBLE_PTR_SIZE:%.*]] = llvm.mul [[C2]], [[PTR_SIZE]] : i64
-// CHECK: [[DESC_ALLOC_SIZE:%.*]] = llvm.add [[DOUBLE_PTR_SIZE]], %{{.*}}
-// CHECK: [[UNDERLYING_DESC:%.*]] = llvm.alloca [[DESC_ALLOC_SIZE]] x i8
-// CHECK: llvm.insertvalue [[UNDERLYING_DESC]], [[UNRANKED_OUT_1]][1]
-
-// Set allocated, aligned pointers and offset.
-// CHECK: [[ALLOC_PTR:%.*]] = llvm.extractvalue [[INPUT]][0] : [[INPUT_TY]]
-// CHECK: [[ALIGN_PTR:%.*]] = llvm.extractvalue [[INPUT]][1] : [[INPUT_TY]]
-// CHECK: [[OFFSET:%.*]] = llvm.extractvalue [[INPUT]][2] : [[INPUT_TY]]
-// CHECK: [[BASE_PTR_PTR:%.*]] = llvm.bitcast [[UNDERLYING_DESC]]
-// CHECK-SAME: !llvm.ptr<i8> to !llvm.ptr<ptr<f32>>
-// CHECK: llvm.store [[ALLOC_PTR]], [[BASE_PTR_PTR]] : !llvm.ptr<ptr<f32>>
-// CHECK: [[BASE_PTR_PTR_:%.*]] = llvm.bitcast [[UNDERLYING_DESC]] : !llvm.ptr<i8> to !llvm.ptr<ptr<f32>>
-// CHECK: [[ALIGNED_PTR_PTR:%.*]] = llvm.getelementptr [[BASE_PTR_PTR_]]{{\[}}1]
-// CHECK: llvm.store [[ALIGN_PTR]], [[ALIGNED_PTR_PTR]] : !llvm.ptr<ptr<f32>>
-// CHECK: [[BASE_PTR_PTR__:%.*]] = llvm.bitcast [[UNDERLYING_DESC]] : !llvm.ptr<i8> to !llvm.ptr<ptr<f32>>
-// CHECK: [[OFFSET_PTR_:%.*]] = llvm.getelementptr [[BASE_PTR_PTR__]]{{\[}}2]
-// CHECK: [[OFFSET_PTR:%.*]] = llvm.bitcast [[OFFSET_PTR_]]
-// CHECK: llvm.store [[OFFSET]], [[OFFSET_PTR]] : !llvm.ptr<i64>
-
-// Iterate over shape operand in reverse order and set sizes and strides.
-// CHECK: [[STRUCT_PTR:%.*]] = llvm.bitcast [[UNDERLYING_DESC]]
-// CHECK-SAME: !llvm.ptr<i8> to !llvm.ptr<struct<(ptr<f32>, ptr<f32>, i64, i64)>>
-// CHECK: [[SIZES_PTR:%.*]] = llvm.getelementptr [[STRUCT_PTR]]{{\[}}0, 3]
-// CHECK: [[STRIDES_PTR:%.*]] = llvm.getelementptr [[SIZES_PTR]]{{\[}}[[RANK]]]
-// CHECK: [[SHAPE_IN_PTR:%.*]] = llvm.extractvalue [[SHAPE]][1] : [[SHAPE_TY]]
-// CHECK: [[C1_:%.*]] = llvm.mlir.constant(1 : index) : i64
-// CHECK: [[RANK_MIN_1:%.*]] = llvm.sub [[RANK]], [[C1_]] : i64
-// CHECK: llvm.br ^bb1([[RANK_MIN_1]], [[C1_]] : i64, i64)
-
-// CHECK: ^bb1([[DIM:%.*]]: i64, [[CUR_STRIDE:%.*]]: i64):
-// CHECK: [[C0_:%.*]] = llvm.mlir.constant(0 : index) : i64
-// CHECK: [[COND:%.*]] = llvm.icmp "sge" [[DIM]], [[C0_]] : i64
-// CHECK: llvm.cond_br [[COND]], ^bb2, ^bb3
-
-// CHECK: ^bb2:
-// CHECK: [[SIZE_PTR:%.*]] = llvm.getelementptr [[SHAPE_IN_PTR]]{{\[}}[[DIM]]]
-// CHECK: [[SIZE:%.*]] = llvm.load [[SIZE_PTR]] : !llvm.ptr<i64>
-// CHECK: [[TARGET_SIZE_PTR:%.*]] = llvm.getelementptr [[SIZES_PTR]]{{\[}}[[DIM]]]
-// CHECK: llvm.store [[SIZE]], [[TARGET_SIZE_PTR]] : !llvm.ptr<i64>
-// CHECK: [[TARGET_STRIDE_PTR:%.*]] = llvm.getelementptr [[STRIDES_PTR]]{{\[}}[[DIM]]]
-// CHECK: llvm.store [[CUR_STRIDE]], [[TARGET_STRIDE_PTR]] : !llvm.ptr<i64>
-// CHECK: [[UPDATE_STRIDE:%.*]] = llvm.mul [[CUR_STRIDE]], [[SIZE]] : i64
-// CHECK: [[STRIDE_COND:%.*]] = llvm.sub [[DIM]], [[C1_]] : i64
-// CHECK: llvm.br ^bb1([[STRIDE_COND]], [[UPDATE_STRIDE]] : i64, i64)
-
-// CHECK: ^bb3:
-// CHECK: return
More information about the Mlir-commits
mailing list