Author: Christian Ulmann Date: 2023-11-03T13:02:35+01:00 New Revision: 97a238e863fdf1f1a54e4bb609e130a6456a4f61
URL: https://github.com/llvm/llvm-project/commit/97a238e863fdf1f1a54e4bb609e130a6456a4f61 DIFF: https://github.com/llvm/llvm-project/commit/97a238e863fdf1f1a54e4bb609e130a6456a4f61.diff LOG: [MLIR][LLVM] Remove typed pointer conversion utils (#71169) This commit removes the no longer required type pointer helpers from the LLVM dialect conversion utils. 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/LoweringOptions.h mlir/include/mlir/Conversion/LLVMCommon/TypeConverter.h mlir/include/mlir/Dialect/LLVMIR/FunctionCallUtils.h mlir/lib/Conversion/FuncToLLVM/FuncToLLVM.cpp mlir/lib/Conversion/GPUCommon/GPUOpsLowering.cpp mlir/lib/Conversion/LLVMCommon/MemRefBuilder.cpp mlir/lib/Conversion/LLVMCommon/Pattern.cpp mlir/lib/Conversion/LLVMCommon/PrintCallHelper.cpp mlir/lib/Conversion/LLVMCommon/TypeConverter.cpp mlir/lib/Conversion/MemRefToLLVM/AllocLikeConversion.cpp mlir/lib/Conversion/SPIRVToLLVM/SPIRVToLLVM.cpp mlir/lib/Dialect/LLVMIR/IR/FunctionCallUtils.cpp mlir/lib/Dialect/NVGPU/TransformOps/NVGPUTransformOps.cpp Removed: ################################################################################ diff --git a/mlir/include/mlir/Conversion/LLVMCommon/LoweringOptions.h b/mlir/include/mlir/Conversion/LLVMCommon/LoweringOptions.h index cc4e17e9527f01e..c94892fd4f8164c 100644 --- a/mlir/include/mlir/Conversion/LLVMCommon/LoweringOptions.h +++ b/mlir/include/mlir/Conversion/LLVMCommon/LoweringOptions.h @@ -33,7 +33,6 @@ class LowerToLLVMOptions { LowerToLLVMOptions(MLIRContext *ctx, const DataLayout &dl); bool useBarePtrCallConv = false; - bool useOpaquePointers = true; enum class AllocLowering { /// Use malloc for heap allocations. diff --git a/mlir/include/mlir/Conversion/LLVMCommon/TypeConverter.h b/mlir/include/mlir/Conversion/LLVMCommon/TypeConverter.h index 2a4327535c68750..74f9c977b702860 100644 --- a/mlir/include/mlir/Conversion/LLVMCommon/TypeConverter.h +++ b/mlir/include/mlir/Conversion/LLVMCommon/TypeConverter.h @@ -125,17 +125,6 @@ class LLVMTypeConverter : public TypeConverter { /// integer type with the size configured for this type converter. Type getIndexType() const; - /// Returns true if using opaque pointers was enabled in the lowering options. - bool useOpaquePointers() const { return getOptions().useOpaquePointers; } - - /// Creates an LLVM pointer type with the given element type and address - /// space. - /// This function is meant to be used in code supporting both typed and opaque - /// pointers, as it will create an opaque pointer with the given address space - /// if opaque pointers are enabled in the lowering options. - LLVM::LLVMPointerType getPointerType(Type elementType, - unsigned addressSpace = 0) const; - /// Gets the bitwidth of the index type when converted to LLVM. unsigned getIndexTypeBitwidth() const { return options.getIndexBitwidth(); } diff --git a/mlir/include/mlir/Dialect/LLVMIR/FunctionCallUtils.h b/mlir/include/mlir/Dialect/LLVMIR/FunctionCallUtils.h index 8da609755f6cae6..123ce36cb0a7951 100644 --- a/mlir/include/mlir/Dialect/LLVMIR/FunctionCallUtils.h +++ b/mlir/include/mlir/Dialect/LLVMIR/FunctionCallUtils.h @@ -43,25 +43,21 @@ LLVM::LLVMFuncOp lookupOrCreatePrintF64Fn(ModuleOp moduleOp); /// If a custom runtime function is defined via `runtimeFunctionName`, it must /// have the signature void(char const*). The default function is `printString`. LLVM::LLVMFuncOp -lookupOrCreatePrintStringFn(ModuleOp moduleOp, bool opaquePointers, +lookupOrCreatePrintStringFn(ModuleOp moduleOp, std::optional<StringRef> runtimeFunctionName = {}); LLVM::LLVMFuncOp lookupOrCreatePrintOpenFn(ModuleOp moduleOp); LLVM::LLVMFuncOp lookupOrCreatePrintCloseFn(ModuleOp moduleOp); LLVM::LLVMFuncOp lookupOrCreatePrintCommaFn(ModuleOp moduleOp); LLVM::LLVMFuncOp lookupOrCreatePrintNewlineFn(ModuleOp moduleOp); -LLVM::LLVMFuncOp lookupOrCreateMallocFn(ModuleOp moduleOp, Type indexType, - bool opaquePointers = true); -LLVM::LLVMFuncOp lookupOrCreateAlignedAllocFn(ModuleOp moduleOp, Type indexType, - bool opaquePointers = true); -LLVM::LLVMFuncOp lookupOrCreateFreeFn(ModuleOp moduleOp, - bool opaquePointers = true); -LLVM::LLVMFuncOp lookupOrCreateGenericAllocFn(ModuleOp moduleOp, Type indexType, - bool opaquePointers = true); -LLVM::LLVMFuncOp -lookupOrCreateGenericAlignedAllocFn(ModuleOp moduleOp, Type indexType, - bool opaquePointers = true); -LLVM::LLVMFuncOp lookupOrCreateGenericFreeFn(ModuleOp moduleOp, - bool opaquePointers = true); +LLVM::LLVMFuncOp lookupOrCreateMallocFn(ModuleOp moduleOp, Type indexType); +LLVM::LLVMFuncOp lookupOrCreateAlignedAllocFn(ModuleOp moduleOp, + Type indexType); +LLVM::LLVMFuncOp lookupOrCreateFreeFn(ModuleOp moduleOp); +LLVM::LLVMFuncOp lookupOrCreateGenericAllocFn(ModuleOp moduleOp, + Type indexType); +LLVM::LLVMFuncOp lookupOrCreateGenericAlignedAllocFn(ModuleOp moduleOp, + Type indexType); +LLVM::LLVMFuncOp lookupOrCreateGenericFreeFn(ModuleOp moduleOp); LLVM::LLVMFuncOp lookupOrCreateMemRefCopyFn(ModuleOp moduleOp, Type indexType, Type unrankedDescriptorType); diff --git a/mlir/lib/Conversion/FuncToLLVM/FuncToLLVM.cpp b/mlir/lib/Conversion/FuncToLLVM/FuncToLLVM.cpp index 84e145c98e971e7..bd50c67fb87958a 100644 --- a/mlir/lib/Conversion/FuncToLLVM/FuncToLLVM.cpp +++ b/mlir/lib/Conversion/FuncToLLVM/FuncToLLVM.cpp @@ -241,7 +241,7 @@ static void wrapExternalFunction(OpBuilder &builder, Location loc, builder, loc, typeConverter, unrankedMemRefType, wrapperArgsRange.take_front(numToDrop)); - auto ptrTy = typeConverter.getPointerType(packed.getType()); + auto ptrTy = LLVM::LLVMPointerType::get(builder.getContext()); Value one = builder.create<LLVM::ConstantOp>( loc, typeConverter.convertType(builder.getIndexType()), builder.getIntegerAttr(builder.getIndexType(), 1)); diff --git a/mlir/lib/Conversion/GPUCommon/GPUOpsLowering.cpp b/mlir/lib/Conversion/GPUCommon/GPUOpsLowering.cpp index 6d2585aa30ab4c5..a747e9742d4fb72 100644 --- a/mlir/lib/Conversion/GPUCommon/GPUOpsLowering.cpp +++ b/mlir/lib/Conversion/GPUCommon/GPUOpsLowering.cpp @@ -106,18 +106,13 @@ GPUFuncOpLowering::matchAndRewrite(gpu::GPUFuncOp gpuFuncOp, OpAdaptor adaptor, for (const auto &en : llvm::enumerate(workgroupBuffers)) { LLVM::GlobalOp global = en.value(); + auto ptrType = LLVM::LLVMPointerType::get(rewriter.getContext(), + global.getAddrSpace()); Value address = rewriter.create<LLVM::AddressOfOp>( - loc, - getTypeConverter()->getPointerType(global.getType(), - global.getAddrSpace()), - global.getSymNameAttr()); - auto elementType = - cast<LLVM::LLVMArrayType>(global.getType()).getElementType(); - Value memory = rewriter.create<LLVM::GEPOp>( - loc, - getTypeConverter()->getPointerType(elementType, - global.getAddrSpace()), - global.getType(), address, ArrayRef<LLVM::GEPArg>{0, 0}); + loc, ptrType, global.getSymNameAttr()); + Value memory = + rewriter.create<LLVM::GEPOp>(loc, ptrType, global.getType(), address, + ArrayRef<LLVM::GEPArg>{0, 0}); // Build a memref descriptor pointing to the buffer to plug with the // existing memref infrastructure. This may use more registers than @@ -143,7 +138,7 @@ GPUFuncOpLowering::matchAndRewrite(gpu::GPUFuncOp gpuFuncOp, OpAdaptor adaptor, // memory space and does not support `alloca`s with addrspace(5). Type elementType = typeConverter->convertType(type.getElementType()); auto ptrType = - getTypeConverter()->getPointerType(elementType, allocaAddrSpace); + LLVM::LLVMPointerType::get(rewriter.getContext(), allocaAddrSpace); Value numElements = rewriter.create<LLVM::ConstantOp>( gpuFuncOp.getLoc(), int64Ty, type.getNumElements()); uint64_t alignment = 0; @@ -275,7 +270,7 @@ LogicalResult GPUPrintfOpToHIPLowering::matchAndRewrite( Location loc = gpuPrintfOp->getLoc(); mlir::Type llvmI8 = typeConverter->convertType(rewriter.getI8Type()); - mlir::Type i8Ptr = getTypeConverter()->getPointerType(llvmI8); + auto ptrType = LLVM::LLVMPointerType::get(rewriter.getContext()); mlir::Type llvmI32 = typeConverter->convertType(rewriter.getI32Type()); mlir::Type llvmI64 = typeConverter->convertType(rewriter.getI64Type()); // Note: this is the GPUModule op, not the ModuleOp that surrounds it @@ -298,7 +293,7 @@ LogicalResult GPUPrintfOpToHIPLowering::matchAndRewrite( moduleOp, loc, rewriter, "__ockl_printf_append_string_n", LLVM::LLVMFunctionType::get( llvmI64, - {llvmI64, i8Ptr, /*length (bytes)*/ llvmI64, /*isLast*/ llvmI32})); + {llvmI64, ptrType, /*length (bytes)*/ llvmI64, /*isLast*/ llvmI32})); /// Start the printf hostcall Value zeroI64 = rewriter.create<LLVM::ConstantOp>(loc, llvmI64, 0); @@ -326,10 +321,10 @@ LogicalResult GPUPrintfOpToHIPLowering::matchAndRewrite( // Get a pointer to the format string's first element and pass it to printf() Value globalPtr = rewriter.create<LLVM::AddressOfOp>( loc, - getTypeConverter()->getPointerType(globalType, global.getAddrSpace()), + LLVM::LLVMPointerType::get(rewriter.getContext(), global.getAddrSpace()), global.getSymNameAttr()); Value stringStart = rewriter.create<LLVM::GEPOp>( - loc, i8Ptr, globalType, globalPtr, ArrayRef<LLVM::GEPArg>{0, 0}); + loc, ptrType, globalType, globalPtr, ArrayRef<LLVM::GEPArg>{0, 0}); Value stringLen = rewriter.create<LLVM::ConstantOp>(loc, llvmI64, formatStringSize); @@ -386,15 +381,17 @@ LogicalResult GPUPrintfOpToLLVMCallLowering::matchAndRewrite( Location loc = gpuPrintfOp->getLoc(); mlir::Type llvmI8 = typeConverter->convertType(rewriter.getIntegerType(8)); - mlir::Type i8Ptr = getTypeConverter()->getPointerType(llvmI8, addressSpace); + mlir::Type ptrType = + LLVM::LLVMPointerType::get(rewriter.getContext(), addressSpace); // Note: this is the GPUModule op, not the ModuleOp that surrounds it // This ensures that global constants and declarations are placed within // the device code, not the host code auto moduleOp = gpuPrintfOp->getParentOfType<gpu::GPUModuleOp>(); - auto printfType = LLVM::LLVMFunctionType::get(rewriter.getI32Type(), {i8Ptr}, - /*isVarArg=*/true); + auto printfType = + LLVM::LLVMFunctionType::get(rewriter.getI32Type(), {ptrType}, + /*isVarArg=*/true); LLVM::LLVMFuncOp printfDecl = getOrDefineFunction(moduleOp, loc, rewriter, "printf", printfType); @@ -418,10 +415,10 @@ LogicalResult GPUPrintfOpToLLVMCallLowering::matchAndRewrite( // Get a pointer to the format string's first element Value globalPtr = rewriter.create<LLVM::AddressOfOp>( loc, - getTypeConverter()->getPointerType(globalType, global.getAddrSpace()), + LLVM::LLVMPointerType::get(rewriter.getContext(), global.getAddrSpace()), global.getSymNameAttr()); Value stringStart = rewriter.create<LLVM::GEPOp>( - loc, i8Ptr, globalType, globalPtr, ArrayRef<LLVM::GEPArg>{0, 0}); + loc, ptrType, globalType, globalPtr, ArrayRef<LLVM::GEPArg>{0, 0}); // Construct arguments and function call auto argsRange = adaptor.getArgs(); @@ -473,8 +470,7 @@ LogicalResult GPUPrintfOpToVPrintfLowering::matchAndRewrite( // Get a pointer to the format string's first element Value globalPtr = rewriter.create<LLVM::AddressOfOp>(loc, global); Value stringStart = rewriter.create<LLVM::GEPOp>( - loc, getTypeConverter()->getPointerType(globalType), globalType, - globalPtr, ArrayRef<LLVM::GEPArg>{0, 0}); + loc, ptrType, globalType, globalPtr, ArrayRef<LLVM::GEPArg>{0, 0}); SmallVector<Type> types; SmallVector<Value> args; // Promote and pack the arguments into a stack allocation. @@ -498,8 +494,7 @@ LogicalResult GPUPrintfOpToVPrintfLowering::matchAndRewrite( /*alignment=*/0); for (auto [index, arg] : llvm::enumerate(args)) { Value ptr = rewriter.create<LLVM::GEPOp>( - loc, getTypeConverter()->getPointerType(structType), structType, - tempAlloc, ArrayRef<LLVM::GEPArg>{0, index}); + loc, ptrType, structType, tempAlloc, ArrayRef<LLVM::GEPArg>{0, index}); rewriter.create<LLVM::StoreOp>(loc, arg, ptr); } std::array<Value, 2> printfArgs = {stringStart, tempAlloc}; diff --git a/mlir/lib/Conversion/LLVMCommon/MemRefBuilder.cpp b/mlir/lib/Conversion/LLVMCommon/MemRefBuilder.cpp index 023fd6244ce1afb..da084b89ceadc25 100644 --- a/mlir/lib/Conversion/LLVMCommon/MemRefBuilder.cpp +++ b/mlir/lib/Conversion/LLVMCommon/MemRefBuilder.cpp @@ -486,10 +486,10 @@ Value UnrankedMemRefDescriptor::size(OpBuilder &builder, Location loc, Value sizeBasePtr, Value index) { Type indexTy = typeConverter.getIndexType(); - Type indexPtrTy = typeConverter.getPointerType(indexTy); + auto ptrType = LLVM::LLVMPointerType::get(builder.getContext()); Value sizeStoreGep = - builder.create<LLVM::GEPOp>(loc, indexPtrTy, indexTy, sizeBasePtr, index); + builder.create<LLVM::GEPOp>(loc, ptrType, indexTy, sizeBasePtr, index); return builder.create<LLVM::LoadOp>(loc, indexTy, sizeStoreGep); } @@ -498,10 +498,10 @@ void UnrankedMemRefDescriptor::setSize(OpBuilder &builder, Location loc, Value sizeBasePtr, Value index, Value size) { Type indexTy = typeConverter.getIndexType(); - Type indexPtrTy = typeConverter.getPointerType(indexTy); + auto ptrType = LLVM::LLVMPointerType::get(builder.getContext()); Value sizeStoreGep = - builder.create<LLVM::GEPOp>(loc, indexPtrTy, indexTy, sizeBasePtr, index); + builder.create<LLVM::GEPOp>(loc, ptrType, indexTy, sizeBasePtr, index); builder.create<LLVM::StoreOp>(loc, size, sizeStoreGep); } @@ -509,10 +509,9 @@ Value UnrankedMemRefDescriptor::strideBasePtr( OpBuilder &builder, Location loc, const LLVMTypeConverter &typeConverter, Value sizeBasePtr, Value rank) { Type indexTy = typeConverter.getIndexType(); - Type indexPtrTy = typeConverter.getPointerType(indexTy); + auto ptrType = LLVM::LLVMPointerType::get(builder.getContext()); - return builder.create<LLVM::GEPOp>(loc, indexPtrTy, indexTy, sizeBasePtr, - rank); + return builder.create<LLVM::GEPOp>(loc, ptrType, indexTy, sizeBasePtr, rank); } Value UnrankedMemRefDescriptor::stride(OpBuilder &builder, Location loc, @@ -520,10 +519,10 @@ Value UnrankedMemRefDescriptor::stride(OpBuilder &builder, Location loc, Value strideBasePtr, Value index, Value stride) { Type indexTy = typeConverter.getIndexType(); - Type indexPtrTy = typeConverter.getPointerType(indexTy); + auto ptrType = LLVM::LLVMPointerType::get(builder.getContext()); - Value strideStoreGep = builder.create<LLVM::GEPOp>(loc, indexPtrTy, indexTy, - strideBasePtr, index); + Value strideStoreGep = + builder.create<LLVM::GEPOp>(loc, ptrType, indexTy, strideBasePtr, index); return builder.create<LLVM::LoadOp>(loc, indexTy, strideStoreGep); } @@ -532,9 +531,9 @@ void UnrankedMemRefDescriptor::setStride(OpBuilder &builder, Location loc, Value strideBasePtr, Value index, Value stride) { Type indexTy = typeConverter.getIndexType(); - Type indexPtrTy = typeConverter.getPointerType(indexTy); + auto ptrType = LLVM::LLVMPointerType::get(builder.getContext()); - Value strideStoreGep = builder.create<LLVM::GEPOp>(loc, indexPtrTy, indexTy, - strideBasePtr, index); + Value strideStoreGep = + builder.create<LLVM::GEPOp>(loc, ptrType, indexTy, strideBasePtr, index); builder.create<LLVM::StoreOp>(loc, stride, strideStoreGep); } diff --git a/mlir/lib/Conversion/LLVMCommon/Pattern.cpp b/mlir/lib/Conversion/LLVMCommon/Pattern.cpp index 40d4c97975a6a94..83c31a204efc7e0 100644 --- a/mlir/lib/Conversion/LLVMCommon/Pattern.cpp +++ b/mlir/lib/Conversion/LLVMCommon/Pattern.cpp @@ -47,8 +47,7 @@ Type ConvertToLLVMPattern::getVoidType() const { } Type ConvertToLLVMPattern::getVoidPtrType() const { - return getTypeConverter()->getPointerType( - IntegerType::get(&getTypeConverter()->getContext(), 8)); + return LLVM::LLVMPointerType::get(&getTypeConverter()->getContext()); } Value ConvertToLLVMPattern::createIndexAttrConstant(OpBuilder &builder, @@ -106,12 +105,10 @@ bool ConvertToLLVMPattern::isConvertibleAndHasIdentityMaps( } Type ConvertToLLVMPattern::getElementPtrType(MemRefType type) const { - auto elementType = type.getElementType(); - auto structElementType = typeConverter->convertType(elementType); auto addressSpace = getTypeConverter()->getMemRefAddressSpace(type); if (failed(addressSpace)) return {}; - return getTypeConverter()->getPointerType(structElementType, *addressSpace); + return LLVM::LLVMPointerType::get(type.getContext(), *addressSpace); } void ConvertToLLVMPattern::getMemRefDescriptorSizes( @@ -161,7 +158,7 @@ void ConvertToLLVMPattern::getMemRefDescriptorSizes( if (sizeInBytes) { // Buffer size in bytes. Type elementType = typeConverter->convertType(memRefType.getElementType()); - Type elementPtrType = getTypeConverter()->getPointerType(elementType); + auto elementPtrType = LLVM::LLVMPointerType::get(rewriter.getContext()); Value nullPtr = rewriter.create<LLVM::ZeroOp>(loc, elementPtrType); Value gepPtr = rewriter.create<LLVM::GEPOp>( loc, elementPtrType, elementType, nullPtr, runningStride); @@ -179,7 +176,7 @@ Value ConvertToLLVMPattern::getSizeInBytes( // %1 = ptrtoint %elementType* %0 to %indexType // which is a common pattern of getting the size of a type in bytes. Type llvmType = typeConverter->convertType(type); - auto convertedPtrType = getTypeConverter()->getPointerType(llvmType); + auto convertedPtrType = LLVM::LLVMPointerType::get(rewriter.getContext()); auto nullPtr = rewriter.create<LLVM::ZeroOp>(loc, convertedPtrType); auto gep = rewriter.create<LLVM::GEPOp>(loc, convertedPtrType, llvmType, nullPtr, ArrayRef<LLVM::GEPArg>{1}); @@ -283,11 +280,9 @@ LogicalResult ConvertToLLVMPattern::copyUnrankedDescriptors( auto module = builder.getInsertionPoint()->getParentOfType<ModuleOp>(); LLVM::LLVMFuncOp freeFunc, mallocFunc; if (toDynamic) - mallocFunc = LLVM::lookupOrCreateMallocFn( - module, indexType, getTypeConverter()->useOpaquePointers()); + mallocFunc = LLVM::lookupOrCreateMallocFn(module, indexType); if (!toDynamic) - freeFunc = LLVM::lookupOrCreateFreeFn( - module, getTypeConverter()->useOpaquePointers()); + freeFunc = LLVM::lookupOrCreateFreeFn(module); unsigned unrankedMemrefPos = 0; for (unsigned i = 0, e = operands.size(); i < e; ++i) { diff --git a/mlir/lib/Conversion/LLVMCommon/PrintCallHelper.cpp b/mlir/lib/Conversion/LLVMCommon/PrintCallHelper.cpp index 6293643ac6f0349..bd7b401efec17a9 100644 --- a/mlir/lib/Conversion/LLVMCommon/PrintCallHelper.cpp +++ b/mlir/lib/Conversion/LLVMCommon/PrintCallHelper.cpp @@ -51,16 +51,16 @@ void mlir::LLVM::createPrintStrCall( loc, arrayTy, /*constant=*/true, LLVM::Linkage::Private, ensureSymbolNameIsUnique(moduleOp, symbolName), dataAttr); + auto ptrTy = LLVM::LLVMPointerType::get(builder.getContext()); // Emit call to `printStr` in runtime library. builder.restoreInsertionPoint(ip); - auto msgAddr = builder.create<LLVM::AddressOfOp>( - loc, typeConverter.getPointerType(arrayTy), globalOp.getName()); + auto msgAddr = + builder.create<LLVM::AddressOfOp>(loc, ptrTy, globalOp.getName()); SmallVector<LLVM::GEPArg> indices(1, 0); - Value gep = builder.create<LLVM::GEPOp>( - loc, typeConverter.getPointerType(builder.getI8Type()), arrayTy, msgAddr, - indices); - Operation *printer = LLVM::lookupOrCreatePrintStringFn( - moduleOp, typeConverter.useOpaquePointers(), runtimeFunctionName); + Value gep = + builder.create<LLVM::GEPOp>(loc, ptrTy, arrayTy, msgAddr, indices); + Operation *printer = + LLVM::lookupOrCreatePrintStringFn(moduleOp, runtimeFunctionName); builder.create<LLVM::CallOp>(loc, TypeRange(), SymbolRefAttr::get(printer), gep); } diff --git a/mlir/lib/Conversion/LLVMCommon/TypeConverter.cpp b/mlir/lib/Conversion/LLVMCommon/TypeConverter.cpp index fe3a8c6d410902b..35b95d7a5ebe925 100644 --- a/mlir/lib/Conversion/LLVMCommon/TypeConverter.cpp +++ b/mlir/lib/Conversion/LLVMCommon/TypeConverter.cpp @@ -209,14 +209,6 @@ Type LLVMTypeConverter::getIndexType() const { return IntegerType::get(&getContext(), getIndexTypeBitwidth()); } -LLVM::LLVMPointerType -LLVMTypeConverter::getPointerType(Type elementType, - unsigned int addressSpace) const { - if (useOpaquePointers()) - return LLVM::LLVMPointerType::get(&getContext(), addressSpace); - return LLVM::LLVMPointerType::get(elementType, addressSpace); -} - unsigned LLVMTypeConverter::getPointerBitwidth(unsigned addressSpace) const { return options.dataLayout.getPointerSizeInBits(addressSpace); } @@ -249,12 +241,7 @@ Type LLVMTypeConverter::convertComplexType(ComplexType type) const { // Except for signatures, MLIR function types are converted into LLVM // pointer-to-function types. Type LLVMTypeConverter::convertFunctionType(FunctionType type) const { - SignatureConversion conversion(type.getNumInputs()); - Type converted = convertFunctionSignature( - type, /*isVariadic=*/false, options.useBarePtrCallConv, conversion); - if (!converted) - return {}; - return getPointerType(converted); + return LLVM::LLVMPointerType::get(type.getContext()); } // Function types are converted to LLVM Function types by recursively converting @@ -301,11 +288,12 @@ LLVMTypeConverter::convertFunctionTypeCWrapper(FunctionType type) const { if (!resultType) return {}; + auto ptrType = LLVM::LLVMPointerType::get(type.getContext()); auto structType = dyn_cast<LLVM::LLVMStructType>(resultType); if (structType) { // Struct types cannot be safely returned via C interface. Make this a // pointer argument, instead. - inputs.push_back(getPointerType(structType)); + inputs.push_back(ptrType); resultType = LLVM::LLVMVoidType::get(&getContext()); } @@ -314,7 +302,7 @@ LLVMTypeConverter::convertFunctionTypeCWrapper(FunctionType type) const { if (!converted || !LLVM::isCompatibleType(converted)) return {}; if (isa<MemRefType, UnrankedMemRefType>(t)) - converted = getPointerType(converted); + converted = ptrType; inputs.push_back(converted); } @@ -373,7 +361,7 @@ LLVMTypeConverter::getMemRefDescriptorFields(MemRefType type, "failed. Consider adding memory space conversions."; return {}; } - auto ptrTy = getPointerType(elementType, *addressSpace); + auto ptrTy = LLVM::LLVMPointerType::get(type.getContext(), *addressSpace); auto indexTy = getIndexType(); @@ -419,7 +407,7 @@ Type LLVMTypeConverter::convertMemRefType(MemRefType type) const { /// be unranked. SmallVector<Type, 2> LLVMTypeConverter::getUnrankedMemRefDescriptorFields() const { - return {getIndexType(), getPointerType(IntegerType::get(&getContext(), 8))}; + return {getIndexType(), LLVM::LLVMPointerType::get(&getContext())}; } unsigned LLVMTypeConverter::getUnrankedMemRefDescriptorSize( @@ -487,7 +475,7 @@ Type LLVMTypeConverter::convertMemRefToBarePtr(BaseMemRefType type) const { FailureOr<unsigned> addressSpace = getMemRefAddressSpace(type); if (failed(addressSpace)) return {}; - return getPointerType(elementType, *addressSpace); + return LLVM::LLVMPointerType::get(type.getContext(), *addressSpace); } /// Convert an n-D vector type to an LLVM vector type: @@ -593,7 +581,7 @@ Value LLVMTypeConverter::promoteOneMemRefDescriptor(Location loc, Value operand, OpBuilder &builder) const { // Alloca with proper alignment. We do not expect optimizations of this // alloca op and so we omit allocating at the entry block. - auto ptrType = getPointerType(operand.getType()); + auto ptrType = LLVM::LLVMPointerType::get(builder.getContext()); Value one = builder.create<LLVM::ConstantOp>(loc, builder.getI64Type(), builder.getIndexAttr(1)); Value allocated = diff --git a/mlir/lib/Conversion/MemRefToLLVM/AllocLikeConversion.cpp b/mlir/lib/Conversion/MemRefToLLVM/AllocLikeConversion.cpp index 7e3fb9e95bc2cd9..b29abc94ce400c4 100644 --- a/mlir/lib/Conversion/MemRefToLLVM/AllocLikeConversion.cpp +++ b/mlir/lib/Conversion/MemRefToLLVM/AllocLikeConversion.cpp @@ -62,9 +62,7 @@ static Value castAllocFuncResult(ConversionPatternRewriter &rewriter, unsigned memrefAddrSpace = *maybeMemrefAddrSpace; if (allocatedPtrTy.getAddressSpace() != memrefAddrSpace) allocatedPtr = rewriter.create<LLVM::AddrSpaceCastOp>( - loc, - typeConverter.getPointerType(allocatedPtrTy.getElementType(), - memrefAddrSpace), + loc, LLVM::LLVMPointerType::get(rewriter.getContext(), memrefAddrSpace), allocatedPtr); return allocatedPtr; } diff --git a/mlir/lib/Conversion/SPIRVToLLVM/SPIRVToLLVM.cpp b/mlir/lib/Conversion/SPIRVToLLVM/SPIRVToLLVM.cpp index cbc09c9ddfa3aa9..c62e676efc159a0 100644 --- a/mlir/lib/Conversion/SPIRVToLLVM/SPIRVToLLVM.cpp +++ b/mlir/lib/Conversion/SPIRVToLLVM/SPIRVToLLVM.cpp @@ -314,9 +314,8 @@ static unsigned mapToAddressSpace(spirv::ClientAPI clientAPI, static Type convertPointerType(spirv::PointerType type, LLVMTypeConverter &converter, spirv::ClientAPI clientAPI) { - auto pointeeType = converter.convertType(type.getPointeeType()); unsigned addressSpace = mapToAddressSpace(clientAPI, type.getStorageClass()); - return converter.getPointerType(pointeeType, addressSpace); + return LLVM::LLVMPointerType::get(type.getContext(), addressSpace); } /// Converts SPIR-V runtime array to LLVM array. Since LLVM allows indexing over diff --git a/mlir/lib/Dialect/LLVMIR/IR/FunctionCallUtils.cpp b/mlir/lib/Dialect/LLVMIR/IR/FunctionCallUtils.cpp index 7ed8296a22a4570..0004c2e3403e53a 100644 --- a/mlir/lib/Dialect/LLVMIR/IR/FunctionCallUtils.cpp +++ b/mlir/lib/Dialect/LLVMIR/IR/FunctionCallUtils.cpp @@ -93,25 +93,19 @@ LLVM::LLVMFuncOp mlir::LLVM::lookupOrCreatePrintF64Fn(ModuleOp moduleOp) { LLVM::LLVMVoidType::get(moduleOp->getContext())); } -static LLVM::LLVMPointerType getCharPtr(MLIRContext *context, - bool opaquePointers) { - if (opaquePointers) - return LLVM::LLVMPointerType::get(context); - - return LLVM::LLVMPointerType::get(IntegerType::get(context, 8)); +static LLVM::LLVMPointerType getCharPtr(MLIRContext *context) { + return LLVM::LLVMPointerType::get(context); } -static LLVM::LLVMPointerType getVoidPtr(MLIRContext *context, - bool opaquePointers) { +static LLVM::LLVMPointerType getVoidPtr(MLIRContext *context) { // A char pointer and void ptr are the same in LLVM IR. - return getCharPtr(context, opaquePointers); + return getCharPtr(context); } LLVM::LLVMFuncOp mlir::LLVM::lookupOrCreatePrintStringFn( - ModuleOp moduleOp, bool opaquePointers, - std::optional<StringRef> runtimeFunctionName) { + ModuleOp moduleOp, std::optional<StringRef> runtimeFunctionName) { return lookupOrCreateFn(moduleOp, runtimeFunctionName.value_or(kPrintString), - getCharPtr(moduleOp->getContext(), opaquePointers), + getCharPtr(moduleOp->getContext()), LLVM::LLVMVoidType::get(moduleOp->getContext())); } @@ -136,48 +130,40 @@ LLVM::LLVMFuncOp mlir::LLVM::lookupOrCreatePrintNewlineFn(ModuleOp moduleOp) { } LLVM::LLVMFuncOp mlir::LLVM::lookupOrCreateMallocFn(ModuleOp moduleOp, - Type indexType, - bool opaquePointers) { - return LLVM::lookupOrCreateFn( - moduleOp, kMalloc, indexType, - getVoidPtr(moduleOp->getContext(), opaquePointers)); + Type indexType) { + return LLVM::lookupOrCreateFn(moduleOp, kMalloc, indexType, + getVoidPtr(moduleOp->getContext())); } LLVM::LLVMFuncOp mlir::LLVM::lookupOrCreateAlignedAllocFn(ModuleOp moduleOp, - Type indexType, - bool opaquePointers) { - return LLVM::lookupOrCreateFn( - moduleOp, kAlignedAlloc, {indexType, indexType}, - getVoidPtr(moduleOp->getContext(), opaquePointers)); + Type indexType) { + return LLVM::lookupOrCreateFn(moduleOp, kAlignedAlloc, {indexType, indexType}, + getVoidPtr(moduleOp->getContext())); } -LLVM::LLVMFuncOp mlir::LLVM::lookupOrCreateFreeFn(ModuleOp moduleOp, - bool opaquePointers) { +LLVM::LLVMFuncOp mlir::LLVM::lookupOrCreateFreeFn(ModuleOp moduleOp) { return LLVM::lookupOrCreateFn( - moduleOp, kFree, getVoidPtr(moduleOp->getContext(), opaquePointers), + moduleOp, kFree, getVoidPtr(moduleOp->getContext()), LLVM::LLVMVoidType::get(moduleOp->getContext())); } LLVM::LLVMFuncOp mlir::LLVM::lookupOrCreateGenericAllocFn(ModuleOp moduleOp, - Type indexType, - bool opaquePointers) { - return LLVM::lookupOrCreateFn( - moduleOp, kGenericAlloc, indexType, - getVoidPtr(moduleOp->getContext(), opaquePointers)); + Type indexType) { + return LLVM::lookupOrCreateFn(moduleOp, kGenericAlloc, indexType, + getVoidPtr(moduleOp->getContext())); } -LLVM::LLVMFuncOp mlir::LLVM::lookupOrCreateGenericAlignedAllocFn( - ModuleOp moduleOp, Type indexType, bool opaquePointers) { - return LLVM::lookupOrCreateFn( - moduleOp, kGenericAlignedAlloc, {indexType, indexType}, - getVoidPtr(moduleOp->getContext(), opaquePointers)); +LLVM::LLVMFuncOp +mlir::LLVM::lookupOrCreateGenericAlignedAllocFn(ModuleOp moduleOp, + Type indexType) { + return LLVM::lookupOrCreateFn(moduleOp, kGenericAlignedAlloc, + {indexType, indexType}, + getVoidPtr(moduleOp->getContext())); } -LLVM::LLVMFuncOp mlir::LLVM::lookupOrCreateGenericFreeFn(ModuleOp moduleOp, - bool opaquePointers) { +LLVM::LLVMFuncOp mlir::LLVM::lookupOrCreateGenericFreeFn(ModuleOp moduleOp) { return LLVM::lookupOrCreateFn( - moduleOp, kGenericFree, - getVoidPtr(moduleOp->getContext(), opaquePointers), + moduleOp, kGenericFree, getVoidPtr(moduleOp->getContext()), LLVM::LLVMVoidType::get(moduleOp->getContext())); } diff --git a/mlir/lib/Dialect/NVGPU/TransformOps/NVGPUTransformOps.cpp b/mlir/lib/Dialect/NVGPU/TransformOps/NVGPUTransformOps.cpp index 408c1dc798feeb4..316ed17caf47dcd 100644 --- a/mlir/lib/Dialect/NVGPU/TransformOps/NVGPUTransformOps.cpp +++ b/mlir/lib/Dialect/NVGPU/TransformOps/NVGPUTransformOps.cpp @@ -99,8 +99,7 @@ void transform::ApplyNVGPUToNVVMConversionPatternsOp::populatePatterns( }); llvmTypeConverter.addConversion( [&](nvgpu::TensorMapDescriptorType type) -> Type { - return llvmTypeConverter.getPointerType( - type.getTensor().getElementType()); + return LLVM::LLVMPointerType::get(type.getContext()); }); populateNVGPUToNVVMConversionPatterns(llvmTypeConverter, patterns); } _______________________________________________ llvm-branch-commits mailing list llvm-branch-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-branch-commits
