diff --git a/mlir/include/mlir/Conversion/LLVMCommon/MemRefBuilder.h b/mlir/include/mlir/Conversion/LLVMCommon/MemRefBuilder.h index ef8215d332c46..e97675f37e10c 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 53da1e58bf248..1efb2d00213b5 100644 --- a/mlir/include/mlir/Conversion/Passes.td +++ b/mlir/include/mlir/Conversion/Passes.td @@ -745,10 +745,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 05320c0c71869..7289c3ac6ff7e 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 0a3c9a57eec95..023fd6244ce1a 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( loc, value, llvm::ArrayRef({kSizePosInMemRefDescriptor})); - auto sizesPtr = builder.create(loc, arrayPtrTy, arrayTy, one, + auto sizesPtr = builder.create(loc, ptrTy, arrayTy, one, /*alignment=*/0); builder.create(loc, sizes, sizesPtr); // Load an return size value of interest. - auto resultPtr = builder.create( - loc, indexPtrTy, arrayTy, sizesPtr, ArrayRef{0, pos}); + auto resultPtr = builder.create(loc, ptrTy, arrayTy, sizesPtr, + ArrayRef{0, pos}); return builder.create(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( - loc, LLVM::LLVMPointerType::get(elemPtrType), memRefDescPtr); - - return builder.create(loc, elemPtrType, elementPtrPtr); + return builder.create(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( - loc, LLVM::LLVMPointerType::get(elemPtrType), memRefDescPtr); - - builder.create(loc, allocatedPtr, elementPtrPtr); + builder.create(loc, allocatedPtr, memRefDescPtr); } static std::pair 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(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(loc, elemPtrPtrType, elemPtrType, - elementPtrPtr, ArrayRef{2}); - - if (!elemPtrType.isOpaque()) { - offsetGep = builder.create( - loc, LLVM::LLVMPointerType::get(typeConverter.getIndexType()), - offsetGep); - } - return offsetGep; + return builder.create(loc, elemPtrPtrType, elemPtrType, + elementPtrPtr, ArrayRef{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(loc, structPtrTy, memRefDescPtr); - } - - auto resultType = elemPtrType.isOpaque() - ? LLVM::LLVMPointerType::get(indexTy.getContext()) - : LLVM::LLVMPointerType::get(indexTy); - return builder.create(loc, resultType, structTy, structPtr, + auto resultType = LLVM::LLVMPointerType::get(builder.getContext()); + return builder.create(loc, resultType, structTy, memRefDescPtr, ArrayRef{0, 3}); } diff --git a/mlir/lib/Conversion/MemRefToLLVM/MemRefToLLVM.cpp b/mlir/lib/Conversion/MemRefToLLVM/MemRefToLLVM.cpp index e9efcedec0e14..91b1210efec23 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(loc, elementPtrType, elementType, size, @@ -232,10 +231,8 @@ struct DeallocOpLowering : public ConvertOpToLLVMPattern { Value allocatedPtr; if (auto unrankedTy = llvm::dyn_cast(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 { allocatedPtr = MemRefDescriptor(adaptor.getMemref()) .allocatedPtr(rewriter, op.getLoc()); } - if (!getTypeConverter()->useOpaquePointers()) - allocatedPtr = rewriter.create( - op.getLoc(), getVoidPtrType(), allocatedPtr); - rewriter.replaceOpWithNewOp(op, freeFunc, allocatedPtr); return success(); } @@ -306,19 +299,12 @@ struct DimOpLowering : public ConvertOpToLLVMPattern { Value underlyingRankedDesc = unrankedDesc.memRefDescPtr(rewriter, loc); Type elementType = typeConverter->convertType(scalarMemRefType); - Value scalarMemRefDescPtr; - if (getTypeConverter()->useOpaquePointers()) - scalarMemRefDescPtr = underlyingRankedDesc; - else - scalarMemRefDescPtr = rewriter.create( - loc, LLVM::LLVMPointerType::get(elementType, addressSpace), - underlyingRankedDesc); // Get pointer to offset field of memref descriptor. - Type indexPtrTy = getTypeConverter()->getPointerType( - getTypeConverter()->getIndexType(), addressSpace); + auto indexPtrTy = + LLVM::LLVMPointerType::get(rewriter.getContext(), addressSpace); Value offsetPtr = rewriter.create( - loc, indexPtrTy, elementType, scalarMemRefDescPtr, + loc, indexPtrTy, elementType, underlyingRankedDesc, ArrayRef{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(loc, resTy, getGlobalOp.getName()); + rewriter.create(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( - loc, elementPtrType, arrayTy, addressOf, + loc, ptrTy, arrayTy, addressOf, SmallVector(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(loc, elementPtrType, deadBeefConst); + rewriter.create(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 { auto ptr = getTypeConverter()->promoteOneMemRefDescriptor( loc, adaptor.getSource(), rewriter); - // voidptr = BitCastOp srcType* to void* - Value voidPtr; - if (getTypeConverter()->useOpaquePointers()) - voidPtr = ptr; - else - voidPtr = rewriter.create(loc, getVoidPtrType(), ptr); - // rank = ConstantOp srcRank auto rankVal = rewriter.create( loc, getIndexType(), rewriter.getIndexAttr(rank)); @@ -749,8 +724,8 @@ struct MemRefCastOpLowering : public ConvertOpToLLVMPattern { 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(srcType) && isa(dstType)) { @@ -760,17 +735,9 @@ struct MemRefCastOpLowering : public ConvertOpToLLVMPattern { 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( - loc, LLVM::LLVMPointerType::get(targetStructType), ptr); - // struct = LoadOp castPtr - auto loadOp = - rewriter.create(loc, targetStructType, castPtr); + // struct = LoadOp ptr + auto loadOp = rewriter.create(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 { auto ptr = typeConverter->promoteOneMemRefDescriptor(loc, ranked, rewriter); - Value voidPtr; - if (getTypeConverter()->useOpaquePointers()) - voidPtr = ptr; - else - voidPtr = rewriter.create(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 { auto one = rewriter.create(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(loc, ptrType, desc.getType(), one); rewriter.create(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(operandType)); - Type elementType = cast(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(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( loc, llvmIndexPtrType, typeConverter->convertType(shapeMemRefType.getElementType()), @@ -1430,9 +1384,9 @@ class TransposeOpLowering : public ConvertOpToLLVMPattern { 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 { // Field 1: Copy the allocated pointer, used for malloc/free. Value allocatedPtr = sourceMemRef.allocatedPtr(rewriter, loc); auto srcMemRefType = cast(viewOp.getSource().getType()); - unsigned sourceMemorySpace = - *getTypeConverter()->getMemRefAddressSpace(srcMemRefType); - Value bitcastPtr; - if (getTypeConverter()->useOpaquePointers()) - bitcastPtr = allocatedPtr; - else - bitcastPtr = rewriter.create( - 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 { typeConverter->convertType(srcMemRefType.getElementType()), alignedPtr, adaptor.getByteShift()); - if (getTypeConverter()->useOpaquePointers()) { - bitcastPtr = alignedPtr; - } else { - bitcastPtr = rewriter.create( - 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 5cc9b33d21f17..5fb3059626cdc 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 ea6a235857e63..66dc30127ae74 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 35a6358d8f58b..f1600d43e7bfb 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 { 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 0e655b5464d96..eb45112b117c0 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 d5ac0b0da979d..9256461eadcb3 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 ae487ef669474..3b3a51d609be9 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 different IR diff --git a/mlir/test/Conversion/MemRefToLLVM/typed-pointers.mlir b/mlir/test/Conversion/MemRefToLLVM/typed-pointers.mlir deleted file mode 100644 index 19d053ee7813b..0000000000000 --- 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, ptr, i64, array<1 x i64>, array<1 x i64>)> - %0 = memref.alloc() : memref<2048xi8> - - // CHECK: llvm.mlir.undef : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> - // CHECK: %[[BASE_PTR_2:.*]] = llvm.extractvalue %{{.*}}[1] : !llvm.struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)> - // CHECK: %[[SHIFTED_BASE_PTR_2:.*]] = llvm.getelementptr %[[BASE_PTR_2]][%[[ARG2]]] : (!llvm.ptr, i64) -> !llvm.ptr - // CHECK: %[[CAST_SHIFTED_BASE_PTR_2:.*]] = llvm.bitcast %[[SHIFTED_BASE_PTR_2]] : !llvm.ptr to !llvm.ptr - // CHECK: llvm.insertvalue %[[CAST_SHIFTED_BASE_PTR_2]], %{{.*}}[1] : !llvm.struct<(ptr, ptr, 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, ptr, i64, array<2 x i64>, array<2 x i64>)> - // CHECK: llvm.insertvalue %[[ARG1]], %{{.*}}[3, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> - // CHECK: llvm.mlir.constant(1 : index) : i64 - // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[4, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> - // CHECK: llvm.mlir.constant(4 : index) : i64 - // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[3, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> - // CHECK: llvm.mul %{{.*}}, %[[ARG1]] - // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[4, 0] : !llvm.struct<(ptr, ptr, 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> - // CHECK: %[[GEP:.*]] = llvm.getelementptr %[[ADDR]][0, 0] : (!llvm.ptr>) -> !llvm.ptr - // CHECK: %[[DEADBEEF:.*]] = llvm.mlir.constant(3735928559 : index) : i64 - // CHECK: %[[DEADBEEFPTR:.*]] = llvm.inttoptr %[[DEADBEEF]] : i64 to !llvm.ptr - // CHECK: llvm.mlir.undef : !llvm.struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)> - // CHECK: llvm.insertvalue %[[DEADBEEFPTR]], {{.*}}[0] : !llvm.struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)> - // CHECK: llvm.insertvalue %[[GEP]], {{.*}}[1] : !llvm.struct<(ptr, ptr, 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, ptr, i64, array<1 x i64>, array<1 x i64>)> - // CHECK: llvm.insertvalue %[[DIM]], {{.*}}[3, 0] : !llvm.struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)> - // CHECK: llvm.insertvalue %[[STRIDE]], {{.*}}[4, 0] : !llvm.struct<(ptr, ptr, 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, ptr, 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, ptr, 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, ptr, i64, array<1 x i64>, array<1 x i64>)> : (i64) -> !llvm.ptr, ptr, i64, array<1 x i64>, array<1 x i64>)>> - // CHECK: llvm.store {{%.*}}, [[ALLOCA]] : !llvm.ptr, ptr, i64, array<1 x i64>, array<1 x i64>)>> - // CHECK: [[BITCAST:%.*]] = llvm.bitcast [[ALLOCA]] : !llvm.ptr, ptr, i64, array<1 x i64>, array<1 x i64>)>> to !llvm.ptr - // CHECK: [[RANK:%.*]] = llvm.mlir.constant(1 : index) : i64 - // CHECK: [[UNDEF:%.*]] = llvm.mlir.undef : !llvm.struct<(i64, ptr)> - // CHECK: [[INSERT:%.*]] = llvm.insertvalue [[RANK]], [[UNDEF]][0] : !llvm.struct<(i64, ptr)> - // CHECK: [[INSERT2:%.*]] = llvm.insertvalue [[BITCAST]], [[INSERT]][1] : !llvm.struct<(i64, ptr)> - // CHECK: [[STACKSAVE:%.*]] = llvm.intr.stacksave : !llvm.ptr - // CHECK: [[RANK2:%.*]] = llvm.mlir.constant(1 : index) : i64 - // CHECK: [[ALLOCA2:%.*]] = llvm.alloca [[RANK2]] x !llvm.struct<(i64, ptr)> : (i64) -> !llvm.ptr)>> - // CHECK: llvm.store {{%.*}}, [[ALLOCA2]] : !llvm.ptr)>> - // CHECK: [[ALLOCA3:%.*]] = llvm.alloca [[RANK2]] x !llvm.struct<(i64, ptr)> : (i64) -> !llvm.ptr)>> - // CHECK: llvm.store [[INSERT2]], [[ALLOCA3]] : !llvm.ptr)>> - // CHECK: [[SIZEPTR:%.*]] = llvm.getelementptr {{%.*}}[1] : (!llvm.ptr) -> !llvm.ptr - // CHECK: [[SIZE:%.*]] = llvm.ptrtoint [[SIZEPTR]] : !llvm.ptr to i64 - // CHECK: llvm.call @memrefCopy([[SIZE]], [[ALLOCA2]], [[ALLOCA3]]) : (i64, !llvm.ptr)>>, !llvm.ptr)>>) -> () - // 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 { -// 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 -// CHECK-NEXT: %[[gep:.*]] = llvm.getelementptr %[[null]][%[[sz]]] : (!llvm.ptr, i64) -> !llvm.ptr -// CHECK-NEXT: %[[sz_bytes:.*]] = llvm.ptrtoint %[[gep]] : !llvm.ptr to i64 -// CHECK-NEXT: llvm.call @malloc(%[[sz_bytes]]) : (i64) -> !llvm.ptr -// CHECK-NEXT: llvm.bitcast %{{.*}} : !llvm.ptr to !llvm.ptr -// CHECK-NEXT: llvm.mlir.undef : !llvm.struct<(ptr, ptr, i64, array<3 x i64>, array<3 x i64>)> -// CHECK-NEXT: llvm.insertvalue %{{.*}}, %{{.*}}[0] : !llvm.struct<(ptr, ptr, i64, array<3 x i64>, array<3 x i64>)> -// CHECK-NEXT: llvm.insertvalue %{{.*}}, %{{.*}}[1] : !llvm.struct<(ptr, ptr, 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, ptr, i64, array<3 x i64>, array<3 x i64>)> -// CHECK-NEXT: llvm.insertvalue %[[M]], %{{.*}}[3, 0] : !llvm.struct<(ptr, ptr, i64, array<3 x i64>, array<3 x i64>)> -// CHECK-NEXT: llvm.insertvalue %[[c42]], %{{.*}}[3, 1] : !llvm.struct<(ptr, ptr, i64, array<3 x i64>, array<3 x i64>)> -// CHECK-NEXT: llvm.insertvalue %[[N]], %{{.*}}[3, 2] : !llvm.struct<(ptr, ptr, i64, array<3 x i64>, array<3 x i64>)> -// CHECK-NEXT: llvm.insertvalue %[[st0]], %{{.*}}[4, 0] : !llvm.struct<(ptr, ptr, i64, array<3 x i64>, array<3 x i64>)> -// CHECK-NEXT: llvm.insertvalue %[[N]], %{{.*}}[4, 1] : !llvm.struct<(ptr, ptr, i64, array<3 x i64>, array<3 x i64>)> -// CHECK-NEXT: llvm.insertvalue %[[one]], %{{.*}}[4, 2] : !llvm.struct<(ptr, ptr, i64, array<3 x i64>, array<3 x i64>)> - %0 = memref.alloc(%arg0, %arg1) : memref - return %0 : memref -} - -// ----- - -// CHECK-LABEL: func @mixed_dealloc -func.func @mixed_dealloc(%arg0: memref) { -// CHECK: %[[ptr:.*]] = llvm.extractvalue %{{.*}}[0] : !llvm.struct<(ptr, ptr, i64, array<3 x i64>, array<3 x i64>)> -// CHECK-NEXT: %[[ptri8:.*]] = llvm.bitcast %[[ptr]] : !llvm.ptr to !llvm.ptr -// CHECK-NEXT: llvm.call @free(%[[ptri8]]) : (!llvm.ptr) -> () - memref.dealloc %arg0 : memref - return -} - -// ----- - -// CHECK-LABEL: func @dynamic_alloc( -// CHECK: %[[Marg:.*]]: index, %[[Narg:.*]]: index) -func.func @dynamic_alloc(%arg0: index, %arg1: index) -> memref { -// 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 -// CHECK-NEXT: %[[gep:.*]] = llvm.getelementptr %[[null]][%[[sz]]] : (!llvm.ptr, i64) -> !llvm.ptr -// CHECK-NEXT: %[[sz_bytes:.*]] = llvm.ptrtoint %[[gep]] : !llvm.ptr to i64 -// CHECK-NEXT: llvm.call @malloc(%[[sz_bytes]]) : (i64) -> !llvm.ptr -// CHECK-NEXT: llvm.bitcast %{{.*}} : !llvm.ptr to !llvm.ptr -// CHECK-NEXT: llvm.mlir.undef : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> -// CHECK-NEXT: llvm.insertvalue %{{.*}}, %{{.*}}[0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> -// CHECK-NEXT: llvm.insertvalue %{{.*}}, %{{.*}}[1] : !llvm.struct<(ptr, ptr, 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, ptr, i64, array<2 x i64>, array<2 x i64>)> -// CHECK-NEXT: llvm.insertvalue %[[M]], %{{.*}}[3, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> -// CHECK-NEXT: llvm.insertvalue %[[N]], %{{.*}}[3, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> -// CHECK-NEXT: llvm.insertvalue %[[N]], %{{.*}}[4, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> -// CHECK-NEXT: llvm.insertvalue %[[one]], %{{.*}}[4, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> - %0 = memref.alloc(%arg0, %arg1) : memref - return %0 : memref -} - -// ----- - -// CHECK-LABEL: func @dynamic_dealloc -func.func @dynamic_dealloc(%arg0: memref) { -// CHECK: %[[ptr:.*]] = llvm.extractvalue %{{.*}}[0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> -// CHECK-NEXT: %[[ptri8:.*]] = llvm.bitcast %[[ptr]] : !llvm.ptr to !llvm.ptr -// CHECK-NEXT: llvm.call @free(%[[ptri8]]) : (!llvm.ptr) -> () - memref.dealloc %arg0 : memref - 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 - 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 - return -} - -// ----- - -// CHECK-LABEL: func @memref_cast_dynamic_to_static -func.func @memref_cast_dynamic_to_static(%dynamic : memref) { -// CHECK-NOT: llvm.bitcast - %0 = memref.cast %dynamic : memref to memref<10x12xf32> - return -} - -// ----- - -// CHECK-LABEL: func @memref_cast_dynamic_to_mixed -func.func @memref_cast_dynamic_to_mixed(%dynamic : memref) { -// CHECK-NOT: llvm.bitcast - %0 = memref.cast %dynamic : memref to memref - 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 - 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 - 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, ptr, i64, array<3 x i64>, array<3 x i64>)> : (i64) -> !llvm.ptr, ptr, i64, array<3 x i64>, array<3 x i64>)>> -// CHECK-DAG: llvm.store %{{.*}}, %[[p]] : !llvm.ptr, ptr, i64, array<3 x i64>, array<3 x i64>)>> -// CHECK-DAG: %[[p2:.*]] = llvm.bitcast %[[p]] : !llvm.ptr, ptr, i64, array<3 x i64>, array<3 x i64>)>> to !llvm.ptr -// CHECK-DAG: %[[r:.*]] = llvm.mlir.constant(3 : index) : i64 -// CHECK : llvm.mlir.undef : !llvm.struct<(i64, ptr)> -// CHECK-DAG: llvm.insertvalue %[[r]], %{{.*}}[0] : !llvm.struct<(i64, ptr)> -// CHECK-DAG: llvm.insertvalue %[[p2]], %{{.*}}[1] : !llvm.struct<(i64, ptr)> -// CHECK32-DAG: %[[c:.*]] = llvm.mlir.constant(1 : index) : i64 -// CHECK32-DAG: %[[p:.*]] = llvm.alloca %[[c]] x !llvm.struct<(ptr, ptr, i32, array<3 x i32>, array<3 x i32>)> : (i64) -> !llvm.ptr, ptr, i32, array<3 x i32>, array<3 x i32>)>> -// CHECK32-DAG: llvm.store %{{.*}}, %[[p]] : !llvm.ptr, ptr, i32, array<3 x i32>, array<3 x i32>)>> -// CHECK32-DAG: %[[p2:.*]] = llvm.bitcast %[[p]] : !llvm.ptr, ptr, i32, array<3 x i32>, array<3 x i32>)>> to !llvm.ptr -// CHECK32-DAG: %[[r:.*]] = llvm.mlir.constant(3 : index) : i32 -// CHECK32 : llvm.mlir.undef : !llvm.struct<(i32, ptr)> -// CHECK32-DAG: llvm.insertvalue %[[r]], %{{.*}}[0] : !llvm.struct<(i32, ptr)> -// CHECK32-DAG: llvm.insertvalue %[[p2]], %{{.*}}[1] : !llvm.struct<(i32, ptr)> - %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)> -// CHECK-NEXT: llvm.bitcast %[[p]] : !llvm.ptr to !llvm.ptr, ptr, i64, array<4 x i64>, array<4 x i64>)>> - %0 = memref.cast %arg : memref<*xf32> to memref - 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> - 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)> -// CHECK: [[BASE_PTR_PTR:%.*]] = llvm.bitcast [[DESCRIPTOR]] : !llvm.ptr to !llvm.ptr> -// CHECK: [[BASE_PTR:%.*]] = llvm.load [[BASE_PTR_PTR]] : !llvm.ptr> -// CHECK: [[BASE_PTR_PTR_:%.*]] = llvm.bitcast [[DESCRIPTOR]] : !llvm.ptr to !llvm.ptr> -// CHECK: [[ALIGNED_PTR_PTR:%.*]] = llvm.getelementptr [[BASE_PTR_PTR_]]{{\[}}1] -// CHECK-SAME: : (!llvm.ptr>) -> !llvm.ptr> -// CHECK: [[ALIGNED_PTR:%.*]] = llvm.load [[ALIGNED_PTR_PTR]] : !llvm.ptr> -// 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) { - %output = memref.reshape %input(%shape) - : (memref<2x3xf32>, memref) -> 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)> -// CHECK: [[UNRANKED_OUT_1:%.*]] = llvm.insertvalue [[RANK]], [[UNRANKED_OUT_O]][0] : !llvm.struct<(i64, ptr)> - -// 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 to !llvm.ptr> -// CHECK: llvm.store [[ALLOC_PTR]], [[BASE_PTR_PTR]] : !llvm.ptr> -// CHECK: [[BASE_PTR_PTR_:%.*]] = llvm.bitcast [[UNDERLYING_DESC]] : !llvm.ptr to !llvm.ptr> -// CHECK: [[ALIGNED_PTR_PTR:%.*]] = llvm.getelementptr [[BASE_PTR_PTR_]]{{\[}}1] -// CHECK: llvm.store [[ALIGN_PTR]], [[ALIGNED_PTR_PTR]] : !llvm.ptr> -// CHECK: [[BASE_PTR_PTR__:%.*]] = llvm.bitcast [[UNDERLYING_DESC]] : !llvm.ptr to !llvm.ptr> -// CHECK: [[OFFSET_PTR_:%.*]] = llvm.getelementptr [[BASE_PTR_PTR__]]{{\[}}2] -// CHECK: [[OFFSET_PTR:%.*]] = llvm.bitcast [[OFFSET_PTR_]] -// CHECK: llvm.store [[OFFSET]], [[OFFSET_PTR]] : !llvm.ptr - -// Iterate over shape operand in reverse order and set sizes and strides. -// CHECK: [[STRUCT_PTR:%.*]] = llvm.bitcast [[UNDERLYING_DESC]] -// CHECK-SAME: !llvm.ptr to !llvm.ptr, ptr, 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 -// CHECK: [[TARGET_SIZE_PTR:%.*]] = llvm.getelementptr [[SIZES_PTR]]{{\[}}[[DIM]]] -// CHECK: llvm.store [[SIZE]], [[TARGET_SIZE_PTR]] : !llvm.ptr -// CHECK: [[TARGET_STRIDE_PTR:%.*]] = llvm.getelementptr [[STRIDES_PTR]]{{\[}}[[DIM]]] -// CHECK: llvm.store [[CUR_STRIDE]], [[TARGET_STRIDE_PTR]] : !llvm.ptr -// 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