From cbe4f4b9e3b8925104936f85caa8e3192e2771c6 Mon Sep 17 00:00:00 2001 From: Lukas Sommer Date: Mon, 27 Mar 2023 13:06:43 +0100 Subject: [PATCH 01/11] Introduce additional parameter for opaque pointers Signed-off-by: Lukas Sommer --- .../lib/Conversion/SYCLToLLVM/SYCLToLLVM.cpp | 134 +++++++++++------- 1 file changed, 80 insertions(+), 54 deletions(-) diff --git a/mlir-sycl/lib/Conversion/SYCLToLLVM/SYCLToLLVM.cpp b/mlir-sycl/lib/Conversion/SYCLToLLVM/SYCLToLLVM.cpp index ad597f52a0293..5f9ab64b33119 100644 --- a/mlir-sycl/lib/Conversion/SYCLToLLVM/SYCLToLLVM.cpp +++ b/mlir-sycl/lib/Conversion/SYCLToLLVM/SYCLToLLVM.cpp @@ -257,7 +257,7 @@ class GetMemberPatternBase { std::is_constructible_v || is_empty_v>> Value getRef(OpBuilder &builder, Location loc, Type ty, Value ptr, - std::optional targetAddressSpace, + std::optional targetAddressSpace, bool useOpaquePtr, Args &&...args) const { SmallVector indices{0}; const auto staticIndices = getIndices(); @@ -294,9 +294,9 @@ class GetMemberPatternBase { std::is_constructible_v || is_empty_v>> Value loadValue(OpBuilder &builder, Location loc, Type ty, Value ptr, - Args &&...args) const { + bool useOpaquePtr, Args &&...args) const { const auto gep = getRef(builder, loc, ty, ptr, std::nullopt, - std::forward(args)...); + useOpaquePtr, std::forward(args)...); return builder.create(loc, gep); } @@ -356,11 +356,14 @@ class GetRefToMemberPattern : public GetMemberPattern, void rewrite(Op op, OpAdaptor adaptor, ConversionPatternRewriter &rewriter) const final { const auto operands = adaptor.getOperands(); + const auto elemTy = getTypeConverter()->convertType( + cast(op.getType())->getElementType()); const auto ptrTy = getTypeConverter() ->convertType(op.getType()) .template cast(); - rewriter.replaceOp(op, getRef(rewriter, op.getLoc(), ptrTy.getElementType(), - ptrTy.getAddressSpace(), operands[0])); + rewriter.replaceOp( + op, getRef(rewriter, op.getLoc(), elemTy, ptrTy.getAddressSpace(), + getTypeConverter()->useOpaquePointers(), operands[0])); } }; @@ -383,11 +386,14 @@ class GetRefToMemberDimPattern : public GetMemberPattern, void rewrite(Op op, OpAdaptor adaptor, ConversionPatternRewriter &rewriter) const final { const auto operands = adaptor.getOperands(); + const auto elemTy = getTypeConverter()->convertType( + cast(op.getType()).getElementType()); const auto ptrTy = getTypeConverter() ->convertType(op.getType()) .template cast(); - rewriter.replaceOp(op, getRef(rewriter, op.getLoc(), ptrTy.getElementType(), - operands[0], ptrTy.getAddressSpace(), + rewriter.replaceOp(op, getRef(rewriter, op.getLoc(), elemTy, operands[0], + ptrTy.getAddressSpace(), + getTypeConverter()->useOpaquePointers(), operands[1])); } }; @@ -410,10 +416,10 @@ class LoadMemberPattern : public GetMemberPattern, void rewrite(Op op, OpAdaptor adaptor, ConversionPatternRewriter &rewriter) const final { const auto operands = adaptor.getOperands(); - rewriter.replaceOp(op, - loadValue(rewriter, op.getLoc(), - getTypeConverter()->convertType(op.getType()), - operands[0])); + rewriter.replaceOp( + op, loadValue(rewriter, op.getLoc(), + getTypeConverter()->convertType(op.getType()), + operands[0], getTypeConverter()->useOpaquePointers())); } }; @@ -435,10 +441,11 @@ class LoadMemberDimPattern : public GetMemberPattern, void rewrite(Op op, OpAdaptor adaptor, ConversionPatternRewriter &rewriter) const final { const auto operands = adaptor.getOperands(); - rewriter.replaceOp(op, - loadValue(rewriter, op.getLoc(), - getTypeConverter()->convertType(op.getType()), - operands[0], operands[1])); + rewriter.replaceOp( + op, + loadValue(rewriter, op.getLoc(), + getTypeConverter()->convertType(op.getType()), operands[0], + getTypeConverter()->useOpaquePointers(), operands[1])); } }; @@ -471,10 +478,8 @@ class AddZeroArgPattern : public ConvertOpToLLVMPattern { /// range. template class GetRangeSizePattern : public ConvertOpToLLVMPattern { -private: - using ConvertOpToLLVMPattern::getTypeConverter; - protected: + using ConvertOpToLLVMPattern::getTypeConverter; using ConvertOpToLLVMPattern::ConvertOpToLLVMPattern; using typename ConvertOpToLLVMPattern::OpAdaptor; @@ -505,10 +510,8 @@ class GetRangeSizePattern : public ConvertOpToLLVMPattern { template class GetLinearIDPattern : public ConvertOpToLLVMPattern { -private: - using ConvertOpToLLVMPattern::getTypeConverter; - protected: + using ConvertOpToLLVMPattern::getTypeConverter; using typename ConvertOpToLLVMPattern::OpAdaptor; using ConvertOpToLLVMPattern::ConvertOpToLLVMPattern; @@ -1071,10 +1074,12 @@ class AccessorGetPointerPattern const auto acc = opAdaptor.getAcc(); const auto resTy = getTypeConverter()->getIndexType(); Value res = builder.create(loc, 0, resTy); + bool useOpaquePointers = getTypeConverter()->useOpaquePointers(); for (unsigned i = 0; i < accTy.getDimension(); ++i) { // Res = Res * Mem[I] + Id[I] - const auto memI = getMemRange(builder, loc, resTy, acc, i); - const auto idI = getID(builder, loc, resTy, acc, i); + const auto memI = + getMemRange(builder, loc, resTy, acc, useOpaquePointers, i); + const auto idI = getID(builder, loc, resTy, acc, useOpaquePointers, i); res = builder.create( loc, builder.create(loc, res, memI), idI); } @@ -1097,7 +1102,8 @@ class AccessorGetPointerPattern const auto ptrTy = cast( getTypeConverter()->convertType(op.getType())); Value ptr = GetMemberPattern::loadValue( - rewriter, loc, ptrTy, opAdaptor.getAcc()); + rewriter, loc, ptrTy, opAdaptor.getAcc(), + getTypeConverter()->useOpaquePointers()); rewriter.replaceOpWithNewOp(op, ptrTy, ptr, index, /*inbounds*/ true); return success(); @@ -1130,7 +1136,8 @@ class AccessorSizePattern Value getRange(OpBuilder &builder, Location loc, Type ty, Value thisArg, int32_t index) const final { return GetMemberPattern::loadValue( - builder, loc, ty, thisArg, index); + builder, loc, ty, thisArg, getTypeConverter()->useOpaquePointers(), + index); } }; @@ -1170,8 +1177,8 @@ class AccessorSubscriptPattern .getTargetMode()); const auto gepPtrTy = LLVM::LLVMPointerType::get(ptrTy.getElementType(), addressSpace); - const auto ptr = GetMemberPattern::loadValue(builder, loc, - gepPtrTy, acc); + const auto ptr = GetMemberPattern::loadValue( + builder, loc, gepPtrTy, acc, getTypeConverter()->useOpaquePointers()); const Value gep = builder.create(loc, gepPtrTy, ptr, index, /*inbounds*/ true); return ptrTy == gepPtrTy @@ -1204,10 +1211,12 @@ class AccessorSubscriptIDIndexPattern // size_t Res{0}; const auto resTy = getTypeConverter()->getIndexType(); Value res = builder.create(loc, 0, resTy); + bool useOpaquePointers = getTypeConverter()->useOpaquePointers(); for (unsigned i = 0, dim = accTy.getDimension(); i < dim; ++i) { // Res = Res * Mem[I] + Id[I] - const auto memI = getMemRange(builder, loc, resTy, acc, i); - const auto idI = getID(builder, loc, resTy, id, i); + const auto memI = + getMemRange(builder, loc, resTy, acc, useOpaquePointers, i); + const auto idI = getID(builder, loc, resTy, id, useOpaquePointers, i); res = builder.create( loc, builder.create(loc, res, memI), idI); } @@ -1371,7 +1380,8 @@ class RangeSizePattern : public GetRangeSizePattern, Value getRange(OpBuilder &builder, Location loc, Type ty, Value thisArg, int32_t index) const final { - return loadValue(builder, loc, ty, thisArg, index); + return loadValue(builder, loc, ty, thisArg, + getTypeConverter()->useOpaquePointers(), index); } }; @@ -1436,16 +1446,17 @@ class NDRangeGetGroupRangePattern LLVM::LLVMPointerType::get(getTypeConverter()->convertType(rangeTy)), rewriter.create(loc, 1, indexTy), /*alignment*/ 0); + bool useOpaquePointers = getTypeConverter()->useOpaquePointers(); for (int32_t i = 0, dim = rangeTy.getDimension(); i < dim; ++i) { const auto lhs = GetMemberPattern::loadValue( - rewriter, loc, indexTy, nd, i); + rewriter, loc, indexTy, nd, useOpaquePointers, i); const auto rhs = GetMemberPattern::loadValue( - rewriter, loc, indexTy, nd, i); + rewriter, loc, indexTy, nd, useOpaquePointers, i); const Value val = rewriter.create(loc, lhs, rhs); const auto ptr = GetMemberPattern::getRef( - rewriter, loc, indexTy, alloca, std::nullopt, i); + rewriter, loc, indexTy, alloca, std::nullopt, useOpaquePointers, i); rewriter.create(loc, val, ptr); } rewriter.replaceOpWithNewOp(op, alloca); @@ -1545,7 +1556,8 @@ class ItemGetLinearIDPattern Value getRange(OpBuilder &builder, Location loc, Type ty, Value thisArg, int32_t index) const final { return GetMemberPattern::loadValue( - builder, loc, ty, thisArg, index); + builder, loc, ty, thisArg, getTypeConverter()->useOpaquePointers(), + index); } public: @@ -1564,8 +1576,9 @@ class ItemNoOffsetGetLinearIDPattern : public ItemGetLinearIDPattern { Value getID(OpBuilder &builder, Location loc, Type ty, Value thisArg, int32_t index) const final { - return GetMemberPattern::loadValue(builder, loc, ty, - thisArg, index); + return GetMemberPattern::loadValue( + builder, loc, ty, thisArg, getTypeConverter()->useOpaquePointers(), + index); } }; @@ -1576,10 +1589,11 @@ class ItemOffsetGetLinearIDPattern protected: Value getID(OpBuilder &builder, Location loc, Type ty, Value thisArg, int32_t index) const final { + bool useOpaquePointers = getTypeConverter()->useOpaquePointers(); const auto id = GetMemberPattern::loadValue( - builder, loc, ty, thisArg, index); + builder, loc, ty, thisArg, useOpaquePointers, index); const auto offset = GetMemberPattern::loadValue( - builder, loc, ty, thisArg, index); + builder, loc, ty, thisArg, useOpaquePointers, index); return builder.create(loc, id, offset); } @@ -1636,13 +1650,16 @@ class NDItemGetGlobalLinearIDPattern int32_t index) const final { return GetMemberPattern::loadValue(builder, loc, ty, thisArg, + getTypeConverter() + ->useOpaquePointers(), index); } Value getID(OpBuilder &builder, Location loc, Type ty, Value thisArg, int32_t index) const final { return GetMemberPattern::loadValue( - builder, loc, ty, thisArg, index); + builder, loc, ty, thisArg, getTypeConverter()->useOpaquePointers(), + index); } public: @@ -1693,13 +1710,16 @@ class NDItemGetLocalLinearIDPattern int32_t index) const final { return GetMemberPattern::loadValue(builder, loc, ty, thisArg, + getTypeConverter() + ->useOpaquePointers(), index); } Value getID(OpBuilder &builder, Location loc, Type ty, Value thisArg, int32_t index) const final { return GetMemberPattern::loadValue( - builder, loc, ty, thisArg, index); + builder, loc, ty, thisArg, getTypeConverter()->useOpaquePointers(), + index); } public: @@ -1825,24 +1845,25 @@ class NDItemGetNDRange const auto rangeTy = cast(ndrTy).getBody()[0]; const auto idTy = cast(ndrTy).getBody()[2]; + bool useOpaque = getTypeConverter()->useOpaquePointers(); rewriter.create( loc, GetMemberPattern::loadValue( - rewriter, loc, rangeTy, ndItem), - GetMemberPattern::getRef(rewriter, loc, rangeTy, - alloca, std::nullopt)); + rewriter, loc, rangeTy, ndItem, useOpaque), + GetMemberPattern::getRef( + rewriter, loc, rangeTy, alloca, std::nullopt, useOpaque)); rewriter.create( loc, GetMemberPattern::loadValue( - rewriter, loc, rangeTy, ndItem), - GetMemberPattern::getRef(rewriter, loc, rangeTy, - alloca, std::nullopt)); + rewriter, loc, rangeTy, ndItem, useOpaque), + GetMemberPattern::getRef( + rewriter, loc, rangeTy, alloca, std::nullopt, useOpaque)); rewriter.create( loc, GetMemberPattern::loadValue( - rewriter, loc, idTy, ndItem), + rewriter, loc, idTy, ndItem, useOpaque), GetMemberPattern::getRef(rewriter, loc, idTy, alloca, - std::nullopt)); + std::nullopt, useOpaque)); rewriter.replaceOpWithNewOp(op, alloca); return success(); } @@ -1986,14 +2007,16 @@ class GroupGetGroupLinearIDPattern protected: Value getID(OpBuilder &builder, Location loc, Type ty, Value thisArg, int32_t index) const final { - return GetMemberPattern::loadValue(builder, loc, ty, - thisArg, index); + return GetMemberPattern::loadValue( + builder, loc, ty, thisArg, getTypeConverter()->useOpaquePointers(), + index); } Value getRange(OpBuilder &builder, Location loc, Type ty, Value thisArg, int32_t index) const final { return GetMemberPattern::loadValue( - builder, loc, ty, thisArg, index); + builder, loc, ty, thisArg, getTypeConverter()->useOpaquePointers(), + index); } public: @@ -2019,7 +2042,8 @@ class GroupGetLocalLinearIDPattern Value getRange(OpBuilder &builder, Location loc, Type ty, Value thisArg, int32_t offset) const final { return GetMemberPattern::loadValue( - builder, loc, ty, thisArg, offset); + builder, loc, ty, thisArg, getTypeConverter()->useOpaquePointers(), + offset); } public: @@ -2043,7 +2067,8 @@ class GroupGetGroupLinearRangePattern Value getRange(OpBuilder &builder, Location loc, Type ty, Value thisArg, int32_t index) const final { return GetMemberPattern::loadValue( - builder, loc, ty, thisArg, index); + builder, loc, ty, thisArg, getTypeConverter()->useOpaquePointers(), + index); } }; @@ -2064,7 +2089,8 @@ class GroupGetLocalLinearRangePattern Value getRange(OpBuilder &builder, Location loc, Type ty, Value thisArg, int32_t index) const final { return GetMemberPattern::loadValue( - builder, loc, ty, thisArg, index); + builder, loc, ty, thisArg, getTypeConverter()->useOpaquePointers(), + index); } }; From 8d1baa93569ca850160c03e5bcd390e4dd6aadc4 Mon Sep 17 00:00:00 2001 From: Lukas Sommer Date: Thu, 30 Mar 2023 10:01:37 +0100 Subject: [PATCH 02/11] WIP: Opaque pointer compatible conversion Signed-off-by: Lukas Sommer --- .../Conversion/SYCLToLLVM/DialectBuilder.h | 3 +- .../Conversion/SYCLToLLVM/DialectBuilder.cpp | 4 +- .../lib/Conversion/SYCLToLLVM/SYCLToLLVM.cpp | 118 +++++++++++++----- 3 files changed, 92 insertions(+), 33 deletions(-) diff --git a/mlir-sycl/include/mlir/Conversion/SYCLToLLVM/DialectBuilder.h b/mlir-sycl/include/mlir/Conversion/SYCLToLLVM/DialectBuilder.h index 0a90750aab91e..12c1c01d52493 100644 --- a/mlir-sycl/include/mlir/Conversion/SYCLToLLVM/DialectBuilder.h +++ b/mlir-sycl/include/mlir/Conversion/SYCLToLLVM/DialectBuilder.h @@ -72,7 +72,8 @@ class LLVMBuilder : public DialectBuilder { public: LLVMBuilder(OpBuilder &b, Location loc) : DialectBuilder(b, loc) {} - LLVM::AllocaOp genAlloca(Type type, Value size, int64_t align) const; + LLVM::AllocaOp genAlloca(Type type, Type elemType, Value size, + int64_t align) const; LLVM::BitcastOp genBitcast(Type type, Value val) const; LLVM::ExtractValueOp genExtractValue(Type type, Value container, ArrayRef pos) const; diff --git a/mlir-sycl/lib/Conversion/SYCLToLLVM/DialectBuilder.cpp b/mlir-sycl/lib/Conversion/SYCLToLLVM/DialectBuilder.cpp index cbb53a7bf7538..46272a2f3b8c1 100644 --- a/mlir-sycl/lib/Conversion/SYCLToLLVM/DialectBuilder.cpp +++ b/mlir-sycl/lib/Conversion/SYCLToLLVM/DialectBuilder.cpp @@ -103,9 +103,9 @@ func::CallOp FuncBuilder::genCall(StringRef funcName, TypeRange resTypes, // LLVMBuilder //===----------------------------------------------------------------------===// -LLVM::AllocaOp LLVMBuilder::genAlloca(Type type, Value size, +LLVM::AllocaOp LLVMBuilder::genAlloca(Type type, Type elemType, Value size, int64_t align) const { - return create(type, size, align); + return create(type, elemType, size, align); } LLVM::BitcastOp LLVMBuilder::genBitcast(Type type, Value val) const { diff --git a/mlir-sycl/lib/Conversion/SYCLToLLVM/SYCLToLLVM.cpp b/mlir-sycl/lib/Conversion/SYCLToLLVM/SYCLToLLVM.cpp index 5f9ab64b33119..7bcb5b5fa1f33 100644 --- a/mlir-sycl/lib/Conversion/SYCLToLLVM/SYCLToLLVM.cpp +++ b/mlir-sycl/lib/Conversion/SYCLToLLVM/SYCLToLLVM.cpp @@ -272,14 +272,26 @@ class GetMemberPatternBase { const auto addressSpace = targetAddressSpace.value_or(origAddressSpace); if (origAddressSpace != addressSpace) { - ptr = builder.create( - loc, - LLVM::LLVMPointerType::get( - cast(ptr.getType()).getElementType(), - addressSpace), - ptr); + if (useOpaquePtr) { + ptr = builder.create( + loc, LLVM::LLVMPointerType::get(ty.getContext(), addressSpace), + ptr); + } else { + ptr = builder.create( + loc, + LLVM::LLVMPointerType::get( + cast(ptr.getType()).getElementType(), + addressSpace), + ptr); + } } + if (useOpaquePtr) { + const auto ptrTy = + LLVM::LLVMPointerType::get(ty.getContext(), addressSpace); + return builder.create(loc, ptrTy, ty, ptr, indices, + /*inbounds*/ true); + } const auto ptrTy = LLVM::LLVMPointerType::get(ty, addressSpace); return builder.create(loc, ptrTy, ptr, indices, /*inbounds*/ true); @@ -297,6 +309,10 @@ class GetMemberPatternBase { bool useOpaquePtr, Args &&...args) const { const auto gep = getRef(builder, loc, ty, ptr, std::nullopt, useOpaquePtr, std::forward(args)...); + + if (useOpaquePtr) + return builder.create(loc, ty, gep); + return builder.create(loc, gep); } @@ -1099,13 +1115,20 @@ class AccessorGetPointerPattern rewriter, loc, cast(op.getAcc().getType().getElementType()), opAdaptor)); + bool useOpaquePointers = getTypeConverter()->useOpaquePointers(); const auto ptrTy = cast( getTypeConverter()->convertType(op.getType())); Value ptr = GetMemberPattern::loadValue( - rewriter, loc, ptrTy, opAdaptor.getAcc(), - getTypeConverter()->useOpaquePointers()); - rewriter.replaceOpWithNewOp(op, ptrTy, ptr, index, - /*inbounds*/ true); + rewriter, loc, ptrTy, opAdaptor.getAcc(), useOpaquePointers); + if (useOpaquePointers) { + auto elemType = + getTypeConverter()->convertType(op.getType().getElementType()); + rewriter.replaceOpWithNewOp(op, ptrTy, elemType, ptr, index, + /*inbounds*/ true); + } else { + rewriter.replaceOpWithNewOp(op, ptrTy, ptr, index, + /*inbounds*/ true); + } return success(); } }; @@ -1172,13 +1195,24 @@ class AccessorSubscriptPattern Value getRef(OpBuilder &builder, Location loc, SYCLAccessorSubscriptOp orig, LLVM::LLVMPointerType ptrTy, Value acc, Value index) const { - const auto addressSpace = targetToAddressSpace( - cast(orig.getAcc().getType().getElementType()) - .getTargetMode()); + bool useOpaquePointers = getTypeConverter()->useOpaquePointers(); + auto accTy = cast(orig.getAcc().getType().getElementType()); + const auto addressSpace = targetToAddressSpace(accTy.getTargetMode()); + if (useOpaquePointers) { + const auto gepPtrTy = + LLVM::LLVMPointerType::get(ptrTy.getContext(), addressSpace); + const auto ptr = GetMemberPattern::loadValue( + builder, loc, gepPtrTy, acc, useOpaquePointers); + const Value gep = builder.create( + loc, gepPtrTy, accTy.getType(), ptr, index, /*inbounds*/ true); + return (ptrTy.getAddressSpace() == addressSpace) + ? gep + : builder.create(loc, ptrTy, gep); + } const auto gepPtrTy = LLVM::LLVMPointerType::get(ptrTy.getElementType(), addressSpace); const auto ptr = GetMemberPattern::loadValue( - builder, loc, gepPtrTy, acc, getTypeConverter()->useOpaquePointers()); + builder, loc, gepPtrTy, acc, useOpaquePointers); const Value gep = builder.create(loc, gepPtrTy, ptr, index, /*inbounds*/ true); return ptrTy == gepPtrTy @@ -1306,9 +1340,17 @@ class SubscriptScalarOffsetND : public AccessorSubscriptPattern { loc, subscript, zero, ArrayRef{0, 0, 0, i}); } // Insert original accessor - rewriter.replaceOpWithNewOp( - op, subscript, rewriter.create(loc, opAdaptor.getAcc()), - 1); + if (getTypeConverter()->useOpaquePointers()) { + auto accTy = getTypeConverter()->convertType( + op.getAcc().getType().getElementType()); + rewriter.replaceOpWithNewOp( + op, subscript, + rewriter.create(loc, accTy, opAdaptor.getAcc()), 1); + } else { + rewriter.replaceOpWithNewOp( + op, subscript, rewriter.create(loc, opAdaptor.getAcc()), + 1); + } } }; @@ -1440,13 +1482,16 @@ class NDRangeGetGroupRangePattern const auto loc = op.getLoc(); const auto nd = opAdaptor.getND(); const auto rangeTy = op.getType(); + const auto convRangeTy = getTypeConverter()->convertType(rangeTy); const auto indexTy = getTypeConverter()->getIndexType(); + bool useOpaquePointers = getTypeConverter()->useOpaquePointers(); + const auto allocaTy = (useOpaquePointers) + ? LLVM::LLVMPointerType::get(rangeTy.getContext()) + : LLVM::LLVMPointerType::get(convRangeTy); Value alloca = rewriter.create( - loc, - LLVM::LLVMPointerType::get(getTypeConverter()->convertType(rangeTy)), + loc, allocaTy, convRangeTy, rewriter.create(loc, 1, indexTy), /*alignment*/ 0); - bool useOpaquePointers = getTypeConverter()->useOpaquePointers(); for (int32_t i = 0, dim = rangeTy.getDimension(); i < dim; ++i) { const auto lhs = GetMemberPattern::loadValue( @@ -1459,6 +1504,10 @@ class NDRangeGetGroupRangePattern rewriter, loc, indexTy, alloca, std::nullopt, useOpaquePointers, i); rewriter.create(loc, val, ptr); } + if (useOpaquePointers) { + rewriter.replaceOpWithNewOp(op, convRangeTy, alloca); + return success(); + } rewriter.replaceOpWithNewOp(op, alloca); return success(); } @@ -1838,32 +1887,39 @@ class NDItemGetNDRange const auto ndItem = opAdaptor.getNDItem(); const auto ndrTy = getTypeConverter()->convertType(op.getType()); + bool useOpaquePointers = getTypeConverter()->useOpaquePointers(); + const auto allocaTy = (useOpaquePointers) + ? LLVM::LLVMPointerType::get(ndrTy.getContext()) + : LLVM::LLVMPointerType::get(ndrTy); const Value alloca = rewriter.create( - loc, LLVM::LLVMPointerType::get(ndrTy), ndrTy, + loc, allocaTy, ndrTy, rewriter.create(loc, 1, 32)); const auto rangeTy = cast(ndrTy).getBody()[0]; const auto idTy = cast(ndrTy).getBody()[2]; - bool useOpaque = getTypeConverter()->useOpaquePointers(); rewriter.create( loc, GetMemberPattern::loadValue( - rewriter, loc, rangeTy, ndItem, useOpaque), + rewriter, loc, rangeTy, ndItem, useOpaquePointers), GetMemberPattern::getRef( - rewriter, loc, rangeTy, alloca, std::nullopt, useOpaque)); + rewriter, loc, rangeTy, alloca, std::nullopt, useOpaquePointers)); rewriter.create( loc, GetMemberPattern::loadValue( - rewriter, loc, rangeTy, ndItem, useOpaque), + rewriter, loc, rangeTy, ndItem, useOpaquePointers), GetMemberPattern::getRef( - rewriter, loc, rangeTy, alloca, std::nullopt, useOpaque)); + rewriter, loc, rangeTy, alloca, std::nullopt, useOpaquePointers)); rewriter.create( loc, GetMemberPattern::loadValue( - rewriter, loc, idTy, ndItem, useOpaque), - GetMemberPattern::getRef(rewriter, loc, idTy, alloca, - std::nullopt, useOpaque)); + rewriter, loc, idTy, ndItem, useOpaquePointers), + GetMemberPattern::getRef( + rewriter, loc, idTy, alloca, std::nullopt, useOpaquePointers)); + if (useOpaquePointers) { + rewriter.replaceOpWithNewOp(op, ndrTy, alloca); + return success(); + } rewriter.replaceOpWithNewOp(op, alloca); return success(); } @@ -2237,6 +2293,7 @@ void ConvertSYCLToLLVMPass::runOnOperation() { LowerToLLVMOptions options(&context); options.useBarePtrCallConv = true; + options.useOpaquePointers = true; if (indexBitwidth != kDeriveIndexBitwidthFromDataLayout) options.overrideIndexBitwidth(indexBitwidth); LLVMTypeConverter converter(&context, options); @@ -2248,7 +2305,8 @@ void ConvertSYCLToLLVMPass::runOnOperation() { populateReturnOpTypeConversionPattern(patterns, converter); populateCallOpTypeConversionPattern(patterns, converter); populateAnyFunctionOpInterfaceTypeConversionPattern(patterns, converter); - polygeist::populateBareMemRefToLLVMConversionPatterns(converter, patterns); + polygeist::populateBareMemRefToLLVMConversionPatterns( + converter, patterns, /*useOpaquePointers*/ true); populateSYCLToSPIRVConversionPatterns(converter, patterns); populateSYCLToLLVMConversionPatterns(converter, patterns); From 03a3919b03d01bc5f2855f966e147ae7a835baf4 Mon Sep 17 00:00:00 2001 From: Lukas Sommer Date: Thu, 30 Mar 2023 12:57:16 +0100 Subject: [PATCH 03/11] Add pass option for opaque pointer use Signed-off-by: Lukas Sommer --- mlir-sycl/include/mlir/Conversion/SYCLPasses.td | 7 +++++-- mlir-sycl/lib/Conversion/SYCLToLLVM/SYCLToLLVM.cpp | 4 ++-- 2 files changed, 7 insertions(+), 4 deletions(-) diff --git a/mlir-sycl/include/mlir/Conversion/SYCLPasses.td b/mlir-sycl/include/mlir/Conversion/SYCLPasses.td index f4b9f27a84c95..a7507a176880f 100644 --- a/mlir-sycl/include/mlir/Conversion/SYCLPasses.td +++ b/mlir-sycl/include/mlir/Conversion/SYCLPasses.td @@ -30,8 +30,11 @@ def ConvertSYCLToLLVM : Pass<"convert-sycl-to-llvm", "ModuleOp"> { ]; let options = [ Option<"indexBitwidth", "index-bitwidth", "unsigned", - /*default=kDeriveIndexBitwidthFromDataLayout*/"0", - "Bitwidth of the index type, 0 to use size of machine word"> + /*default=kDeriveIndexBitwidthFromDataLayout*/"0", + "Bitwidth of the index type, 0 to use size of machine word">, + Option<"useOpaquePointers", "use-opaque-pointers", "bool", + /*default=*/"false", "Generate LLVM IR using opaque pointers " + "instead of typed pointers">, ]; } diff --git a/mlir-sycl/lib/Conversion/SYCLToLLVM/SYCLToLLVM.cpp b/mlir-sycl/lib/Conversion/SYCLToLLVM/SYCLToLLVM.cpp index 7bcb5b5fa1f33..09a0a26e042f6 100644 --- a/mlir-sycl/lib/Conversion/SYCLToLLVM/SYCLToLLVM.cpp +++ b/mlir-sycl/lib/Conversion/SYCLToLLVM/SYCLToLLVM.cpp @@ -2293,7 +2293,7 @@ void ConvertSYCLToLLVMPass::runOnOperation() { LowerToLLVMOptions options(&context); options.useBarePtrCallConv = true; - options.useOpaquePointers = true; + options.useOpaquePointers = useOpaquePointers; if (indexBitwidth != kDeriveIndexBitwidthFromDataLayout) options.overrideIndexBitwidth(indexBitwidth); LLVMTypeConverter converter(&context, options); @@ -2306,7 +2306,7 @@ void ConvertSYCLToLLVMPass::runOnOperation() { populateCallOpTypeConversionPattern(patterns, converter); populateAnyFunctionOpInterfaceTypeConversionPattern(patterns, converter); polygeist::populateBareMemRefToLLVMConversionPatterns( - converter, patterns, /*useOpaquePointers*/ true); + converter, patterns, useOpaquePointers); populateSYCLToSPIRVConversionPatterns(converter, patterns); populateSYCLToLLVMConversionPatterns(converter, patterns); From 2c3204fcfd77cf66f0ce018b3a855925a4b0f9d3 Mon Sep 17 00:00:00 2001 From: Lukas Sommer Date: Thu, 30 Mar 2023 13:10:50 +0100 Subject: [PATCH 04/11] Update tests for opaque pointers Signed-off-by: Lukas Sommer --- ...l-addrspacecast-to-llvm-typed-pointer.mlir | 23 + .../sycl-addrspacecast-to-llvm.mlir | 14 +- .../sycl-call-to-llvm-typed-pointer.mlir | 38 ++ .../SYCLToLLVM/sycl-call-to-llvm.mlir | 6 +- .../sycl-grid-ops-to-llvm-typed-pointer.mlir | 458 ++++++++++++++++++ .../SYCLToLLVM/sycl-grid-ops-to-llvm.mlir | 240 ++++----- 6 files changed, 649 insertions(+), 130 deletions(-) create mode 100644 mlir-sycl/test/Conversion/SYCLToLLVM/sycl-addrspacecast-to-llvm-typed-pointer.mlir create mode 100644 mlir-sycl/test/Conversion/SYCLToLLVM/sycl-call-to-llvm-typed-pointer.mlir create mode 100644 mlir-sycl/test/Conversion/SYCLToLLVM/sycl-grid-ops-to-llvm-typed-pointer.mlir diff --git a/mlir-sycl/test/Conversion/SYCLToLLVM/sycl-addrspacecast-to-llvm-typed-pointer.mlir b/mlir-sycl/test/Conversion/SYCLToLLVM/sycl-addrspacecast-to-llvm-typed-pointer.mlir new file mode 100644 index 0000000000000..f3cbce5f6b6ca --- /dev/null +++ b/mlir-sycl/test/Conversion/SYCLToLLVM/sycl-addrspacecast-to-llvm-typed-pointer.mlir @@ -0,0 +1,23 @@ +// RUN: sycl-mlir-opt -split-input-file -convert-sycl-to-llvm='use-opaque-pointers=0' -verify-diagnostics %s | FileCheck %s + +// CHECK-LABEL: llvm.func @PtrCastToGeneric(%arg0: !llvm.ptr) -> !llvm.ptr { +// CHECK-NEXT: %0 = llvm.addrspacecast %arg0 : !llvm.ptr to !llvm.ptr +// CHECK-NEXT: llvm.return %0 : !llvm.ptr +// CHECK-NEXT: } + +func.func @PtrCastToGeneric(%arg0: memref) -> memref { + %0 = sycl.addrspacecast %arg0 : memref to memref + return %0 : memref +} + +// ----- + +// CHECK-LABEL: llvm.func @GenericCastToPtr(%arg0: !llvm.ptr) -> !llvm.ptr { +// CHECK-NEXT: %0 = llvm.addrspacecast %arg0 : !llvm.ptr to !llvm.ptr +// CHECK-NEXT: llvm.return %0 : !llvm.ptr +// CHECK-NEXT: } + +func.func @GenericCastToPtr(%arg0: memref) -> memref { + %0 = sycl.addrspacecast %arg0 : memref to memref + return %0 : memref +} diff --git a/mlir-sycl/test/Conversion/SYCLToLLVM/sycl-addrspacecast-to-llvm.mlir b/mlir-sycl/test/Conversion/SYCLToLLVM/sycl-addrspacecast-to-llvm.mlir index 03372b55f131e..10b5c5694fd46 100644 --- a/mlir-sycl/test/Conversion/SYCLToLLVM/sycl-addrspacecast-to-llvm.mlir +++ b/mlir-sycl/test/Conversion/SYCLToLLVM/sycl-addrspacecast-to-llvm.mlir @@ -1,8 +1,8 @@ -// RUN: sycl-mlir-opt -split-input-file -convert-sycl-to-llvm -verify-diagnostics %s | FileCheck %s +// RUN: sycl-mlir-opt -split-input-file -convert-sycl-to-llvm='use-opaque-pointers=1' -verify-diagnostics %s | FileCheck %s -// CHECK-LABEL: llvm.func @PtrCastToGeneric(%arg0: !llvm.ptr) -> !llvm.ptr { -// CHECK-NEXT: %0 = llvm.addrspacecast %arg0 : !llvm.ptr to !llvm.ptr -// CHECK-NEXT: llvm.return %0 : !llvm.ptr +// CHECK-LABEL: llvm.func @PtrCastToGeneric(%arg0: !llvm.ptr) -> !llvm.ptr<4> { +// CHECK-NEXT: %0 = llvm.addrspacecast %arg0 : !llvm.ptr to !llvm.ptr<4> +// CHECK-NEXT: llvm.return %0 : !llvm.ptr<4> // CHECK-NEXT: } func.func @PtrCastToGeneric(%arg0: memref) -> memref { @@ -12,9 +12,9 @@ func.func @PtrCastToGeneric(%arg0: memref) -> memref { // ----- -// CHECK-LABEL: llvm.func @GenericCastToPtr(%arg0: !llvm.ptr) -> !llvm.ptr { -// CHECK-NEXT: %0 = llvm.addrspacecast %arg0 : !llvm.ptr to !llvm.ptr -// CHECK-NEXT: llvm.return %0 : !llvm.ptr +// CHECK-LABEL: llvm.func @GenericCastToPtr(%arg0: !llvm.ptr<4>) -> !llvm.ptr { +// CHECK-NEXT: %0 = llvm.addrspacecast %arg0 : !llvm.ptr<4> to !llvm.ptr +// CHECK-NEXT: llvm.return %0 : !llvm.ptr // CHECK-NEXT: } func.func @GenericCastToPtr(%arg0: memref) -> memref { diff --git a/mlir-sycl/test/Conversion/SYCLToLLVM/sycl-call-to-llvm-typed-pointer.mlir b/mlir-sycl/test/Conversion/SYCLToLLVM/sycl-call-to-llvm-typed-pointer.mlir new file mode 100644 index 0000000000000..68e2883df6543 --- /dev/null +++ b/mlir-sycl/test/Conversion/SYCLToLLVM/sycl-call-to-llvm-typed-pointer.mlir @@ -0,0 +1,38 @@ +// RUN: sycl-mlir-opt -split-input-file -convert-sycl-to-llvm='use-opaque-pointers=0' -verify-diagnostics %s | FileCheck %s + +//===-------------------------------------------------------------------------------------------------===// +// sycl.call with non void return type +//===-------------------------------------------------------------------------------------------------===// + +// CHECK: llvm.func @foo() -> [[RET_TYPE:i32]] +// CHECK: llvm.func @test() -> [[RET_TYPE]] { +// CHECK-NEXT: %0 = llvm.call @foo() : () -> [[RET_TYPE]] +// CHECK-NEXT: llvm.return %0 : [[RET_TYPE]] + +func.func private @foo() -> (i32) + +func.func @test() -> (i32) { + %0 = sycl.call @foo() {MangledFunctionName = @foo, TypeName = @accessor} : () -> i32 + return %0 : i32 +} + +// ----- + +//===-------------------------------------------------------------------------------------------------===// +// Member functions for sycl::accessor +//===-------------------------------------------------------------------------------------------------===// + +!sycl_id_1_ = !sycl.id<[1], (!sycl.array<[1], (memref<1xi64, 4>)>)> +!sycl_range_1_ = !sycl.range<[1], (!sycl.array<[1], (memref<1xi64, 4>)>)> +!sycl_accessor_1_i32_rw_gb = !sycl.accessor<[1, i32, read_write, global_buffer], (!sycl.accessor_impl_device<[1], (!sycl_id_1_, !sycl_range_1_, !sycl_range_1_)>, !llvm.struct<(ptr)>)> + +// CHECK: llvm.func @_ZN2cl4sycl8accessorIiLi1ELNS0_6access4modeE1026ELNS2_6targetE2014ELNS2_11placeholderE0ENS0_3ext6oneapi22accessor_property_listIJEEEE6__initEPU3AS1iNS0_5rangeILi1EEESE_NS0_2idILi1EEE([[ARG_TYPES:!llvm.ptr, memref, !sycl_range_1_, !sycl_range_1_, !sycl_id_1_) + +func.func @accessorInit1(%arg0: memref, %arg1: memref, %arg2: !sycl_range_1_, %arg3: !sycl_range_1_, %arg4: !sycl_id_1_) { + // CHECK: llvm.call @_ZN2cl4sycl8accessorIiLi1ELNS0_6access4modeE1026ELNS2_6targetE2014ELNS2_11placeholderE0ENS0_3ext6oneapi22accessor_property_listIJEEEE6__initEPU3AS1iNS0_5rangeILi1EEESE_NS0_2idILi1EEE({{.*}}) : ([[ARG_TYPES]]) -> () + sycl.call @__init(%arg0, %arg1, %arg2, %arg3, %arg4) {MangledFunctionName = @_ZN2cl4sycl8accessorIiLi1ELNS0_6access4modeE1026ELNS2_6targetE2014ELNS2_11placeholderE0ENS0_3ext6oneapi22accessor_property_listIJEEEE6__initEPU3AS1iNS0_5rangeILi1EEESE_NS0_2idILi1EEE, TypeName = @accessor} : (memref, memref, !sycl_range_1_, !sycl_range_1_, !sycl_id_1_) -> () + return +} + +// ----- diff --git a/mlir-sycl/test/Conversion/SYCLToLLVM/sycl-call-to-llvm.mlir b/mlir-sycl/test/Conversion/SYCLToLLVM/sycl-call-to-llvm.mlir index f84249679ae81..8a2e635f5d806 100644 --- a/mlir-sycl/test/Conversion/SYCLToLLVM/sycl-call-to-llvm.mlir +++ b/mlir-sycl/test/Conversion/SYCLToLLVM/sycl-call-to-llvm.mlir @@ -1,4 +1,4 @@ -// RUN: sycl-mlir-opt -split-input-file -convert-sycl-to-llvm -verify-diagnostics %s | FileCheck %s +// RUN: sycl-mlir-opt -split-input-file -convert-sycl-to-llvm='use-opaque-pointers=1' -verify-diagnostics %s | FileCheck %s //===-------------------------------------------------------------------------------------------------===// // sycl.call with non void return type @@ -24,9 +24,9 @@ func.func @test() -> (i32) { !sycl_id_1_ = !sycl.id<[1], (!sycl.array<[1], (memref<1xi64, 4>)>)> !sycl_range_1_ = !sycl.range<[1], (!sycl.array<[1], (memref<1xi64, 4>)>)> -!sycl_accessor_1_i32_rw_gb = !sycl.accessor<[1, i32, read_write, global_buffer], (!sycl.accessor_impl_device<[1], (!sycl_id_1_, !sycl_range_1_, !sycl_range_1_)>, !llvm.struct<(ptr)>)> +!sycl_accessor_1_i32_rw_gb = !sycl.accessor<[1, i32, read_write, global_buffer], (!sycl.accessor_impl_device<[1], (!sycl_id_1_, !sycl_range_1_, !sycl_range_1_)>, !llvm.struct<(ptr<1>)>)> -// CHECK: llvm.func @_ZN2cl4sycl8accessorIiLi1ELNS0_6access4modeE1026ELNS2_6targetE2014ELNS2_11placeholderE0ENS0_3ext6oneapi22accessor_property_listIJEEEE6__initEPU3AS1iNS0_5rangeILi1EEESE_NS0_2idILi1EEE([[ARG_TYPES:!llvm.ptr, memref, !sycl_range_1_, !sycl_range_1_, !sycl_id_1_) func.func @accessorInit1(%arg0: memref, %arg1: memref, %arg2: !sycl_range_1_, %arg3: !sycl_range_1_, %arg4: !sycl_id_1_) { diff --git a/mlir-sycl/test/Conversion/SYCLToLLVM/sycl-grid-ops-to-llvm-typed-pointer.mlir b/mlir-sycl/test/Conversion/SYCLToLLVM/sycl-grid-ops-to-llvm-typed-pointer.mlir new file mode 100644 index 0000000000000..3d2bcffabcc3f --- /dev/null +++ b/mlir-sycl/test/Conversion/SYCLToLLVM/sycl-grid-ops-to-llvm-typed-pointer.mlir @@ -0,0 +1,458 @@ +// RUN: sycl-mlir-opt -convert-sycl-to-llvm='use-opaque-pointers=0' %s -o - | FileCheck %s + +!sycl_id_1_ = !sycl.id<[1], (!sycl.array<[1], (memref<1xi64, 4>)>)> +!sycl_id_2_ = !sycl.id<[2], (!sycl.array<[2], (memref<2xi64, 4>)>)> +!sycl_id_3_ = !sycl.id<[3], (!sycl.array<[3], (memref<3xi64, 4>)>)> +!sycl_range_1_ = !sycl.range<[1], (!sycl.array<[1], (memref<1xi64, 4>)>)> +!sycl_range_2_ = !sycl.range<[2], (!sycl.array<[2], (memref<2xi64, 4>)>)> +!sycl_range_3_ = !sycl.range<[3], (!sycl.array<[3], (memref<3xi64, 4>)>)> + +module attributes {gpu.container_module} { + // CHECK: gpu.module @kernels { + //CHECK-DAG: llvm.mlir.global external constant @__spirv_BuiltInSubgroupLocalInvocationId() {addr_space = 0 : i32} : i64 + //CHECK-DAG: llvm.mlir.global external constant @__spirv_BuiltInSubgroupMaxSize() {addr_space = 0 : i32} : i64 + //CHECK-DAG: llvm.mlir.global external constant @__spirv_BuiltInGlobalOffset() {addr_space = 0 : i32} : vector<3xi64> + //CHECK-DAG: llvm.mlir.global external constant @__spirv_BuiltInSubgroupId() {addr_space = 0 : i32} : i64 + //CHECK-DAG: llvm.mlir.global external constant @__spirv_BuiltInSubgroupSize() {addr_space = 0 : i32} : i64 + //CHECK-DAG: llvm.mlir.global external constant @__spirv_BuiltInNumSubgroups() {addr_space = 0 : i32} : i64 + //CHECK-DAG: llvm.mlir.global external constant @__spirv_BuiltInWorkgroupId() {addr_space = 0 : i32} : vector<3xi64> + //CHECK-DAG: llvm.mlir.global external constant @__spirv_BuiltInWorkgroupSize() {addr_space = 0 : i32} : vector<3xi64> + //CHECK-DAG: llvm.mlir.global external constant @__spirv_BuiltInLocalInvocationId() {addr_space = 0 : i32} : vector<3xi64> + //CHECK-DAG: llvm.mlir.global external constant @__spirv_BuiltInGlobalInvocationId() {addr_space = 0 : i32} : vector<3xi64> + //CHECK-DAG: llvm.mlir.global external constant @__spirv_BuiltInNumWorkgroups() {addr_space = 0 : i32} : vector<3xi64> + //CHECK-DAG: llvm.mlir.global external constant @__spirv_BuiltInGlobalSize() {addr_space = 0 : i32} : vector<3xi64> + gpu.module @kernels { + // CHECK-LABEL: llvm.func @test_num_work_items() -> !llvm.struct<"class.sycl::_V1::range.1", (struct<"class.sycl::_V1::detail::array.1", (array<1 x i64>)>)> { + // CHECK-NEXT: %[[VAL_0:.*]] = llvm.mlir.addressof @__spirv_BuiltInGlobalSize : !llvm.ptr> + // CHECK-NEXT: %[[VAL_1:.*]] = llvm.load %[[VAL_0]] : !llvm.ptr> + // CHECK-NEXT: %[[VAL_2:.*]] = llvm.mlir.null : !llvm.ptr)>)>> + // CHECK-NEXT: %[[VAL_3:.*]] = llvm.mlir.constant(1 : index) : i64 + // CHECK-NEXT: %[[VAL_4:.*]] = llvm.getelementptr %[[VAL_2]]{{\[}}%[[VAL_3]]] : (!llvm.ptr)>)>>, i64) -> !llvm.ptr)>)>> + // CHECK-NEXT: %[[VAL_5:.*]] = llvm.ptrtoint %[[VAL_4]] : !llvm.ptr)>)>> to i64 + // CHECK-NEXT: %[[VAL_6:.*]] = llvm.alloca %[[VAL_5]] x !llvm.struct<"class.sycl::_V1::range.1", (struct<"class.sycl::_V1::detail::array.1", (array<1 x i64>)>)> : (i64) -> !llvm.ptr)>)>> + // CHECK-DAG: %[[VAL_7:.*]] = llvm.mlir.constant(0 : index) : i64 + // CHECK-DAG: %[[VAL_8:.*]] = llvm.mlir.constant(0 : i32) : i32 + // CHECK-DAG: %[[VAL_9:.*]] = llvm.mlir.constant(0 : i32) : i32 + // CHECK-NEXT: %[[VAL_10:.*]] = llvm.extractelement %[[VAL_1]]{{\[}}%[[VAL_9]] : i32] : vector<3xi64> + // CHECK-NEXT: %[[VAL_11:.*]] = llvm.getelementptr inbounds %[[VAL_6]][0, 0, 0, %[[VAL_8]]] : (!llvm.ptr)>)>>, i32) -> !llvm.ptr + // CHECK-NEXT: %[[VAL_12:.*]] = llvm.getelementptr %[[VAL_11]]{{\[}}%[[VAL_7]]] : (!llvm.ptr, i64) -> !llvm.ptr + // CHECK-NEXT: llvm.store %[[VAL_10]], %[[VAL_12]] : !llvm.ptr + // CHECK-NEXT: %[[VAL_13:.*]] = llvm.getelementptr %[[VAL_6]]{{\[}}%[[VAL_7]]] : (!llvm.ptr)>)>>, i64) -> !llvm.ptr)>)>> + // CHECK-NEXT: %[[VAL_14:.*]] = llvm.load %[[VAL_13]] : !llvm.ptr)>)>> + // CHECK-NEXT: llvm.return %[[VAL_14]] : !llvm.struct<"class.sycl::_V1::range.1", (struct<"class.sycl::_V1::detail::array.1", (array<1 x i64>)>)> + // CHECK-NEXT: } + func.func @test_num_work_items() -> !sycl_range_1_ { + %0 = sycl.num_work_items : !sycl_range_1_ + return %0 : !sycl_range_1_ + } + + // CHECK-LABEL: llvm.func @test_num_work_items_dim( + // CHECK-SAME: %[[VAL_15:.*]]: i32) -> i64 { + // CHECK-NEXT: %[[VAL_16:.*]] = llvm.mlir.addressof @__spirv_BuiltInGlobalSize : !llvm.ptr> + // CHECK-NEXT: %[[VAL_17:.*]] = llvm.load %[[VAL_16]] : !llvm.ptr> + // CHECK-DAG: %[[VAL_18:.*]] = llvm.mlir.constant(dense<0> : vector<3xindex>) : vector<3xi64> + // CHECK-DAG: %[[VAL_19:.*]] = llvm.mlir.constant(0 : i32) : i32 + // CHECK-NEXT: %[[VAL_20:.*]] = llvm.extractelement %[[VAL_17]]{{\[}}%[[VAL_19]] : i32] : vector<3xi64> + // CHECK-NEXT: %[[VAL_21:.*]] = llvm.mlir.constant(0 : i64) : i64 + // CHECK-NEXT: %[[VAL_22:.*]] = llvm.insertelement %[[VAL_20]], %[[VAL_18]]{{\[}}%[[VAL_21]] : i64] : vector<3xi64> + // CHECK-NEXT: %[[VAL_23:.*]] = llvm.mlir.constant(1 : i32) : i32 + // CHECK-NEXT: %[[VAL_24:.*]] = llvm.extractelement %[[VAL_17]]{{\[}}%[[VAL_23]] : i32] : vector<3xi64> + // CHECK-NEXT: %[[VAL_25:.*]] = llvm.mlir.constant(1 : i64) : i64 + // CHECK-NEXT: %[[VAL_26:.*]] = llvm.insertelement %[[VAL_24]], %[[VAL_22]]{{\[}}%[[VAL_25]] : i64] : vector<3xi64> + // CHECK-NEXT: %[[VAL_27:.*]] = llvm.mlir.constant(2 : i32) : i32 + // CHECK-NEXT: %[[VAL_28:.*]] = llvm.extractelement %[[VAL_17]]{{\[}}%[[VAL_27]] : i32] : vector<3xi64> + // CHECK-NEXT: %[[VAL_29:.*]] = llvm.mlir.constant(2 : i64) : i64 + // CHECK-NEXT: %[[VAL_30:.*]] = llvm.insertelement %[[VAL_28]], %[[VAL_26]]{{\[}}%[[VAL_29]] : i64] : vector<3xi64> + // CHECK-NEXT: %[[VAL_31:.*]] = llvm.extractelement %[[VAL_30]]{{\[}}%[[VAL_15]] : i32] : vector<3xi64> + // CHECK-NEXT: llvm.return %[[VAL_31]] : i64 + // CHECK-NEXT: } + func.func @test_num_work_items_dim(%i: i32) -> index { + %0 = sycl.num_work_items %i : index + return %0 : index + } + + // CHECK-LABEL: llvm.func @test_global_id() -> !llvm.struct<"class.sycl::_V1::id.2", (struct<"class.sycl::_V1::detail::array.2", (array<2 x i64>)>)> { + // CHECK-NEXT: %[[VAL_32:.*]] = llvm.mlir.addressof @__spirv_BuiltInGlobalInvocationId : !llvm.ptr> + // CHECK-NEXT: %[[VAL_33:.*]] = llvm.load %[[VAL_32]] : !llvm.ptr> + // CHECK-NEXT: %[[VAL_34:.*]] = llvm.mlir.null : !llvm.ptr)>)>> + // CHECK-NEXT: %[[VAL_35:.*]] = llvm.mlir.constant(1 : index) : i64 + // CHECK-NEXT: %[[VAL_36:.*]] = llvm.getelementptr %[[VAL_34]]{{\[}}%[[VAL_35]]] : (!llvm.ptr)>)>>, i64) -> !llvm.ptr)>)>> + // CHECK-NEXT: %[[VAL_37:.*]] = llvm.ptrtoint %[[VAL_36]] : !llvm.ptr)>)>> to i64 + // CHECK-NEXT: %[[VAL_38:.*]] = llvm.alloca %[[VAL_37]] x !llvm.struct<"class.sycl::_V1::id.2", (struct<"class.sycl::_V1::detail::array.2", (array<2 x i64>)>)> : (i64) -> !llvm.ptr)>)>> + // CHECK-DAG: %[[VAL_39:.*]] = llvm.mlir.constant(0 : index) : i64 + // CHECK-DAG: %[[VAL_40:.*]] = llvm.mlir.constant(0 : i32) : i32 + // CHECK-DAG: %[[VAL_41:.*]] = llvm.mlir.constant(0 : i32) : i32 + // CHECK-NEXT: %[[VAL_42:.*]] = llvm.extractelement %[[VAL_33]]{{\[}}%[[VAL_41]] : i32] : vector<3xi64> + // CHECK-NEXT: %[[VAL_43:.*]] = llvm.getelementptr inbounds %[[VAL_38]][0, 0, 0, %[[VAL_40]]] : (!llvm.ptr)>)>>, i32) -> !llvm.ptr + // CHECK-NEXT: %[[VAL_44:.*]] = llvm.getelementptr %[[VAL_43]]{{\[}}%[[VAL_39]]] : (!llvm.ptr, i64) -> !llvm.ptr + // CHECK-NEXT: llvm.store %[[VAL_42]], %[[VAL_44]] : !llvm.ptr + // CHECK-DAG: %[[VAL_45:.*]] = llvm.mlir.constant(1 : i32) : i32 + // CHECK-DAG: %[[VAL_46:.*]] = llvm.mlir.constant(1 : i32) : i32 + // CHECK-NEXT: %[[VAL_47:.*]] = llvm.extractelement %[[VAL_33]]{{\[}}%[[VAL_46]] : i32] : vector<3xi64> + // CHECK-NEXT: %[[VAL_48:.*]] = llvm.getelementptr inbounds %[[VAL_38]][0, 0, 0, %[[VAL_45]]] : (!llvm.ptr)>)>>, i32) -> !llvm.ptr + // CHECK-NEXT: %[[VAL_49:.*]] = llvm.getelementptr %[[VAL_48]]{{\[}}%[[VAL_39]]] : (!llvm.ptr, i64) -> !llvm.ptr + // CHECK-NEXT: llvm.store %[[VAL_47]], %[[VAL_49]] : !llvm.ptr + // CHECK-NEXT: %[[VAL_50:.*]] = llvm.getelementptr %[[VAL_38]]{{\[}}%[[VAL_39]]] : (!llvm.ptr)>)>>, i64) -> !llvm.ptr)>)>> + // CHECK-NEXT: %[[VAL_51:.*]] = llvm.load %[[VAL_50]] : !llvm.ptr)>)>> + // CHECK-NEXT: llvm.return %[[VAL_51]] : !llvm.struct<"class.sycl::_V1::id.2", (struct<"class.sycl::_V1::detail::array.2", (array<2 x i64>)>)> + // CHECK-NEXT: } + func.func @test_global_id() -> !sycl_id_2_ { + %0 = sycl.global_id : !sycl_id_2_ + return %0 : !sycl_id_2_ + } + + // CHECK-LABEL: llvm.func @test_global_id_dim( + // CHECK-SAME: %[[VAL_52:.*]]: i32) -> i64 { + // CHECK-NEXT: %[[VAL_53:.*]] = llvm.mlir.addressof @__spirv_BuiltInGlobalInvocationId : !llvm.ptr> + // CHECK-NEXT: %[[VAL_54:.*]] = llvm.load %[[VAL_53]] : !llvm.ptr> + // CHECK-DAG: %[[VAL_55:.*]] = llvm.mlir.constant(dense<0> : vector<3xindex>) : vector<3xi64> + // CHECK-DAG: %[[VAL_56:.*]] = llvm.mlir.constant(0 : i32) : i32 + // CHECK-NEXT: %[[VAL_57:.*]] = llvm.extractelement %[[VAL_54]]{{\[}}%[[VAL_56]] : i32] : vector<3xi64> + // CHECK-NEXT: %[[VAL_58:.*]] = llvm.mlir.constant(0 : i64) : i64 + // CHECK-NEXT: %[[VAL_59:.*]] = llvm.insertelement %[[VAL_57]], %[[VAL_55]]{{\[}}%[[VAL_58]] : i64] : vector<3xi64> + // CHECK-NEXT: %[[VAL_60:.*]] = llvm.mlir.constant(1 : i32) : i32 + // CHECK-NEXT: %[[VAL_61:.*]] = llvm.extractelement %[[VAL_54]]{{\[}}%[[VAL_60]] : i32] : vector<3xi64> + // CHECK-NEXT: %[[VAL_62:.*]] = llvm.mlir.constant(1 : i64) : i64 + // CHECK-NEXT: %[[VAL_63:.*]] = llvm.insertelement %[[VAL_61]], %[[VAL_59]]{{\[}}%[[VAL_62]] : i64] : vector<3xi64> + // CHECK-NEXT: %[[VAL_64:.*]] = llvm.mlir.constant(2 : i32) : i32 + // CHECK-NEXT: %[[VAL_65:.*]] = llvm.extractelement %[[VAL_54]]{{\[}}%[[VAL_64]] : i32] : vector<3xi64> + // CHECK-NEXT: %[[VAL_66:.*]] = llvm.mlir.constant(2 : i64) : i64 + // CHECK-NEXT: %[[VAL_67:.*]] = llvm.insertelement %[[VAL_65]], %[[VAL_63]]{{\[}}%[[VAL_66]] : i64] : vector<3xi64> + // CHECK-NEXT: %[[VAL_68:.*]] = llvm.extractelement %[[VAL_67]]{{\[}}%[[VAL_52]] : i32] : vector<3xi64> + // CHECK-NEXT: llvm.return %[[VAL_68]] : i64 + // CHECK-NEXT: } + func.func @test_global_id_dim(%i: i32) -> index { + %0 = sycl.global_id %i : index + return %0 : index + } + + // CHECK-LABEL: llvm.func @test_local_id() -> !llvm.struct<"class.sycl::_V1::id.3", (struct<"class.sycl::_V1::detail::array.3", (array<3 x i64>)>)> { + // CHECK-NEXT: %[[VAL_69:.*]] = llvm.mlir.addressof @__spirv_BuiltInLocalInvocationId : !llvm.ptr> + // CHECK-NEXT: %[[VAL_70:.*]] = llvm.load %[[VAL_69]] : !llvm.ptr> + // CHECK-NEXT: %[[VAL_71:.*]] = llvm.mlir.null : !llvm.ptr)>)>> + // CHECK-NEXT: %[[VAL_72:.*]] = llvm.mlir.constant(1 : index) : i64 + // CHECK-NEXT: %[[VAL_73:.*]] = llvm.getelementptr %[[VAL_71]]{{\[}}%[[VAL_72]]] : (!llvm.ptr)>)>>, i64) -> !llvm.ptr)>)>> + // CHECK-NEXT: %[[VAL_74:.*]] = llvm.ptrtoint %[[VAL_73]] : !llvm.ptr)>)>> to i64 + // CHECK-NEXT: %[[VAL_75:.*]] = llvm.alloca %[[VAL_74]] x !llvm.struct<"class.sycl::_V1::id.3", (struct<"class.sycl::_V1::detail::array.3", (array<3 x i64>)>)> : (i64) -> !llvm.ptr)>)>> + // CHECK-DAG: %[[VAL_76:.*]] = llvm.mlir.constant(0 : index) : i64 + // CHECK-DAG: %[[VAL_77:.*]] = llvm.mlir.constant(0 : i32) : i32 + // CHECK-DAG: %[[VAL_78:.*]] = llvm.mlir.constant(0 : i32) : i32 + // CHECK-NEXT: %[[VAL_79:.*]] = llvm.extractelement %[[VAL_70]]{{\[}}%[[VAL_78]] : i32] : vector<3xi64> + // CHECK-NEXT: %[[VAL_80:.*]] = llvm.getelementptr inbounds %[[VAL_75]][0, 0, 0, %[[VAL_77]]] : (!llvm.ptr)>)>>, i32) -> !llvm.ptr + // CHECK-NEXT: %[[VAL_81:.*]] = llvm.getelementptr %[[VAL_80]]{{\[}}%[[VAL_76]]] : (!llvm.ptr, i64) -> !llvm.ptr + // CHECK-NEXT: llvm.store %[[VAL_79]], %[[VAL_81]] : !llvm.ptr + // CHECK-DAG: %[[VAL_82:.*]] = llvm.mlir.constant(1 : i32) : i32 + // CHECK-DAG: %[[VAL_83:.*]] = llvm.mlir.constant(1 : i32) : i32 + // CHECK-NEXT: %[[VAL_84:.*]] = llvm.extractelement %[[VAL_70]]{{\[}}%[[VAL_83]] : i32] : vector<3xi64> + // CHECK-NEXT: %[[VAL_85:.*]] = llvm.getelementptr inbounds %[[VAL_75]][0, 0, 0, %[[VAL_82]]] : (!llvm.ptr)>)>>, i32) -> !llvm.ptr + // CHECK-NEXT: %[[VAL_86:.*]] = llvm.getelementptr %[[VAL_85]]{{\[}}%[[VAL_76]]] : (!llvm.ptr, i64) -> !llvm.ptr + // CHECK-NEXT: llvm.store %[[VAL_84]], %[[VAL_86]] : !llvm.ptr + // CHECK-DAG: %[[VAL_87:.*]] = llvm.mlir.constant(2 : i32) : i32 + // CHECK-DAG: %[[VAL_88:.*]] = llvm.mlir.constant(2 : i32) : i32 + // CHECK-NEXT: %[[VAL_89:.*]] = llvm.extractelement %[[VAL_70]]{{\[}}%[[VAL_88]] : i32] : vector<3xi64> + // CHECK-NEXT: %[[VAL_90:.*]] = llvm.getelementptr inbounds %[[VAL_75]][0, 0, 0, %[[VAL_87]]] : (!llvm.ptr)>)>>, i32) -> !llvm.ptr + // CHECK-NEXT: %[[VAL_91:.*]] = llvm.getelementptr %[[VAL_90]]{{\[}}%[[VAL_76]]] : (!llvm.ptr, i64) -> !llvm.ptr + // CHECK-NEXT: llvm.store %[[VAL_89]], %[[VAL_91]] : !llvm.ptr + // CHECK-NEXT: %[[VAL_92:.*]] = llvm.getelementptr %[[VAL_75]]{{\[}}%[[VAL_76]]] : (!llvm.ptr)>)>>, i64) -> !llvm.ptr)>)>> + // CHECK-NEXT: %[[VAL_93:.*]] = llvm.load %[[VAL_92]] : !llvm.ptr)>)>> + // CHECK-NEXT: llvm.return %[[VAL_93]] : !llvm.struct<"class.sycl::_V1::id.3", (struct<"class.sycl::_V1::detail::array.3", (array<3 x i64>)>)> + // CHECK-NEXT: } + func.func @test_local_id() -> !sycl_id_3_ { + %0 = sycl.local_id : !sycl_id_3_ + return %0 : !sycl_id_3_ + } + + // CHECK-LABEL: llvm.func @test_local_id_dim( + // CHECK-SAME: %[[VAL_94:.*]]: i32) -> i64 { + // CHECK-NEXT: %[[VAL_95:.*]] = llvm.mlir.addressof @__spirv_BuiltInLocalInvocationId : !llvm.ptr> + // CHECK-NEXT: %[[VAL_96:.*]] = llvm.load %[[VAL_95]] : !llvm.ptr> + // CHECK-DAG: %[[VAL_97:.*]] = llvm.mlir.constant(dense<0> : vector<3xindex>) : vector<3xi64> + // CHECK-DAG: %[[VAL_98:.*]] = llvm.mlir.constant(0 : i32) : i32 + // CHECK-NEXT: %[[VAL_99:.*]] = llvm.extractelement %[[VAL_96]]{{\[}}%[[VAL_98]] : i32] : vector<3xi64> + // CHECK-NEXT: %[[VAL_100:.*]] = llvm.mlir.constant(0 : i64) : i64 + // CHECK-NEXT: %[[VAL_101:.*]] = llvm.insertelement %[[VAL_99]], %[[VAL_97]]{{\[}}%[[VAL_100]] : i64] : vector<3xi64> + // CHECK-NEXT: %[[VAL_102:.*]] = llvm.mlir.constant(1 : i32) : i32 + // CHECK-NEXT: %[[VAL_103:.*]] = llvm.extractelement %[[VAL_96]]{{\[}}%[[VAL_102]] : i32] : vector<3xi64> + // CHECK-NEXT: %[[VAL_104:.*]] = llvm.mlir.constant(1 : i64) : i64 + // CHECK-NEXT: %[[VAL_105:.*]] = llvm.insertelement %[[VAL_103]], %[[VAL_101]]{{\[}}%[[VAL_104]] : i64] : vector<3xi64> + // CHECK-NEXT: %[[VAL_106:.*]] = llvm.mlir.constant(2 : i32) : i32 + // CHECK-NEXT: %[[VAL_107:.*]] = llvm.extractelement %[[VAL_96]]{{\[}}%[[VAL_106]] : i32] : vector<3xi64> + // CHECK-NEXT: %[[VAL_108:.*]] = llvm.mlir.constant(2 : i64) : i64 + // CHECK-NEXT: %[[VAL_109:.*]] = llvm.insertelement %[[VAL_107]], %[[VAL_105]]{{\[}}%[[VAL_108]] : i64] : vector<3xi64> + // CHECK-NEXT: %[[VAL_110:.*]] = llvm.extractelement %[[VAL_109]]{{\[}}%[[VAL_94]] : i32] : vector<3xi64> + // CHECK-NEXT: llvm.return %[[VAL_110]] : i64 + // CHECK-NEXT: } + func.func @test_local_id_dim(%i: i32) -> index { + %0 = sycl.local_id %i : index + return %0 : index + } + + // CHECK-LABEL: llvm.func @test_work_group_size() -> !llvm.struct<"class.sycl::_V1::range.3", (struct<"class.sycl::_V1::detail::array.3", (array<3 x i64>)>)> { + // CHECK-NEXT: %[[VAL_111:.*]] = llvm.mlir.addressof @__spirv_BuiltInWorkgroupSize : !llvm.ptr> + // CHECK-NEXT: %[[VAL_112:.*]] = llvm.load %[[VAL_111]] : !llvm.ptr> + // CHECK-NEXT: %[[VAL_113:.*]] = llvm.mlir.null : !llvm.ptr)>)>> + // CHECK-NEXT: %[[VAL_114:.*]] = llvm.mlir.constant(1 : index) : i64 + // CHECK-NEXT: %[[VAL_115:.*]] = llvm.getelementptr %[[VAL_113]]{{\[}}%[[VAL_114]]] : (!llvm.ptr)>)>>, i64) -> !llvm.ptr)>)>> + // CHECK-NEXT: %[[VAL_116:.*]] = llvm.ptrtoint %[[VAL_115]] : !llvm.ptr)>)>> to i64 + // CHECK-NEXT: %[[VAL_117:.*]] = llvm.alloca %[[VAL_116]] x !llvm.struct<"class.sycl::_V1::range.3", (struct<"class.sycl::_V1::detail::array.3", (array<3 x i64>)>)> : (i64) -> !llvm.ptr)>)>> + // CHECK-DAG: %[[VAL_118:.*]] = llvm.mlir.constant(0 : index) : i64 + // CHECK-DAG: %[[VAL_119:.*]] = llvm.mlir.constant(0 : i32) : i32 + // CHECK-DAG: %[[VAL_120:.*]] = llvm.mlir.constant(0 : i32) : i32 + // CHECK-NEXT: %[[VAL_121:.*]] = llvm.extractelement %[[VAL_112]]{{\[}}%[[VAL_120]] : i32] : vector<3xi64> + // CHECK-NEXT: %[[VAL_122:.*]] = llvm.getelementptr inbounds %[[VAL_117]][0, 0, 0, %[[VAL_119]]] : (!llvm.ptr)>)>>, i32) -> !llvm.ptr + // CHECK-NEXT: %[[VAL_123:.*]] = llvm.getelementptr %[[VAL_122]]{{\[}}%[[VAL_118]]] : (!llvm.ptr, i64) -> !llvm.ptr + // CHECK-NEXT: llvm.store %[[VAL_121]], %[[VAL_123]] : !llvm.ptr + // CHECK-DAG: %[[VAL_124:.*]] = llvm.mlir.constant(1 : i32) : i32 + // CHECK-DAG: %[[VAL_125:.*]] = llvm.mlir.constant(1 : i32) : i32 + // CHECK-NEXT: %[[VAL_126:.*]] = llvm.extractelement %[[VAL_112]]{{\[}}%[[VAL_125]] : i32] : vector<3xi64> + // CHECK-NEXT: %[[VAL_127:.*]] = llvm.getelementptr inbounds %[[VAL_117]][0, 0, 0, %[[VAL_124]]] : (!llvm.ptr)>)>>, i32) -> !llvm.ptr + // CHECK-NEXT: %[[VAL_128:.*]] = llvm.getelementptr %[[VAL_127]]{{\[}}%[[VAL_118]]] : (!llvm.ptr, i64) -> !llvm.ptr + // CHECK-NEXT: llvm.store %[[VAL_126]], %[[VAL_128]] : !llvm.ptr + // CHECK-DAG: %[[VAL_129:.*]] = llvm.mlir.constant(2 : i32) : i32 + // CHECK-DAG: %[[VAL_130:.*]] = llvm.mlir.constant(2 : i32) : i32 + // CHECK-NEXT: %[[VAL_131:.*]] = llvm.extractelement %[[VAL_112]]{{\[}}%[[VAL_130]] : i32] : vector<3xi64> + // CHECK-NEXT: %[[VAL_132:.*]] = llvm.getelementptr inbounds %[[VAL_117]][0, 0, 0, %[[VAL_129]]] : (!llvm.ptr)>)>>, i32) -> !llvm.ptr + // CHECK-NEXT: %[[VAL_133:.*]] = llvm.getelementptr %[[VAL_132]]{{\[}}%[[VAL_118]]] : (!llvm.ptr, i64) -> !llvm.ptr + // CHECK-NEXT: llvm.store %[[VAL_131]], %[[VAL_133]] : !llvm.ptr + // CHECK-NEXT: %[[VAL_134:.*]] = llvm.getelementptr %[[VAL_117]]{{\[}}%[[VAL_118]]] : (!llvm.ptr)>)>>, i64) -> !llvm.ptr)>)>> + // CHECK-NEXT: %[[VAL_135:.*]] = llvm.load %[[VAL_134]] : !llvm.ptr)>)>> + // CHECK-NEXT: llvm.return %[[VAL_135]] : !llvm.struct<"class.sycl::_V1::range.3", (struct<"class.sycl::_V1::detail::array.3", (array<3 x i64>)>)> + // CHECK-NEXT: } + func.func @test_work_group_size() -> !sycl_range_3_ { + %0 = sycl.work_group_size : !sycl_range_3_ + return %0 : !sycl_range_3_ + } + + // CHECK-LABEL: llvm.func @test_work_group_size_dim( + // CHECK-SAME: %[[VAL_136:.*]]: i32) -> i64 { + // CHECK-NEXT: %[[VAL_137:.*]] = llvm.mlir.addressof @__spirv_BuiltInWorkgroupSize : !llvm.ptr> + // CHECK-NEXT: %[[VAL_138:.*]] = llvm.load %[[VAL_137]] : !llvm.ptr> + // CHECK-DAG: %[[VAL_139:.*]] = llvm.mlir.constant(dense<0> : vector<3xindex>) : vector<3xi64> + // CHECK-DAG: %[[VAL_140:.*]] = llvm.mlir.constant(0 : i32) : i32 + // CHECK-NEXT: %[[VAL_141:.*]] = llvm.extractelement %[[VAL_138]]{{\[}}%[[VAL_140]] : i32] : vector<3xi64> + // CHECK-NEXT: %[[VAL_142:.*]] = llvm.mlir.constant(0 : i64) : i64 + // CHECK-NEXT: %[[VAL_143:.*]] = llvm.insertelement %[[VAL_141]], %[[VAL_139]]{{\[}}%[[VAL_142]] : i64] : vector<3xi64> + // CHECK-NEXT: %[[VAL_144:.*]] = llvm.mlir.constant(1 : i32) : i32 + // CHECK-NEXT: %[[VAL_145:.*]] = llvm.extractelement %[[VAL_138]]{{\[}}%[[VAL_144]] : i32] : vector<3xi64> + // CHECK-NEXT: %[[VAL_146:.*]] = llvm.mlir.constant(1 : i64) : i64 + // CHECK-NEXT: %[[VAL_147:.*]] = llvm.insertelement %[[VAL_145]], %[[VAL_143]]{{\[}}%[[VAL_146]] : i64] : vector<3xi64> + // CHECK-NEXT: %[[VAL_148:.*]] = llvm.mlir.constant(2 : i32) : i32 + // CHECK-NEXT: %[[VAL_149:.*]] = llvm.extractelement %[[VAL_138]]{{\[}}%[[VAL_148]] : i32] : vector<3xi64> + // CHECK-NEXT: %[[VAL_150:.*]] = llvm.mlir.constant(2 : i64) : i64 + // CHECK-NEXT: %[[VAL_151:.*]] = llvm.insertelement %[[VAL_149]], %[[VAL_147]]{{\[}}%[[VAL_150]] : i64] : vector<3xi64> + // CHECK-NEXT: %[[VAL_152:.*]] = llvm.extractelement %[[VAL_151]]{{\[}}%[[VAL_136]] : i32] : vector<3xi64> + // CHECK-NEXT: llvm.return %[[VAL_152]] : i64 + // CHECK-NEXT: } + func.func @test_work_group_size_dim(%i: i32) -> index { + %0 = sycl.work_group_size %i : index + return %0 : index + } + + // CHECK-LABEL: llvm.func @test_work_group_id() -> !llvm.struct<"class.sycl::_V1::id.1", (struct<"class.sycl::_V1::detail::array.1", (array<1 x i64>)>)> { + // CHECK-NEXT: %[[VAL_153:.*]] = llvm.mlir.addressof @__spirv_BuiltInWorkgroupId : !llvm.ptr> + // CHECK-NEXT: %[[VAL_154:.*]] = llvm.load %[[VAL_153]] : !llvm.ptr> + // CHECK-NEXT: %[[VAL_155:.*]] = llvm.mlir.null : !llvm.ptr)>)>> + // CHECK-NEXT: %[[VAL_156:.*]] = llvm.mlir.constant(1 : index) : i64 + // CHECK-NEXT: %[[VAL_157:.*]] = llvm.getelementptr %[[VAL_155]]{{\[}}%[[VAL_156]]] : (!llvm.ptr)>)>>, i64) -> !llvm.ptr)>)>> + // CHECK-NEXT: %[[VAL_158:.*]] = llvm.ptrtoint %[[VAL_157]] : !llvm.ptr)>)>> to i64 + // CHECK-NEXT: %[[VAL_159:.*]] = llvm.alloca %[[VAL_158]] x !llvm.struct<"class.sycl::_V1::id.1", (struct<"class.sycl::_V1::detail::array.1", (array<1 x i64>)>)> : (i64) -> !llvm.ptr)>)>> + // CHECK-DAG: %[[VAL_160:.*]] = llvm.mlir.constant(0 : index) : i64 + // CHECK-DAG: %[[VAL_161:.*]] = llvm.mlir.constant(0 : i32) : i32 + // CHECK-DAG: %[[VAL_162:.*]] = llvm.mlir.constant(0 : i32) : i32 + // CHECK-NEXT: %[[VAL_163:.*]] = llvm.extractelement %[[VAL_154]]{{\[}}%[[VAL_162]] : i32] : vector<3xi64> + // CHECK-NEXT: %[[VAL_164:.*]] = llvm.getelementptr inbounds %[[VAL_159]][0, 0, 0, %[[VAL_161]]] : (!llvm.ptr)>)>>, i32) -> !llvm.ptr + // CHECK-NEXT: %[[VAL_165:.*]] = llvm.getelementptr %[[VAL_164]]{{\[}}%[[VAL_160]]] : (!llvm.ptr, i64) -> !llvm.ptr + // CHECK-NEXT: llvm.store %[[VAL_163]], %[[VAL_165]] : !llvm.ptr + // CHECK-NEXT: %[[VAL_166:.*]] = llvm.getelementptr %[[VAL_159]]{{\[}}%[[VAL_160]]] : (!llvm.ptr)>)>>, i64) -> !llvm.ptr)>)>> + // CHECK-NEXT: %[[VAL_167:.*]] = llvm.load %[[VAL_166]] : !llvm.ptr)>)>> + // CHECK-NEXT: llvm.return %[[VAL_167]] : !llvm.struct<"class.sycl::_V1::id.1", (struct<"class.sycl::_V1::detail::array.1", (array<1 x i64>)>)> + // CHECK-NEXT: } + func.func @test_work_group_id() -> !sycl_id_1_ { + %0 = sycl.work_group_id : !sycl_id_1_ + return %0 : !sycl_id_1_ + } + + // CHECK-LABEL: llvm.func @test_work_group_id_dim( + // CHECK-SAME: %[[VAL_168:.*]]: i32) -> i64 { + // CHECK-NEXT: %[[VAL_169:.*]] = llvm.mlir.addressof @__spirv_BuiltInWorkgroupId : !llvm.ptr> + // CHECK-NEXT: %[[VAL_170:.*]] = llvm.load %[[VAL_169]] : !llvm.ptr> + // CHECK-DAG: %[[VAL_171:.*]] = llvm.mlir.constant(dense<0> : vector<3xindex>) : vector<3xi64> + // CHECK-DAG: %[[VAL_172:.*]] = llvm.mlir.constant(0 : i32) : i32 + // CHECK-NEXT: %[[VAL_173:.*]] = llvm.extractelement %[[VAL_170]]{{\[}}%[[VAL_172]] : i32] : vector<3xi64> + // CHECK-NEXT: %[[VAL_174:.*]] = llvm.mlir.constant(0 : i64) : i64 + // CHECK-NEXT: %[[VAL_175:.*]] = llvm.insertelement %[[VAL_173]], %[[VAL_171]]{{\[}}%[[VAL_174]] : i64] : vector<3xi64> + // CHECK-NEXT: %[[VAL_176:.*]] = llvm.mlir.constant(1 : i32) : i32 + // CHECK-NEXT: %[[VAL_177:.*]] = llvm.extractelement %[[VAL_170]]{{\[}}%[[VAL_176]] : i32] : vector<3xi64> + // CHECK-NEXT: %[[VAL_178:.*]] = llvm.mlir.constant(1 : i64) : i64 + // CHECK-NEXT: %[[VAL_179:.*]] = llvm.insertelement %[[VAL_177]], %[[VAL_175]]{{\[}}%[[VAL_178]] : i64] : vector<3xi64> + // CHECK-NEXT: %[[VAL_180:.*]] = llvm.mlir.constant(2 : i32) : i32 + // CHECK-NEXT: %[[VAL_181:.*]] = llvm.extractelement %[[VAL_170]]{{\[}}%[[VAL_180]] : i32] : vector<3xi64> + // CHECK-NEXT: %[[VAL_182:.*]] = llvm.mlir.constant(2 : i64) : i64 + // CHECK-NEXT: %[[VAL_183:.*]] = llvm.insertelement %[[VAL_181]], %[[VAL_179]]{{\[}}%[[VAL_182]] : i64] : vector<3xi64> + // CHECK-NEXT: %[[VAL_184:.*]] = llvm.extractelement %[[VAL_183]]{{\[}}%[[VAL_168]] : i32] : vector<3xi64> + // CHECK-NEXT: llvm.return %[[VAL_184]] : i64 + // CHECK-NEXT: } + func.func @test_work_group_id_dim(%i: i32) -> index { + %0 = sycl.work_group_id %i : index + return %0 : index + } + + // CHECK-LABEL: llvm.func @test_num_sub_groups() -> i32 { + // CHECK-NEXT: %[[VAL_200:.*]] = llvm.mlir.addressof @__spirv_BuiltInNumSubgroups : !llvm.ptr + // CHECK-NEXT: %[[VAL_201:.*]] = llvm.load %[[VAL_200]] : !llvm.ptr + // CHECK-NEXT: %[[VAL_202:.*]] = llvm.trunc %[[VAL_201]] : i64 to i32 + // CHECK-NEXT: llvm.return %[[VAL_202]] : i32 + // CHECK-NEXT: } + func.func @test_num_sub_groups() -> i32 { + %0 = sycl.num_sub_groups : i32 + return %0 : i32 + } + + // CHECK-LABEL: llvm.func @test_sub_group_size() -> i32 { + // CHECK-NEXT: %[[VAL_203:.*]] = llvm.mlir.addressof @__spirv_BuiltInSubgroupSize : !llvm.ptr + // CHECK-NEXT: %[[VAL_204:.*]] = llvm.load %[[VAL_203]] : !llvm.ptr + // CHECK-NEXT: %[[VAL_205:.*]] = llvm.trunc %[[VAL_204]] : i64 to i32 + // CHECK-NEXT: llvm.return %[[VAL_205]] : i32 + // CHECK-NEXT: } + func.func @test_sub_group_size() -> i32 { + %0 = sycl.sub_group_size : i32 + return %0 : i32 + } + + // CHECK-LABEL: llvm.func @test_sub_group_id() -> i32 { + // CHECK-NEXT: %[[VAL_206:.*]] = llvm.mlir.addressof @__spirv_BuiltInSubgroupId : !llvm.ptr + // CHECK-NEXT: %[[VAL_207:.*]] = llvm.load %[[VAL_206]] : !llvm.ptr + // CHECK-NEXT: %[[VAL_208:.*]] = llvm.trunc %[[VAL_207]] : i64 to i32 + // CHECK-NEXT: llvm.return %[[VAL_208]] : i32 + // CHECK-NEXT: } + func.func @test_sub_group_id() -> i32 { + %0 = sycl.sub_group_id : i32 + return %0 : i32 + } + + // CHECK-LABEL: llvm.func @test_global_offset() -> !llvm.struct<"class.sycl::_V1::id.1", (struct<"class.sycl::_V1::detail::array.1", (array<1 x i64>)>)> { + // CHECK-NEXT: %[[VAL_194:.*]] = llvm.mlir.addressof @__spirv_BuiltInGlobalOffset : !llvm.ptr> + // CHECK-NEXT: %[[VAL_195:.*]] = llvm.load %[[VAL_194]] : !llvm.ptr> + // CHECK-NEXT: %[[VAL_196:.*]] = llvm.mlir.null : !llvm.ptr)>)>> + // CHECK-NEXT: %[[VAL_197:.*]] = llvm.mlir.constant(1 : index) : i64 + // CHECK-NEXT: %[[VAL_198:.*]] = llvm.getelementptr %[[VAL_196]]{{\[}}%[[VAL_197]]] : (!llvm.ptr)>)>>, i64) -> !llvm.ptr)>)>> + // CHECK-NEXT: %[[VAL_199:.*]] = llvm.ptrtoint %[[VAL_198]] : !llvm.ptr)>)>> to i64 + // CHECK-NEXT: %[[VAL_200:.*]] = llvm.alloca %[[VAL_199]] x !llvm.struct<"class.sycl::_V1::id.1", (struct<"class.sycl::_V1::detail::array.1", (array<1 x i64>)>)> : (i64) -> !llvm.ptr)>)>> + // CHECK-DAG: %[[VAL_201:.*]] = llvm.mlir.constant(0 : index) : i64 + // CHECK-DAG: %[[VAL_202:.*]] = llvm.mlir.constant(0 : i32) : i32 + // CHECK-DAG: %[[VAL_203:.*]] = llvm.mlir.constant(0 : i32) : i32 + // CHECK-NEXT: %[[VAL_204:.*]] = llvm.extractelement %[[VAL_195]]{{\[}}%[[VAL_203]] : i32] : vector<3xi64> + // CHECK-NEXT: %[[VAL_205:.*]] = llvm.getelementptr inbounds %[[VAL_200]][0, 0, 0, %[[VAL_202]]] : (!llvm.ptr)>)>>, i32) -> !llvm.ptr + // CHECK-NEXT: %[[VAL_206:.*]] = llvm.getelementptr %[[VAL_205]]{{\[}}%[[VAL_201]]] : (!llvm.ptr, i64) -> !llvm.ptr + // CHECK-NEXT: llvm.store %[[VAL_204]], %[[VAL_206]] : !llvm.ptr + // CHECK-NEXT: %[[VAL_207:.*]] = llvm.getelementptr %[[VAL_200]]{{\[}}%[[VAL_201]]] : (!llvm.ptr)>)>>, i64) -> !llvm.ptr)>)>> + // CHECK-NEXT: %[[VAL_208:.*]] = llvm.load %[[VAL_207]] : !llvm.ptr)>)>> + // CHECK-NEXT: llvm.return %[[VAL_208]] : !llvm.struct<"class.sycl::_V1::id.1", (struct<"class.sycl::_V1::detail::array.1", (array<1 x i64>)>)> + // CHECK-NEXT: } + func.func @test_global_offset() -> !sycl_id_1_ { + %0 = sycl.global_offset : !sycl_id_1_ + return %0 : !sycl_id_1_ + } + + // CHECK-LABEL: llvm.func @test_global_offset_dim( + // CHECK-SAME: %[[VAL_222:.*]]: i32) -> i64 { + // CHECK-NEXT: %[[VAL_223:.*]] = llvm.mlir.addressof @__spirv_BuiltInGlobalOffset : !llvm.ptr> + // CHECK-NEXT: %[[VAL_224:.*]] = llvm.load %[[VAL_223]] : !llvm.ptr> + // CHECK-DAG: %[[VAL_225:.*]] = llvm.mlir.constant(dense<0> : vector<3xindex>) : vector<3xi64> + // CHECK-DAG: %[[VAL_226:.*]] = llvm.mlir.constant(0 : i32) : i32 + // CHECK-NEXT: %[[VAL_227:.*]] = llvm.extractelement %[[VAL_224]]{{\[}}%[[VAL_226]] : i32] : vector<3xi64> + // CHECK-DAG: %[[VAL_228:.*]] = llvm.mlir.constant(0 : i64) : i64 + // CHECK-NEXT: %[[VAL_229:.*]] = llvm.insertelement %[[VAL_227]], %[[VAL_225]]{{\[}}%[[VAL_228]] : i64] : vector<3xi64> + // CHECK-DAG: %[[VAL_230:.*]] = llvm.mlir.constant(1 : i32) : i32 + // CHECK-NEXT: %[[VAL_231:.*]] = llvm.extractelement %[[VAL_224]]{{\[}}%[[VAL_230]] : i32] : vector<3xi64> + // CHECK-DAG: %[[VAL_232:.*]] = llvm.mlir.constant(1 : i64) : i64 + // CHECK-NEXT: %[[VAL_233:.*]] = llvm.insertelement %[[VAL_231]], %[[VAL_229]]{{\[}}%[[VAL_232]] : i64] : vector<3xi64> + // CHECK-DAG: %[[VAL_234:.*]] = llvm.mlir.constant(2 : i32) : i32 + // CHECK-NEXT: %[[VAL_235:.*]] = llvm.extractelement %[[VAL_224]]{{\[}}%[[VAL_234]] : i32] : vector<3xi64> + // CHECK-DAG: %[[VAL_236:.*]] = llvm.mlir.constant(2 : i64) : i64 + // CHECK-NEXT: %[[VAL_237:.*]] = llvm.insertelement %[[VAL_235]], %[[VAL_233]]{{\[}}%[[VAL_236]] : i64] : vector<3xi64> + // CHECK-NEXT: %[[VAL_238:.*]] = llvm.extractelement %[[VAL_237]]{{\[}}%[[VAL_222]] : i32] : vector<3xi64> + // CHECK-NEXT: llvm.return %[[VAL_238]] : i64 + // CHECK-NEXT: } + func.func @test_global_offset_dim(%i: i32) -> index { + %0 = sycl.global_offset %i : index + return %0 : index + } + + // CHECK-LABEL: llvm.func @test_num_work_groups() -> !llvm.struct<"class.sycl::_V1::range.2", (struct<"class.sycl::_V1::detail::array.2", (array<2 x i64>)>)> { + // CHECK-NEXT: %[[VAL_226:.*]] = llvm.mlir.addressof @__spirv_BuiltInNumWorkgroups : !llvm.ptr> + // CHECK-NEXT: %[[VAL_227:.*]] = llvm.load %[[VAL_226]] : !llvm.ptr> + // CHECK-NEXT: %[[VAL_228:.*]] = llvm.mlir.null : !llvm.ptr)>)>> + // CHECK-NEXT: %[[VAL_229:.*]] = llvm.mlir.constant(1 : index) : i64 + // CHECK-NEXT: %[[VAL_230:.*]] = llvm.getelementptr %[[VAL_228]]{{\[}}%[[VAL_229]]] : (!llvm.ptr)>)>>, i64) -> !llvm.ptr)>)>> + // CHECK-NEXT: %[[VAL_231:.*]] = llvm.ptrtoint %[[VAL_230]] : !llvm.ptr)>)>> to i64 + // CHECK-NEXT: %[[VAL_232:.*]] = llvm.alloca %[[VAL_231]] x !llvm.struct<"class.sycl::_V1::range.2", (struct<"class.sycl::_V1::detail::array.2", (array<2 x i64>)>)> : (i64) -> !llvm.ptr)>)>> + // CHECK-DAG: %[[VAL_233:.*]] = llvm.mlir.constant(0 : index) : i64 + // CHECK-DAG: %[[VAL_234:.*]] = llvm.mlir.constant(0 : i32) : i32 + // CHECK-DAG: %[[VAL_235:.*]] = llvm.mlir.constant(0 : i32) : i32 + // CHECK-NEXT: %[[VAL_236:.*]] = llvm.extractelement %[[VAL_227]]{{\[}}%[[VAL_235]] : i32] : vector<3xi64> + // CHECK-NEXT: %[[VAL_237:.*]] = llvm.getelementptr inbounds %[[VAL_232]][0, 0, 0, %[[VAL_234]]] : (!llvm.ptr)>)>>, i32) -> !llvm.ptr + // CHECK-NEXT: %[[VAL_238:.*]] = llvm.getelementptr %[[VAL_237]]{{\[}}%[[VAL_233]]] : (!llvm.ptr, i64) -> !llvm.ptr + // CHECK-NEXT: llvm.store %[[VAL_236]], %[[VAL_238]] : !llvm.ptr + // CHECK-DAG: %[[VAL_239:.*]] = llvm.mlir.constant(1 : i32) : i32 + // CHECK-DAG: %[[VAL_240:.*]] = llvm.mlir.constant(1 : i32) : i32 + // CHECK-NEXT: %[[VAL_241:.*]] = llvm.extractelement %[[VAL_227]]{{\[}}%[[VAL_240]] : i32] : vector<3xi64> + // CHECK-NEXT: %[[VAL_242:.*]] = llvm.getelementptr inbounds %[[VAL_232]][0, 0, 0, %[[VAL_239]]] : (!llvm.ptr)>)>>, i32) -> !llvm.ptr + // CHECK-NEXT: %[[VAL_243:.*]] = llvm.getelementptr %[[VAL_242]]{{\[}}%[[VAL_233]]] : (!llvm.ptr, i64) -> !llvm.ptr + // CHECK-NEXT: llvm.store %[[VAL_241]], %[[VAL_243]] : !llvm.ptr + // CHECK-NEXT: %[[VAL_244:.*]] = llvm.getelementptr %[[VAL_232]]{{\[}}%[[VAL_233]]] : (!llvm.ptr)>)>>, i64) -> !llvm.ptr)>)>> + // CHECK-NEXT: %[[VAL_245:.*]] = llvm.load %[[VAL_244]] : !llvm.ptr)>)>> + // CHECK-NEXT: llvm.return %[[VAL_245]] : !llvm.struct<"class.sycl::_V1::range.2", (struct<"class.sycl::_V1::detail::array.2", (array<2 x i64>)>)> + // CHECK-NEXT: } + func.func @test_num_work_groups() -> !sycl_range_2_ { + %0 = sycl.num_work_groups : !sycl_range_2_ + return %0 : !sycl_range_2_ + } + + // CHECK-LABEL: llvm.func @test_num_work_groups_dim( + // CHECK-SAME: %[[VAL_246:.*]]: i32) -> i64 { + // CHECK-NEXT: %[[VAL_247:.*]] = llvm.mlir.addressof @__spirv_BuiltInNumWorkgroups : !llvm.ptr> + // CHECK-NEXT: %[[VAL_248:.*]] = llvm.load %[[VAL_247]] : !llvm.ptr> + // CHECK-DAG: %[[VAL_249:.*]] = llvm.mlir.constant(dense<0> : vector<3xindex>) : vector<3xi64> + // CHECK-DAG: %[[VAL_250:.*]] = llvm.mlir.constant(0 : i32) : i32 + // CHECK-NEXT: %[[VAL_251:.*]] = llvm.extractelement %[[VAL_248]]{{\[}}%[[VAL_250]] : i32] : vector<3xi64> + // CHECK-NEXT: %[[VAL_252:.*]] = llvm.mlir.constant(0 : i64) : i64 + // CHECK-NEXT: %[[VAL_253:.*]] = llvm.insertelement %[[VAL_251]], %[[VAL_249]]{{\[}}%[[VAL_252]] : i64] : vector<3xi64> + // CHECK-NEXT: %[[VAL_254:.*]] = llvm.mlir.constant(1 : i32) : i32 + // CHECK-NEXT: %[[VAL_255:.*]] = llvm.extractelement %[[VAL_248]]{{\[}}%[[VAL_254]] : i32] : vector<3xi64> + // CHECK-NEXT: %[[VAL_256:.*]] = llvm.mlir.constant(1 : i64) : i64 + // CHECK-NEXT: %[[VAL_257:.*]] = llvm.insertelement %[[VAL_255]], %[[VAL_253]]{{\[}}%[[VAL_256]] : i64] : vector<3xi64> + // CHECK-NEXT: %[[VAL_258:.*]] = llvm.mlir.constant(2 : i32) : i32 + // CHECK-NEXT: %[[VAL_259:.*]] = llvm.extractelement %[[VAL_248]]{{\[}}%[[VAL_258]] : i32] : vector<3xi64> + // CHECK-NEXT: %[[VAL_260:.*]] = llvm.mlir.constant(2 : i64) : i64 + // CHECK-NEXT: %[[VAL_261:.*]] = llvm.insertelement %[[VAL_259]], %[[VAL_257]]{{\[}}%[[VAL_260]] : i64] : vector<3xi64> + // CHECK-NEXT: %[[VAL_262:.*]] = llvm.extractelement %[[VAL_261]]{{\[}}%[[VAL_246]] : i32] : vector<3xi64> + // CHECK-NEXT: llvm.return %[[VAL_262]] : i64 + // CHECK-NEXT: } + func.func @test_num_work_groups_dim(%i: i32) -> index { + %0 = sycl.num_work_groups %i : index + return %0 : index + } + + // CHECK-LABEL: llvm.func @test_sub_group_max_size() -> i32 { + // CHECK-NEXT: %[[VAL_273:.*]] = llvm.mlir.addressof @__spirv_BuiltInSubgroupMaxSize : !llvm.ptr + // CHECK-NEXT: %[[VAL_274:.*]] = llvm.load %[[VAL_273]] : !llvm.ptr + // CHECK-NEXT: %[[VAL_275:.*]] = llvm.trunc %[[VAL_274]] : i64 to i32 + // CHECK-NEXT: llvm.return %[[VAL_275]] : i32 + func.func @test_sub_group_max_size() -> i32 { + %0 = sycl.sub_group_max_size : i32 + return %0 : i32 + } + + // CHECK-LABEL: llvm.func @test_sub_group_local_id() -> i32 { + // CHECK-NEXT: %[[VAL_276:.*]] = llvm.mlir.addressof @__spirv_BuiltInSubgroupLocalInvocationId : !llvm.ptr + // CHECK-NEXT: %[[VAL_277:.*]] = llvm.load %[[VAL_276]] : !llvm.ptr + // CHECK-NEXT: %[[VAL_278:.*]] = llvm.trunc %[[VAL_277]] : i64 to i32 + // CHECK-NEXT: llvm.return %[[VAL_278]] : i32 + // CHECK-NEXT: } + func.func @test_sub_group_local_id() -> i32 { + %0 = sycl.sub_group_local_id : i32 + return %0 : i32 + } + } +} diff --git a/mlir-sycl/test/Conversion/SYCLToLLVM/sycl-grid-ops-to-llvm.mlir b/mlir-sycl/test/Conversion/SYCLToLLVM/sycl-grid-ops-to-llvm.mlir index e531c3090291a..15ef243f86e18 100644 --- a/mlir-sycl/test/Conversion/SYCLToLLVM/sycl-grid-ops-to-llvm.mlir +++ b/mlir-sycl/test/Conversion/SYCLToLLVM/sycl-grid-ops-to-llvm.mlir @@ -1,4 +1,4 @@ -// RUN: sycl-mlir-opt -convert-sycl-to-llvm %s -o - | FileCheck %s +// RUN: sycl-mlir-opt -convert-sycl-to-llvm='use-opaque-pointers=1' %s -o - | FileCheck %s !sycl_id_1_ = !sycl.id<[1], (!sycl.array<[1], (memref<1xi64, 4>)>)> !sycl_id_2_ = !sycl.id<[2], (!sycl.array<[2], (memref<2xi64, 4>)>)> @@ -23,22 +23,22 @@ module attributes {gpu.container_module} { //CHECK-DAG: llvm.mlir.global external constant @__spirv_BuiltInGlobalSize() {addr_space = 0 : i32} : vector<3xi64> gpu.module @kernels { // CHECK-LABEL: llvm.func @test_num_work_items() -> !llvm.struct<"class.sycl::_V1::range.1", (struct<"class.sycl::_V1::detail::array.1", (array<1 x i64>)>)> { - // CHECK-NEXT: %[[VAL_0:.*]] = llvm.mlir.addressof @__spirv_BuiltInGlobalSize : !llvm.ptr> - // CHECK-NEXT: %[[VAL_1:.*]] = llvm.load %[[VAL_0]] : !llvm.ptr> - // CHECK-NEXT: %[[VAL_2:.*]] = llvm.mlir.null : !llvm.ptr)>)>> + // CHECK-NEXT: %[[VAL_0:.*]] = llvm.mlir.addressof @__spirv_BuiltInGlobalSize : !llvm.ptr + // CHECK-NEXT: %[[VAL_1:.*]] = llvm.load %[[VAL_0]] : !llvm.ptr -> vector<3xi64> + // CHECK-NEXT: %[[VAL_2:.*]] = llvm.mlir.null : !llvm.ptr // CHECK-NEXT: %[[VAL_3:.*]] = llvm.mlir.constant(1 : index) : i64 - // CHECK-NEXT: %[[VAL_4:.*]] = llvm.getelementptr %[[VAL_2]]{{\[}}%[[VAL_3]]] : (!llvm.ptr)>)>>, i64) -> !llvm.ptr)>)>> - // CHECK-NEXT: %[[VAL_5:.*]] = llvm.ptrtoint %[[VAL_4]] : !llvm.ptr)>)>> to i64 - // CHECK-NEXT: %[[VAL_6:.*]] = llvm.alloca %[[VAL_5]] x !llvm.struct<"class.sycl::_V1::range.1", (struct<"class.sycl::_V1::detail::array.1", (array<1 x i64>)>)> : (i64) -> !llvm.ptr)>)>> + // CHECK-NEXT: %[[VAL_4:.*]] = llvm.getelementptr %[[VAL_2]]{{\[}}%[[VAL_3]]] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::range.1", {{.*}}> + // CHECK-NEXT: %[[VAL_5:.*]] = llvm.ptrtoint %[[VAL_4]] : !llvm.ptr to i64 + // CHECK-NEXT: %[[VAL_6:.*]] = llvm.alloca %[[VAL_5]] x !llvm.struct<"class.sycl::_V1::range.1", (struct<"class.sycl::_V1::detail::array.1", (array<1 x i64>)>)> : (i64) -> !llvm.ptr // CHECK-DAG: %[[VAL_7:.*]] = llvm.mlir.constant(0 : index) : i64 // CHECK-DAG: %[[VAL_8:.*]] = llvm.mlir.constant(0 : i32) : i32 // CHECK-DAG: %[[VAL_9:.*]] = llvm.mlir.constant(0 : i32) : i32 // CHECK-NEXT: %[[VAL_10:.*]] = llvm.extractelement %[[VAL_1]]{{\[}}%[[VAL_9]] : i32] : vector<3xi64> - // CHECK-NEXT: %[[VAL_11:.*]] = llvm.getelementptr inbounds %[[VAL_6]][0, 0, 0, %[[VAL_8]]] : (!llvm.ptr)>)>>, i32) -> !llvm.ptr - // CHECK-NEXT: %[[VAL_12:.*]] = llvm.getelementptr %[[VAL_11]]{{\[}}%[[VAL_7]]] : (!llvm.ptr, i64) -> !llvm.ptr - // CHECK-NEXT: llvm.store %[[VAL_10]], %[[VAL_12]] : !llvm.ptr - // CHECK-NEXT: %[[VAL_13:.*]] = llvm.getelementptr %[[VAL_6]]{{\[}}%[[VAL_7]]] : (!llvm.ptr)>)>>, i64) -> !llvm.ptr)>)>> - // CHECK-NEXT: %[[VAL_14:.*]] = llvm.load %[[VAL_13]] : !llvm.ptr)>)>> + // CHECK-NEXT: %[[VAL_11:.*]] = llvm.getelementptr inbounds %[[VAL_6]][0, 0, 0, %[[VAL_8]]] : (!llvm.ptr, i32) -> !llvm.ptr, i64 + // CHECK-NEXT: %[[VAL_12:.*]] = llvm.getelementptr %[[VAL_11]]{{\[}}%[[VAL_7]]] : (!llvm.ptr, i64) -> !llvm.ptr, i64 + // CHECK-NEXT: llvm.store %[[VAL_10]], %[[VAL_12]] : i64, !llvm.ptr + // CHECK-NEXT: %[[VAL_13:.*]] = llvm.getelementptr %[[VAL_6]]{{\[}}%[[VAL_7]]] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::range.1", {{.*}}> + // CHECK-NEXT: %[[VAL_14:.*]] = llvm.load %[[VAL_13]] : !llvm.ptr -> !llvm.struct<"class.sycl::_V1::range.1", {{.*}}> // CHECK-NEXT: llvm.return %[[VAL_14]] : !llvm.struct<"class.sycl::_V1::range.1", (struct<"class.sycl::_V1::detail::array.1", (array<1 x i64>)>)> // CHECK-NEXT: } func.func @test_num_work_items() -> !sycl_range_1_ { @@ -48,8 +48,8 @@ module attributes {gpu.container_module} { // CHECK-LABEL: llvm.func @test_num_work_items_dim( // CHECK-SAME: %[[VAL_15:.*]]: i32) -> i64 { - // CHECK-NEXT: %[[VAL_16:.*]] = llvm.mlir.addressof @__spirv_BuiltInGlobalSize : !llvm.ptr> - // CHECK-NEXT: %[[VAL_17:.*]] = llvm.load %[[VAL_16]] : !llvm.ptr> + // CHECK-NEXT: %[[VAL_16:.*]] = llvm.mlir.addressof @__spirv_BuiltInGlobalSize : !llvm.ptr + // CHECK-NEXT: %[[VAL_17:.*]] = llvm.load %[[VAL_16]] : !llvm.ptr -> vector<3xi64> // CHECK-DAG: %[[VAL_18:.*]] = llvm.mlir.constant(dense<0> : vector<3xindex>) : vector<3xi64> // CHECK-DAG: %[[VAL_19:.*]] = llvm.mlir.constant(0 : i32) : i32 // CHECK-NEXT: %[[VAL_20:.*]] = llvm.extractelement %[[VAL_17]]{{\[}}%[[VAL_19]] : i32] : vector<3xi64> @@ -72,28 +72,28 @@ module attributes {gpu.container_module} { } // CHECK-LABEL: llvm.func @test_global_id() -> !llvm.struct<"class.sycl::_V1::id.2", (struct<"class.sycl::_V1::detail::array.2", (array<2 x i64>)>)> { - // CHECK-NEXT: %[[VAL_32:.*]] = llvm.mlir.addressof @__spirv_BuiltInGlobalInvocationId : !llvm.ptr> - // CHECK-NEXT: %[[VAL_33:.*]] = llvm.load %[[VAL_32]] : !llvm.ptr> - // CHECK-NEXT: %[[VAL_34:.*]] = llvm.mlir.null : !llvm.ptr)>)>> + // CHECK-NEXT: %[[VAL_32:.*]] = llvm.mlir.addressof @__spirv_BuiltInGlobalInvocationId : !llvm.ptr + // CHECK-NEXT: %[[VAL_33:.*]] = llvm.load %[[VAL_32]] : !llvm.ptr -> vector<3xi64> + // CHECK-NEXT: %[[VAL_34:.*]] = llvm.mlir.null : !llvm.ptr // CHECK-NEXT: %[[VAL_35:.*]] = llvm.mlir.constant(1 : index) : i64 - // CHECK-NEXT: %[[VAL_36:.*]] = llvm.getelementptr %[[VAL_34]]{{\[}}%[[VAL_35]]] : (!llvm.ptr)>)>>, i64) -> !llvm.ptr)>)>> - // CHECK-NEXT: %[[VAL_37:.*]] = llvm.ptrtoint %[[VAL_36]] : !llvm.ptr)>)>> to i64 - // CHECK-NEXT: %[[VAL_38:.*]] = llvm.alloca %[[VAL_37]] x !llvm.struct<"class.sycl::_V1::id.2", (struct<"class.sycl::_V1::detail::array.2", (array<2 x i64>)>)> : (i64) -> !llvm.ptr)>)>> + // CHECK-NEXT: %[[VAL_36:.*]] = llvm.getelementptr %[[VAL_34]]{{\[}}%[[VAL_35]]] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::id.2", {{.*}}> + // CHECK-NEXT: %[[VAL_37:.*]] = llvm.ptrtoint %[[VAL_36]] : !llvm.ptr to i64 + // CHECK-NEXT: %[[VAL_38:.*]] = llvm.alloca %[[VAL_37]] x !llvm.struct<"class.sycl::_V1::id.2", (struct<"class.sycl::_V1::detail::array.2", (array<2 x i64>)>)> : (i64) -> !llvm.ptr // CHECK-DAG: %[[VAL_39:.*]] = llvm.mlir.constant(0 : index) : i64 // CHECK-DAG: %[[VAL_40:.*]] = llvm.mlir.constant(0 : i32) : i32 // CHECK-DAG: %[[VAL_41:.*]] = llvm.mlir.constant(0 : i32) : i32 // CHECK-NEXT: %[[VAL_42:.*]] = llvm.extractelement %[[VAL_33]]{{\[}}%[[VAL_41]] : i32] : vector<3xi64> - // CHECK-NEXT: %[[VAL_43:.*]] = llvm.getelementptr inbounds %[[VAL_38]][0, 0, 0, %[[VAL_40]]] : (!llvm.ptr)>)>>, i32) -> !llvm.ptr - // CHECK-NEXT: %[[VAL_44:.*]] = llvm.getelementptr %[[VAL_43]]{{\[}}%[[VAL_39]]] : (!llvm.ptr, i64) -> !llvm.ptr - // CHECK-NEXT: llvm.store %[[VAL_42]], %[[VAL_44]] : !llvm.ptr + // CHECK-NEXT: %[[VAL_43:.*]] = llvm.getelementptr inbounds %[[VAL_38]][0, 0, 0, %[[VAL_40]]] : (!llvm.ptr, i32) -> !llvm.ptr, i64 + // CHECK-NEXT: %[[VAL_44:.*]] = llvm.getelementptr %[[VAL_43]]{{\[}}%[[VAL_39]]] : (!llvm.ptr, i64) -> !llvm.ptr, i64 + // CHECK-NEXT: llvm.store %[[VAL_42]], %[[VAL_44]] : i64, !llvm.ptr // CHECK-DAG: %[[VAL_45:.*]] = llvm.mlir.constant(1 : i32) : i32 // CHECK-DAG: %[[VAL_46:.*]] = llvm.mlir.constant(1 : i32) : i32 // CHECK-NEXT: %[[VAL_47:.*]] = llvm.extractelement %[[VAL_33]]{{\[}}%[[VAL_46]] : i32] : vector<3xi64> - // CHECK-NEXT: %[[VAL_48:.*]] = llvm.getelementptr inbounds %[[VAL_38]][0, 0, 0, %[[VAL_45]]] : (!llvm.ptr)>)>>, i32) -> !llvm.ptr - // CHECK-NEXT: %[[VAL_49:.*]] = llvm.getelementptr %[[VAL_48]]{{\[}}%[[VAL_39]]] : (!llvm.ptr, i64) -> !llvm.ptr - // CHECK-NEXT: llvm.store %[[VAL_47]], %[[VAL_49]] : !llvm.ptr - // CHECK-NEXT: %[[VAL_50:.*]] = llvm.getelementptr %[[VAL_38]]{{\[}}%[[VAL_39]]] : (!llvm.ptr)>)>>, i64) -> !llvm.ptr)>)>> - // CHECK-NEXT: %[[VAL_51:.*]] = llvm.load %[[VAL_50]] : !llvm.ptr)>)>> + // CHECK-NEXT: %[[VAL_48:.*]] = llvm.getelementptr inbounds %[[VAL_38]][0, 0, 0, %[[VAL_45]]] : (!llvm.ptr, i32) -> !llvm.ptr, i64 + // CHECK-NEXT: %[[VAL_49:.*]] = llvm.getelementptr %[[VAL_48]]{{\[}}%[[VAL_39]]] : (!llvm.ptr, i64) -> !llvm.ptr, i64 + // CHECK-NEXT: llvm.store %[[VAL_47]], %[[VAL_49]] : i64, !llvm.ptr + // CHECK-NEXT: %[[VAL_50:.*]] = llvm.getelementptr %[[VAL_38]]{{\[}}%[[VAL_39]]] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::id.2", {{.*}}> + // CHECK-NEXT: %[[VAL_51:.*]] = llvm.load %[[VAL_50]] : !llvm.ptr -> !llvm.struct<"class.sycl::_V1::id.2", {{.*}}> // CHECK-NEXT: llvm.return %[[VAL_51]] : !llvm.struct<"class.sycl::_V1::id.2", (struct<"class.sycl::_V1::detail::array.2", (array<2 x i64>)>)> // CHECK-NEXT: } func.func @test_global_id() -> !sycl_id_2_ { @@ -103,8 +103,8 @@ module attributes {gpu.container_module} { // CHECK-LABEL: llvm.func @test_global_id_dim( // CHECK-SAME: %[[VAL_52:.*]]: i32) -> i64 { - // CHECK-NEXT: %[[VAL_53:.*]] = llvm.mlir.addressof @__spirv_BuiltInGlobalInvocationId : !llvm.ptr> - // CHECK-NEXT: %[[VAL_54:.*]] = llvm.load %[[VAL_53]] : !llvm.ptr> + // CHECK-NEXT: %[[VAL_53:.*]] = llvm.mlir.addressof @__spirv_BuiltInGlobalInvocationId : !llvm.ptr + // CHECK-NEXT: %[[VAL_54:.*]] = llvm.load %[[VAL_53]] : !llvm.ptr -> vector<3xi64> // CHECK-DAG: %[[VAL_55:.*]] = llvm.mlir.constant(dense<0> : vector<3xindex>) : vector<3xi64> // CHECK-DAG: %[[VAL_56:.*]] = llvm.mlir.constant(0 : i32) : i32 // CHECK-NEXT: %[[VAL_57:.*]] = llvm.extractelement %[[VAL_54]]{{\[}}%[[VAL_56]] : i32] : vector<3xi64> @@ -127,34 +127,34 @@ module attributes {gpu.container_module} { } // CHECK-LABEL: llvm.func @test_local_id() -> !llvm.struct<"class.sycl::_V1::id.3", (struct<"class.sycl::_V1::detail::array.3", (array<3 x i64>)>)> { - // CHECK-NEXT: %[[VAL_69:.*]] = llvm.mlir.addressof @__spirv_BuiltInLocalInvocationId : !llvm.ptr> - // CHECK-NEXT: %[[VAL_70:.*]] = llvm.load %[[VAL_69]] : !llvm.ptr> - // CHECK-NEXT: %[[VAL_71:.*]] = llvm.mlir.null : !llvm.ptr)>)>> + // CHECK-NEXT: %[[VAL_69:.*]] = llvm.mlir.addressof @__spirv_BuiltInLocalInvocationId : !llvm.ptr + // CHECK-NEXT: %[[VAL_70:.*]] = llvm.load %[[VAL_69]] : !llvm.ptr -> vector<3xi64> + // CHECK-NEXT: %[[VAL_71:.*]] = llvm.mlir.null : !llvm.ptr // CHECK-NEXT: %[[VAL_72:.*]] = llvm.mlir.constant(1 : index) : i64 - // CHECK-NEXT: %[[VAL_73:.*]] = llvm.getelementptr %[[VAL_71]]{{\[}}%[[VAL_72]]] : (!llvm.ptr)>)>>, i64) -> !llvm.ptr)>)>> - // CHECK-NEXT: %[[VAL_74:.*]] = llvm.ptrtoint %[[VAL_73]] : !llvm.ptr)>)>> to i64 - // CHECK-NEXT: %[[VAL_75:.*]] = llvm.alloca %[[VAL_74]] x !llvm.struct<"class.sycl::_V1::id.3", (struct<"class.sycl::_V1::detail::array.3", (array<3 x i64>)>)> : (i64) -> !llvm.ptr)>)>> + // CHECK-NEXT: %[[VAL_73:.*]] = llvm.getelementptr %[[VAL_71]]{{\[}}%[[VAL_72]]] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::id.3", {{.*}}> + // CHECK-NEXT: %[[VAL_74:.*]] = llvm.ptrtoint %[[VAL_73]] : !llvm.ptr to i64 + // CHECK-NEXT: %[[VAL_75:.*]] = llvm.alloca %[[VAL_74]] x !llvm.struct<"class.sycl::_V1::id.3", (struct<"class.sycl::_V1::detail::array.3", (array<3 x i64>)>)> : (i64) -> !llvm.ptr // CHECK-DAG: %[[VAL_76:.*]] = llvm.mlir.constant(0 : index) : i64 // CHECK-DAG: %[[VAL_77:.*]] = llvm.mlir.constant(0 : i32) : i32 // CHECK-DAG: %[[VAL_78:.*]] = llvm.mlir.constant(0 : i32) : i32 // CHECK-NEXT: %[[VAL_79:.*]] = llvm.extractelement %[[VAL_70]]{{\[}}%[[VAL_78]] : i32] : vector<3xi64> - // CHECK-NEXT: %[[VAL_80:.*]] = llvm.getelementptr inbounds %[[VAL_75]][0, 0, 0, %[[VAL_77]]] : (!llvm.ptr)>)>>, i32) -> !llvm.ptr - // CHECK-NEXT: %[[VAL_81:.*]] = llvm.getelementptr %[[VAL_80]]{{\[}}%[[VAL_76]]] : (!llvm.ptr, i64) -> !llvm.ptr - // CHECK-NEXT: llvm.store %[[VAL_79]], %[[VAL_81]] : !llvm.ptr + // CHECK-NEXT: %[[VAL_80:.*]] = llvm.getelementptr inbounds %[[VAL_75]][0, 0, 0, %[[VAL_77]]] : (!llvm.ptr, i32) -> !llvm.ptr, i64 + // CHECK-NEXT: %[[VAL_81:.*]] = llvm.getelementptr %[[VAL_80]]{{\[}}%[[VAL_76]]] : (!llvm.ptr, i64) -> !llvm.ptr, i64 + // CHECK-NEXT: llvm.store %[[VAL_79]], %[[VAL_81]] : i64, !llvm.ptr // CHECK-DAG: %[[VAL_82:.*]] = llvm.mlir.constant(1 : i32) : i32 // CHECK-DAG: %[[VAL_83:.*]] = llvm.mlir.constant(1 : i32) : i32 // CHECK-NEXT: %[[VAL_84:.*]] = llvm.extractelement %[[VAL_70]]{{\[}}%[[VAL_83]] : i32] : vector<3xi64> - // CHECK-NEXT: %[[VAL_85:.*]] = llvm.getelementptr inbounds %[[VAL_75]][0, 0, 0, %[[VAL_82]]] : (!llvm.ptr)>)>>, i32) -> !llvm.ptr - // CHECK-NEXT: %[[VAL_86:.*]] = llvm.getelementptr %[[VAL_85]]{{\[}}%[[VAL_76]]] : (!llvm.ptr, i64) -> !llvm.ptr - // CHECK-NEXT: llvm.store %[[VAL_84]], %[[VAL_86]] : !llvm.ptr + // CHECK-NEXT: %[[VAL_85:.*]] = llvm.getelementptr inbounds %[[VAL_75]][0, 0, 0, %[[VAL_82]]] : (!llvm.ptr, i32) -> !llvm.ptr, i64 + // CHECK-NEXT: %[[VAL_86:.*]] = llvm.getelementptr %[[VAL_85]]{{\[}}%[[VAL_76]]] : (!llvm.ptr, i64) -> !llvm.ptr, i64 + // CHECK-NEXT: llvm.store %[[VAL_84]], %[[VAL_86]] : i64, !llvm.ptr // CHECK-DAG: %[[VAL_87:.*]] = llvm.mlir.constant(2 : i32) : i32 // CHECK-DAG: %[[VAL_88:.*]] = llvm.mlir.constant(2 : i32) : i32 // CHECK-NEXT: %[[VAL_89:.*]] = llvm.extractelement %[[VAL_70]]{{\[}}%[[VAL_88]] : i32] : vector<3xi64> - // CHECK-NEXT: %[[VAL_90:.*]] = llvm.getelementptr inbounds %[[VAL_75]][0, 0, 0, %[[VAL_87]]] : (!llvm.ptr)>)>>, i32) -> !llvm.ptr - // CHECK-NEXT: %[[VAL_91:.*]] = llvm.getelementptr %[[VAL_90]]{{\[}}%[[VAL_76]]] : (!llvm.ptr, i64) -> !llvm.ptr - // CHECK-NEXT: llvm.store %[[VAL_89]], %[[VAL_91]] : !llvm.ptr - // CHECK-NEXT: %[[VAL_92:.*]] = llvm.getelementptr %[[VAL_75]]{{\[}}%[[VAL_76]]] : (!llvm.ptr)>)>>, i64) -> !llvm.ptr)>)>> - // CHECK-NEXT: %[[VAL_93:.*]] = llvm.load %[[VAL_92]] : !llvm.ptr)>)>> + // CHECK-NEXT: %[[VAL_90:.*]] = llvm.getelementptr inbounds %[[VAL_75]][0, 0, 0, %[[VAL_87]]] : (!llvm.ptr, i32) -> !llvm.ptr, i64 + // CHECK-NEXT: %[[VAL_91:.*]] = llvm.getelementptr %[[VAL_90]]{{\[}}%[[VAL_76]]] : (!llvm.ptr, i64) -> !llvm.ptr, i64 + // CHECK-NEXT: llvm.store %[[VAL_89]], %[[VAL_91]] : i64, !llvm.ptr + // CHECK-NEXT: %[[VAL_92:.*]] = llvm.getelementptr %[[VAL_75]]{{\[}}%[[VAL_76]]] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::id.3", {{.*}}> + // CHECK-NEXT: %[[VAL_93:.*]] = llvm.load %[[VAL_92]] : !llvm.ptr -> !llvm.struct<"class.sycl::_V1::id.3", {{.*}}> // CHECK-NEXT: llvm.return %[[VAL_93]] : !llvm.struct<"class.sycl::_V1::id.3", (struct<"class.sycl::_V1::detail::array.3", (array<3 x i64>)>)> // CHECK-NEXT: } func.func @test_local_id() -> !sycl_id_3_ { @@ -164,8 +164,8 @@ module attributes {gpu.container_module} { // CHECK-LABEL: llvm.func @test_local_id_dim( // CHECK-SAME: %[[VAL_94:.*]]: i32) -> i64 { - // CHECK-NEXT: %[[VAL_95:.*]] = llvm.mlir.addressof @__spirv_BuiltInLocalInvocationId : !llvm.ptr> - // CHECK-NEXT: %[[VAL_96:.*]] = llvm.load %[[VAL_95]] : !llvm.ptr> + // CHECK-NEXT: %[[VAL_95:.*]] = llvm.mlir.addressof @__spirv_BuiltInLocalInvocationId : !llvm.ptr + // CHECK-NEXT: %[[VAL_96:.*]] = llvm.load %[[VAL_95]] : !llvm.ptr -> vector<3xi64> // CHECK-DAG: %[[VAL_97:.*]] = llvm.mlir.constant(dense<0> : vector<3xindex>) : vector<3xi64> // CHECK-DAG: %[[VAL_98:.*]] = llvm.mlir.constant(0 : i32) : i32 // CHECK-NEXT: %[[VAL_99:.*]] = llvm.extractelement %[[VAL_96]]{{\[}}%[[VAL_98]] : i32] : vector<3xi64> @@ -188,34 +188,34 @@ module attributes {gpu.container_module} { } // CHECK-LABEL: llvm.func @test_work_group_size() -> !llvm.struct<"class.sycl::_V1::range.3", (struct<"class.sycl::_V1::detail::array.3", (array<3 x i64>)>)> { - // CHECK-NEXT: %[[VAL_111:.*]] = llvm.mlir.addressof @__spirv_BuiltInWorkgroupSize : !llvm.ptr> - // CHECK-NEXT: %[[VAL_112:.*]] = llvm.load %[[VAL_111]] : !llvm.ptr> - // CHECK-NEXT: %[[VAL_113:.*]] = llvm.mlir.null : !llvm.ptr)>)>> + // CHECK-NEXT: %[[VAL_111:.*]] = llvm.mlir.addressof @__spirv_BuiltInWorkgroupSize : !llvm.ptr + // CHECK-NEXT: %[[VAL_112:.*]] = llvm.load %[[VAL_111]] : !llvm.ptr -> vector<3xi64> + // CHECK-NEXT: %[[VAL_113:.*]] = llvm.mlir.null : !llvm.ptr // CHECK-NEXT: %[[VAL_114:.*]] = llvm.mlir.constant(1 : index) : i64 - // CHECK-NEXT: %[[VAL_115:.*]] = llvm.getelementptr %[[VAL_113]]{{\[}}%[[VAL_114]]] : (!llvm.ptr)>)>>, i64) -> !llvm.ptr)>)>> - // CHECK-NEXT: %[[VAL_116:.*]] = llvm.ptrtoint %[[VAL_115]] : !llvm.ptr)>)>> to i64 - // CHECK-NEXT: %[[VAL_117:.*]] = llvm.alloca %[[VAL_116]] x !llvm.struct<"class.sycl::_V1::range.3", (struct<"class.sycl::_V1::detail::array.3", (array<3 x i64>)>)> : (i64) -> !llvm.ptr)>)>> + // CHECK-NEXT: %[[VAL_115:.*]] = llvm.getelementptr %[[VAL_113]]{{\[}}%[[VAL_114]]] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::range.3", {{.*}}> + // CHECK-NEXT: %[[VAL_116:.*]] = llvm.ptrtoint %[[VAL_115]] : !llvm.ptr to i64 + // CHECK-NEXT: %[[VAL_117:.*]] = llvm.alloca %[[VAL_116]] x !llvm.struct<"class.sycl::_V1::range.3", (struct<"class.sycl::_V1::detail::array.3", (array<3 x i64>)>)> : (i64) -> !llvm.ptr // CHECK-DAG: %[[VAL_118:.*]] = llvm.mlir.constant(0 : index) : i64 // CHECK-DAG: %[[VAL_119:.*]] = llvm.mlir.constant(0 : i32) : i32 // CHECK-DAG: %[[VAL_120:.*]] = llvm.mlir.constant(0 : i32) : i32 // CHECK-NEXT: %[[VAL_121:.*]] = llvm.extractelement %[[VAL_112]]{{\[}}%[[VAL_120]] : i32] : vector<3xi64> - // CHECK-NEXT: %[[VAL_122:.*]] = llvm.getelementptr inbounds %[[VAL_117]][0, 0, 0, %[[VAL_119]]] : (!llvm.ptr)>)>>, i32) -> !llvm.ptr - // CHECK-NEXT: %[[VAL_123:.*]] = llvm.getelementptr %[[VAL_122]]{{\[}}%[[VAL_118]]] : (!llvm.ptr, i64) -> !llvm.ptr - // CHECK-NEXT: llvm.store %[[VAL_121]], %[[VAL_123]] : !llvm.ptr + // CHECK-NEXT: %[[VAL_122:.*]] = llvm.getelementptr inbounds %[[VAL_117]][0, 0, 0, %[[VAL_119]]] : (!llvm.ptr, i32) -> !llvm.ptr, i64 + // CHECK-NEXT: %[[VAL_123:.*]] = llvm.getelementptr %[[VAL_122]]{{\[}}%[[VAL_118]]] : (!llvm.ptr, i64) -> !llvm.ptr, i64 + // CHECK-NEXT: llvm.store %[[VAL_121]], %[[VAL_123]] : i64, !llvm.ptr // CHECK-DAG: %[[VAL_124:.*]] = llvm.mlir.constant(1 : i32) : i32 // CHECK-DAG: %[[VAL_125:.*]] = llvm.mlir.constant(1 : i32) : i32 // CHECK-NEXT: %[[VAL_126:.*]] = llvm.extractelement %[[VAL_112]]{{\[}}%[[VAL_125]] : i32] : vector<3xi64> - // CHECK-NEXT: %[[VAL_127:.*]] = llvm.getelementptr inbounds %[[VAL_117]][0, 0, 0, %[[VAL_124]]] : (!llvm.ptr)>)>>, i32) -> !llvm.ptr - // CHECK-NEXT: %[[VAL_128:.*]] = llvm.getelementptr %[[VAL_127]]{{\[}}%[[VAL_118]]] : (!llvm.ptr, i64) -> !llvm.ptr - // CHECK-NEXT: llvm.store %[[VAL_126]], %[[VAL_128]] : !llvm.ptr + // CHECK-NEXT: %[[VAL_127:.*]] = llvm.getelementptr inbounds %[[VAL_117]][0, 0, 0, %[[VAL_124]]] : (!llvm.ptr, i32) -> !llvm.ptr, i64 + // CHECK-NEXT: %[[VAL_128:.*]] = llvm.getelementptr %[[VAL_127]]{{\[}}%[[VAL_118]]] : (!llvm.ptr, i64) -> !llvm.ptr, i64 + // CHECK-NEXT: llvm.store %[[VAL_126]], %[[VAL_128]] : i64, !llvm.ptr // CHECK-DAG: %[[VAL_129:.*]] = llvm.mlir.constant(2 : i32) : i32 // CHECK-DAG: %[[VAL_130:.*]] = llvm.mlir.constant(2 : i32) : i32 // CHECK-NEXT: %[[VAL_131:.*]] = llvm.extractelement %[[VAL_112]]{{\[}}%[[VAL_130]] : i32] : vector<3xi64> - // CHECK-NEXT: %[[VAL_132:.*]] = llvm.getelementptr inbounds %[[VAL_117]][0, 0, 0, %[[VAL_129]]] : (!llvm.ptr)>)>>, i32) -> !llvm.ptr - // CHECK-NEXT: %[[VAL_133:.*]] = llvm.getelementptr %[[VAL_132]]{{\[}}%[[VAL_118]]] : (!llvm.ptr, i64) -> !llvm.ptr - // CHECK-NEXT: llvm.store %[[VAL_131]], %[[VAL_133]] : !llvm.ptr - // CHECK-NEXT: %[[VAL_134:.*]] = llvm.getelementptr %[[VAL_117]]{{\[}}%[[VAL_118]]] : (!llvm.ptr)>)>>, i64) -> !llvm.ptr)>)>> - // CHECK-NEXT: %[[VAL_135:.*]] = llvm.load %[[VAL_134]] : !llvm.ptr)>)>> + // CHECK-NEXT: %[[VAL_132:.*]] = llvm.getelementptr inbounds %[[VAL_117]][0, 0, 0, %[[VAL_129]]] : (!llvm.ptr, i32) -> !llvm.ptr, i64 + // CHECK-NEXT: %[[VAL_133:.*]] = llvm.getelementptr %[[VAL_132]]{{\[}}%[[VAL_118]]] : (!llvm.ptr, i64) -> !llvm.ptr, i64 + // CHECK-NEXT: llvm.store %[[VAL_131]], %[[VAL_133]] : i64, !llvm.ptr + // CHECK-NEXT: %[[VAL_134:.*]] = llvm.getelementptr %[[VAL_117]]{{\[}}%[[VAL_118]]] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::range.3", {{.*}}> + // CHECK-NEXT: %[[VAL_135:.*]] = llvm.load %[[VAL_134]] : !llvm.ptr -> !llvm.struct<"class.sycl::_V1::range.3", {{.*}}> // CHECK-NEXT: llvm.return %[[VAL_135]] : !llvm.struct<"class.sycl::_V1::range.3", (struct<"class.sycl::_V1::detail::array.3", (array<3 x i64>)>)> // CHECK-NEXT: } func.func @test_work_group_size() -> !sycl_range_3_ { @@ -225,8 +225,8 @@ module attributes {gpu.container_module} { // CHECK-LABEL: llvm.func @test_work_group_size_dim( // CHECK-SAME: %[[VAL_136:.*]]: i32) -> i64 { - // CHECK-NEXT: %[[VAL_137:.*]] = llvm.mlir.addressof @__spirv_BuiltInWorkgroupSize : !llvm.ptr> - // CHECK-NEXT: %[[VAL_138:.*]] = llvm.load %[[VAL_137]] : !llvm.ptr> + // CHECK-NEXT: %[[VAL_137:.*]] = llvm.mlir.addressof @__spirv_BuiltInWorkgroupSize : !llvm.ptr + // CHECK-NEXT: %[[VAL_138:.*]] = llvm.load %[[VAL_137]] : !llvm.ptr -> vector<3xi64> // CHECK-DAG: %[[VAL_139:.*]] = llvm.mlir.constant(dense<0> : vector<3xindex>) : vector<3xi64> // CHECK-DAG: %[[VAL_140:.*]] = llvm.mlir.constant(0 : i32) : i32 // CHECK-NEXT: %[[VAL_141:.*]] = llvm.extractelement %[[VAL_138]]{{\[}}%[[VAL_140]] : i32] : vector<3xi64> @@ -249,22 +249,22 @@ module attributes {gpu.container_module} { } // CHECK-LABEL: llvm.func @test_work_group_id() -> !llvm.struct<"class.sycl::_V1::id.1", (struct<"class.sycl::_V1::detail::array.1", (array<1 x i64>)>)> { - // CHECK-NEXT: %[[VAL_153:.*]] = llvm.mlir.addressof @__spirv_BuiltInWorkgroupId : !llvm.ptr> - // CHECK-NEXT: %[[VAL_154:.*]] = llvm.load %[[VAL_153]] : !llvm.ptr> - // CHECK-NEXT: %[[VAL_155:.*]] = llvm.mlir.null : !llvm.ptr)>)>> + // CHECK-NEXT: %[[VAL_153:.*]] = llvm.mlir.addressof @__spirv_BuiltInWorkgroupId : !llvm.ptr + // CHECK-NEXT: %[[VAL_154:.*]] = llvm.load %[[VAL_153]] : !llvm.ptr -> vector<3xi64> + // CHECK-NEXT: %[[VAL_155:.*]] = llvm.mlir.null : !llvm.ptr // CHECK-NEXT: %[[VAL_156:.*]] = llvm.mlir.constant(1 : index) : i64 - // CHECK-NEXT: %[[VAL_157:.*]] = llvm.getelementptr %[[VAL_155]]{{\[}}%[[VAL_156]]] : (!llvm.ptr)>)>>, i64) -> !llvm.ptr)>)>> - // CHECK-NEXT: %[[VAL_158:.*]] = llvm.ptrtoint %[[VAL_157]] : !llvm.ptr)>)>> to i64 - // CHECK-NEXT: %[[VAL_159:.*]] = llvm.alloca %[[VAL_158]] x !llvm.struct<"class.sycl::_V1::id.1", (struct<"class.sycl::_V1::detail::array.1", (array<1 x i64>)>)> : (i64) -> !llvm.ptr)>)>> + // CHECK-NEXT: %[[VAL_157:.*]] = llvm.getelementptr %[[VAL_155]]{{\[}}%[[VAL_156]]] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::id.1", {{.*}}> + // CHECK-NEXT: %[[VAL_158:.*]] = llvm.ptrtoint %[[VAL_157]] : !llvm.ptr to i64 + // CHECK-NEXT: %[[VAL_159:.*]] = llvm.alloca %[[VAL_158]] x !llvm.struct<"class.sycl::_V1::id.1", (struct<"class.sycl::_V1::detail::array.1", (array<1 x i64>)>)> : (i64) -> !llvm.ptr // CHECK-DAG: %[[VAL_160:.*]] = llvm.mlir.constant(0 : index) : i64 // CHECK-DAG: %[[VAL_161:.*]] = llvm.mlir.constant(0 : i32) : i32 // CHECK-DAG: %[[VAL_162:.*]] = llvm.mlir.constant(0 : i32) : i32 // CHECK-NEXT: %[[VAL_163:.*]] = llvm.extractelement %[[VAL_154]]{{\[}}%[[VAL_162]] : i32] : vector<3xi64> - // CHECK-NEXT: %[[VAL_164:.*]] = llvm.getelementptr inbounds %[[VAL_159]][0, 0, 0, %[[VAL_161]]] : (!llvm.ptr)>)>>, i32) -> !llvm.ptr - // CHECK-NEXT: %[[VAL_165:.*]] = llvm.getelementptr %[[VAL_164]]{{\[}}%[[VAL_160]]] : (!llvm.ptr, i64) -> !llvm.ptr - // CHECK-NEXT: llvm.store %[[VAL_163]], %[[VAL_165]] : !llvm.ptr - // CHECK-NEXT: %[[VAL_166:.*]] = llvm.getelementptr %[[VAL_159]]{{\[}}%[[VAL_160]]] : (!llvm.ptr)>)>>, i64) -> !llvm.ptr)>)>> - // CHECK-NEXT: %[[VAL_167:.*]] = llvm.load %[[VAL_166]] : !llvm.ptr)>)>> + // CHECK-NEXT: %[[VAL_164:.*]] = llvm.getelementptr inbounds %[[VAL_159]][0, 0, 0, %[[VAL_161]]] : (!llvm.ptr, i32) -> !llvm.ptr, i64 + // CHECK-NEXT: %[[VAL_165:.*]] = llvm.getelementptr %[[VAL_164]]{{\[}}%[[VAL_160]]] : (!llvm.ptr, i64) -> !llvm.ptr, i64 + // CHECK-NEXT: llvm.store %[[VAL_163]], %[[VAL_165]] : i64, !llvm.ptr + // CHECK-NEXT: %[[VAL_166:.*]] = llvm.getelementptr %[[VAL_159]]{{\[}}%[[VAL_160]]] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::id.1", {{.*}}> + // CHECK-NEXT: %[[VAL_167:.*]] = llvm.load %[[VAL_166]] : !llvm.ptr -> !llvm.struct<"class.sycl::_V1::id.1", {{.*}}> // CHECK-NEXT: llvm.return %[[VAL_167]] : !llvm.struct<"class.sycl::_V1::id.1", (struct<"class.sycl::_V1::detail::array.1", (array<1 x i64>)>)> // CHECK-NEXT: } func.func @test_work_group_id() -> !sycl_id_1_ { @@ -274,8 +274,8 @@ module attributes {gpu.container_module} { // CHECK-LABEL: llvm.func @test_work_group_id_dim( // CHECK-SAME: %[[VAL_168:.*]]: i32) -> i64 { - // CHECK-NEXT: %[[VAL_169:.*]] = llvm.mlir.addressof @__spirv_BuiltInWorkgroupId : !llvm.ptr> - // CHECK-NEXT: %[[VAL_170:.*]] = llvm.load %[[VAL_169]] : !llvm.ptr> + // CHECK-NEXT: %[[VAL_169:.*]] = llvm.mlir.addressof @__spirv_BuiltInWorkgroupId : !llvm.ptr + // CHECK-NEXT: %[[VAL_170:.*]] = llvm.load %[[VAL_169]] : !llvm.ptr -> vector<3xi64> // CHECK-DAG: %[[VAL_171:.*]] = llvm.mlir.constant(dense<0> : vector<3xindex>) : vector<3xi64> // CHECK-DAG: %[[VAL_172:.*]] = llvm.mlir.constant(0 : i32) : i32 // CHECK-NEXT: %[[VAL_173:.*]] = llvm.extractelement %[[VAL_170]]{{\[}}%[[VAL_172]] : i32] : vector<3xi64> @@ -298,8 +298,8 @@ module attributes {gpu.container_module} { } // CHECK-LABEL: llvm.func @test_num_sub_groups() -> i32 { - // CHECK-NEXT: %[[VAL_200:.*]] = llvm.mlir.addressof @__spirv_BuiltInNumSubgroups : !llvm.ptr - // CHECK-NEXT: %[[VAL_201:.*]] = llvm.load %[[VAL_200]] : !llvm.ptr + // CHECK-NEXT: %[[VAL_200:.*]] = llvm.mlir.addressof @__spirv_BuiltInNumSubgroups : !llvm.ptr + // CHECK-NEXT: %[[VAL_201:.*]] = llvm.load %[[VAL_200]] : !llvm.ptr -> i64 // CHECK-NEXT: %[[VAL_202:.*]] = llvm.trunc %[[VAL_201]] : i64 to i32 // CHECK-NEXT: llvm.return %[[VAL_202]] : i32 // CHECK-NEXT: } @@ -309,8 +309,8 @@ module attributes {gpu.container_module} { } // CHECK-LABEL: llvm.func @test_sub_group_size() -> i32 { - // CHECK-NEXT: %[[VAL_203:.*]] = llvm.mlir.addressof @__spirv_BuiltInSubgroupSize : !llvm.ptr - // CHECK-NEXT: %[[VAL_204:.*]] = llvm.load %[[VAL_203]] : !llvm.ptr + // CHECK-NEXT: %[[VAL_203:.*]] = llvm.mlir.addressof @__spirv_BuiltInSubgroupSize : !llvm.ptr + // CHECK-NEXT: %[[VAL_204:.*]] = llvm.load %[[VAL_203]] : !llvm.ptr -> i64 // CHECK-NEXT: %[[VAL_205:.*]] = llvm.trunc %[[VAL_204]] : i64 to i32 // CHECK-NEXT: llvm.return %[[VAL_205]] : i32 // CHECK-NEXT: } @@ -320,8 +320,8 @@ module attributes {gpu.container_module} { } // CHECK-LABEL: llvm.func @test_sub_group_id() -> i32 { - // CHECK-NEXT: %[[VAL_206:.*]] = llvm.mlir.addressof @__spirv_BuiltInSubgroupId : !llvm.ptr - // CHECK-NEXT: %[[VAL_207:.*]] = llvm.load %[[VAL_206]] : !llvm.ptr + // CHECK-NEXT: %[[VAL_206:.*]] = llvm.mlir.addressof @__spirv_BuiltInSubgroupId : !llvm.ptr + // CHECK-NEXT: %[[VAL_207:.*]] = llvm.load %[[VAL_206]] : !llvm.ptr -> i64 // CHECK-NEXT: %[[VAL_208:.*]] = llvm.trunc %[[VAL_207]] : i64 to i32 // CHECK-NEXT: llvm.return %[[VAL_208]] : i32 // CHECK-NEXT: } @@ -331,22 +331,22 @@ module attributes {gpu.container_module} { } // CHECK-LABEL: llvm.func @test_global_offset() -> !llvm.struct<"class.sycl::_V1::id.1", (struct<"class.sycl::_V1::detail::array.1", (array<1 x i64>)>)> { - // CHECK-NEXT: %[[VAL_194:.*]] = llvm.mlir.addressof @__spirv_BuiltInGlobalOffset : !llvm.ptr> - // CHECK-NEXT: %[[VAL_195:.*]] = llvm.load %[[VAL_194]] : !llvm.ptr> - // CHECK-NEXT: %[[VAL_196:.*]] = llvm.mlir.null : !llvm.ptr)>)>> + // CHECK-NEXT: %[[VAL_194:.*]] = llvm.mlir.addressof @__spirv_BuiltInGlobalOffset : !llvm.ptr + // CHECK-NEXT: %[[VAL_195:.*]] = llvm.load %[[VAL_194]] : !llvm.ptr -> vector<3xi64> + // CHECK-NEXT: %[[VAL_196:.*]] = llvm.mlir.null : !llvm.ptr // CHECK-NEXT: %[[VAL_197:.*]] = llvm.mlir.constant(1 : index) : i64 - // CHECK-NEXT: %[[VAL_198:.*]] = llvm.getelementptr %[[VAL_196]]{{\[}}%[[VAL_197]]] : (!llvm.ptr)>)>>, i64) -> !llvm.ptr)>)>> - // CHECK-NEXT: %[[VAL_199:.*]] = llvm.ptrtoint %[[VAL_198]] : !llvm.ptr)>)>> to i64 - // CHECK-NEXT: %[[VAL_200:.*]] = llvm.alloca %[[VAL_199]] x !llvm.struct<"class.sycl::_V1::id.1", (struct<"class.sycl::_V1::detail::array.1", (array<1 x i64>)>)> : (i64) -> !llvm.ptr)>)>> + // CHECK-NEXT: %[[VAL_198:.*]] = llvm.getelementptr %[[VAL_196]]{{\[}}%[[VAL_197]]] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::id.1", {{.*}}> + // CHECK-NEXT: %[[VAL_199:.*]] = llvm.ptrtoint %[[VAL_198]] : !llvm.ptr to i64 + // CHECK-NEXT: %[[VAL_200:.*]] = llvm.alloca %[[VAL_199]] x !llvm.struct<"class.sycl::_V1::id.1", (struct<"class.sycl::_V1::detail::array.1", (array<1 x i64>)>)> : (i64) -> !llvm.ptr // CHECK-DAG: %[[VAL_201:.*]] = llvm.mlir.constant(0 : index) : i64 // CHECK-DAG: %[[VAL_202:.*]] = llvm.mlir.constant(0 : i32) : i32 // CHECK-DAG: %[[VAL_203:.*]] = llvm.mlir.constant(0 : i32) : i32 // CHECK-NEXT: %[[VAL_204:.*]] = llvm.extractelement %[[VAL_195]]{{\[}}%[[VAL_203]] : i32] : vector<3xi64> - // CHECK-NEXT: %[[VAL_205:.*]] = llvm.getelementptr inbounds %[[VAL_200]][0, 0, 0, %[[VAL_202]]] : (!llvm.ptr)>)>>, i32) -> !llvm.ptr - // CHECK-NEXT: %[[VAL_206:.*]] = llvm.getelementptr %[[VAL_205]]{{\[}}%[[VAL_201]]] : (!llvm.ptr, i64) -> !llvm.ptr - // CHECK-NEXT: llvm.store %[[VAL_204]], %[[VAL_206]] : !llvm.ptr - // CHECK-NEXT: %[[VAL_207:.*]] = llvm.getelementptr %[[VAL_200]]{{\[}}%[[VAL_201]]] : (!llvm.ptr)>)>>, i64) -> !llvm.ptr)>)>> - // CHECK-NEXT: %[[VAL_208:.*]] = llvm.load %[[VAL_207]] : !llvm.ptr)>)>> + // CHECK-NEXT: %[[VAL_205:.*]] = llvm.getelementptr inbounds %[[VAL_200]][0, 0, 0, %[[VAL_202]]] : (!llvm.ptr, i32) -> !llvm.ptr, i64 + // CHECK-NEXT: %[[VAL_206:.*]] = llvm.getelementptr %[[VAL_205]]{{\[}}%[[VAL_201]]] : (!llvm.ptr, i64) -> !llvm.ptr, i64 + // CHECK-NEXT: llvm.store %[[VAL_204]], %[[VAL_206]] : i64, !llvm.ptr + // CHECK-NEXT: %[[VAL_207:.*]] = llvm.getelementptr %[[VAL_200]]{{\[}}%[[VAL_201]]] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::id.1", {{.*}}> + // CHECK-NEXT: %[[VAL_208:.*]] = llvm.load %[[VAL_207]] : !llvm.ptr -> !llvm.struct<"class.sycl::_V1::id.1", {{.*}}> // CHECK-NEXT: llvm.return %[[VAL_208]] : !llvm.struct<"class.sycl::_V1::id.1", (struct<"class.sycl::_V1::detail::array.1", (array<1 x i64>)>)> // CHECK-NEXT: } func.func @test_global_offset() -> !sycl_id_1_ { @@ -356,8 +356,8 @@ module attributes {gpu.container_module} { // CHECK-LABEL: llvm.func @test_global_offset_dim( // CHECK-SAME: %[[VAL_222:.*]]: i32) -> i64 { - // CHECK-NEXT: %[[VAL_223:.*]] = llvm.mlir.addressof @__spirv_BuiltInGlobalOffset : !llvm.ptr> - // CHECK-NEXT: %[[VAL_224:.*]] = llvm.load %[[VAL_223]] : !llvm.ptr> + // CHECK-NEXT: %[[VAL_223:.*]] = llvm.mlir.addressof @__spirv_BuiltInGlobalOffset : !llvm.ptr + // CHECK-NEXT: %[[VAL_224:.*]] = llvm.load %[[VAL_223]] : !llvm.ptr -> vector<3xi64> // CHECK-DAG: %[[VAL_225:.*]] = llvm.mlir.constant(dense<0> : vector<3xindex>) : vector<3xi64> // CHECK-DAG: %[[VAL_226:.*]] = llvm.mlir.constant(0 : i32) : i32 // CHECK-NEXT: %[[VAL_227:.*]] = llvm.extractelement %[[VAL_224]]{{\[}}%[[VAL_226]] : i32] : vector<3xi64> @@ -380,28 +380,28 @@ module attributes {gpu.container_module} { } // CHECK-LABEL: llvm.func @test_num_work_groups() -> !llvm.struct<"class.sycl::_V1::range.2", (struct<"class.sycl::_V1::detail::array.2", (array<2 x i64>)>)> { - // CHECK-NEXT: %[[VAL_226:.*]] = llvm.mlir.addressof @__spirv_BuiltInNumWorkgroups : !llvm.ptr> - // CHECK-NEXT: %[[VAL_227:.*]] = llvm.load %[[VAL_226]] : !llvm.ptr> - // CHECK-NEXT: %[[VAL_228:.*]] = llvm.mlir.null : !llvm.ptr)>)>> + // CHECK-NEXT: %[[VAL_226:.*]] = llvm.mlir.addressof @__spirv_BuiltInNumWorkgroups : !llvm.ptr + // CHECK-NEXT: %[[VAL_227:.*]] = llvm.load %[[VAL_226]] : !llvm.ptr -> vector<3xi64> + // CHECK-NEXT: %[[VAL_228:.*]] = llvm.mlir.null : !llvm.ptr // CHECK-NEXT: %[[VAL_229:.*]] = llvm.mlir.constant(1 : index) : i64 - // CHECK-NEXT: %[[VAL_230:.*]] = llvm.getelementptr %[[VAL_228]]{{\[}}%[[VAL_229]]] : (!llvm.ptr)>)>>, i64) -> !llvm.ptr)>)>> - // CHECK-NEXT: %[[VAL_231:.*]] = llvm.ptrtoint %[[VAL_230]] : !llvm.ptr)>)>> to i64 - // CHECK-NEXT: %[[VAL_232:.*]] = llvm.alloca %[[VAL_231]] x !llvm.struct<"class.sycl::_V1::range.2", (struct<"class.sycl::_V1::detail::array.2", (array<2 x i64>)>)> : (i64) -> !llvm.ptr)>)>> + // CHECK-NEXT: %[[VAL_230:.*]] = llvm.getelementptr %[[VAL_228]]{{\[}}%[[VAL_229]]] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::range.2", {{.*}}> + // CHECK-NEXT: %[[VAL_231:.*]] = llvm.ptrtoint %[[VAL_230]] : !llvm.ptr to i64 + // CHECK-NEXT: %[[VAL_232:.*]] = llvm.alloca %[[VAL_231]] x !llvm.struct<"class.sycl::_V1::range.2", (struct<"class.sycl::_V1::detail::array.2", (array<2 x i64>)>)> : (i64) -> !llvm.ptr // CHECK-DAG: %[[VAL_233:.*]] = llvm.mlir.constant(0 : index) : i64 // CHECK-DAG: %[[VAL_234:.*]] = llvm.mlir.constant(0 : i32) : i32 // CHECK-DAG: %[[VAL_235:.*]] = llvm.mlir.constant(0 : i32) : i32 // CHECK-NEXT: %[[VAL_236:.*]] = llvm.extractelement %[[VAL_227]]{{\[}}%[[VAL_235]] : i32] : vector<3xi64> - // CHECK-NEXT: %[[VAL_237:.*]] = llvm.getelementptr inbounds %[[VAL_232]][0, 0, 0, %[[VAL_234]]] : (!llvm.ptr)>)>>, i32) -> !llvm.ptr - // CHECK-NEXT: %[[VAL_238:.*]] = llvm.getelementptr %[[VAL_237]]{{\[}}%[[VAL_233]]] : (!llvm.ptr, i64) -> !llvm.ptr - // CHECK-NEXT: llvm.store %[[VAL_236]], %[[VAL_238]] : !llvm.ptr + // CHECK-NEXT: %[[VAL_237:.*]] = llvm.getelementptr inbounds %[[VAL_232]][0, 0, 0, %[[VAL_234]]] : (!llvm.ptr, i32) -> !llvm.ptr, i64 + // CHECK-NEXT: %[[VAL_238:.*]] = llvm.getelementptr %[[VAL_237]]{{\[}}%[[VAL_233]]] : (!llvm.ptr, i64) -> !llvm.ptr, i64 + // CHECK-NEXT: llvm.store %[[VAL_236]], %[[VAL_238]] : i64, !llvm.ptr // CHECK-DAG: %[[VAL_239:.*]] = llvm.mlir.constant(1 : i32) : i32 // CHECK-DAG: %[[VAL_240:.*]] = llvm.mlir.constant(1 : i32) : i32 // CHECK-NEXT: %[[VAL_241:.*]] = llvm.extractelement %[[VAL_227]]{{\[}}%[[VAL_240]] : i32] : vector<3xi64> - // CHECK-NEXT: %[[VAL_242:.*]] = llvm.getelementptr inbounds %[[VAL_232]][0, 0, 0, %[[VAL_239]]] : (!llvm.ptr)>)>>, i32) -> !llvm.ptr - // CHECK-NEXT: %[[VAL_243:.*]] = llvm.getelementptr %[[VAL_242]]{{\[}}%[[VAL_233]]] : (!llvm.ptr, i64) -> !llvm.ptr - // CHECK-NEXT: llvm.store %[[VAL_241]], %[[VAL_243]] : !llvm.ptr - // CHECK-NEXT: %[[VAL_244:.*]] = llvm.getelementptr %[[VAL_232]]{{\[}}%[[VAL_233]]] : (!llvm.ptr)>)>>, i64) -> !llvm.ptr)>)>> - // CHECK-NEXT: %[[VAL_245:.*]] = llvm.load %[[VAL_244]] : !llvm.ptr)>)>> + // CHECK-NEXT: %[[VAL_242:.*]] = llvm.getelementptr inbounds %[[VAL_232]][0, 0, 0, %[[VAL_239]]] : (!llvm.ptr, i32) -> !llvm.ptr, i64 + // CHECK-NEXT: %[[VAL_243:.*]] = llvm.getelementptr %[[VAL_242]]{{\[}}%[[VAL_233]]] : (!llvm.ptr, i64) -> !llvm.ptr, i64 + // CHECK-NEXT: llvm.store %[[VAL_241]], %[[VAL_243]] : i64, !llvm.ptr + // CHECK-NEXT: %[[VAL_244:.*]] = llvm.getelementptr %[[VAL_232]]{{\[}}%[[VAL_233]]] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::range.2", {{.*}}> + // CHECK-NEXT: %[[VAL_245:.*]] = llvm.load %[[VAL_244]] : !llvm.ptr -> !llvm.struct<"class.sycl::_V1::range.2", {{.*}}> // CHECK-NEXT: llvm.return %[[VAL_245]] : !llvm.struct<"class.sycl::_V1::range.2", (struct<"class.sycl::_V1::detail::array.2", (array<2 x i64>)>)> // CHECK-NEXT: } func.func @test_num_work_groups() -> !sycl_range_2_ { @@ -411,8 +411,8 @@ module attributes {gpu.container_module} { // CHECK-LABEL: llvm.func @test_num_work_groups_dim( // CHECK-SAME: %[[VAL_246:.*]]: i32) -> i64 { - // CHECK-NEXT: %[[VAL_247:.*]] = llvm.mlir.addressof @__spirv_BuiltInNumWorkgroups : !llvm.ptr> - // CHECK-NEXT: %[[VAL_248:.*]] = llvm.load %[[VAL_247]] : !llvm.ptr> + // CHECK-NEXT: %[[VAL_247:.*]] = llvm.mlir.addressof @__spirv_BuiltInNumWorkgroups : !llvm.ptr + // CHECK-NEXT: %[[VAL_248:.*]] = llvm.load %[[VAL_247]] : !llvm.ptr -> vector<3xi64> // CHECK-DAG: %[[VAL_249:.*]] = llvm.mlir.constant(dense<0> : vector<3xindex>) : vector<3xi64> // CHECK-DAG: %[[VAL_250:.*]] = llvm.mlir.constant(0 : i32) : i32 // CHECK-NEXT: %[[VAL_251:.*]] = llvm.extractelement %[[VAL_248]]{{\[}}%[[VAL_250]] : i32] : vector<3xi64> @@ -435,8 +435,8 @@ module attributes {gpu.container_module} { } // CHECK-LABEL: llvm.func @test_sub_group_max_size() -> i32 { - // CHECK-NEXT: %[[VAL_273:.*]] = llvm.mlir.addressof @__spirv_BuiltInSubgroupMaxSize : !llvm.ptr - // CHECK-NEXT: %[[VAL_274:.*]] = llvm.load %[[VAL_273]] : !llvm.ptr + // CHECK-NEXT: %[[VAL_273:.*]] = llvm.mlir.addressof @__spirv_BuiltInSubgroupMaxSize : !llvm.ptr + // CHECK-NEXT: %[[VAL_274:.*]] = llvm.load %[[VAL_273]] : !llvm.ptr -> i64 // CHECK-NEXT: %[[VAL_275:.*]] = llvm.trunc %[[VAL_274]] : i64 to i32 // CHECK-NEXT: llvm.return %[[VAL_275]] : i32 func.func @test_sub_group_max_size() -> i32 { @@ -445,8 +445,8 @@ module attributes {gpu.container_module} { } // CHECK-LABEL: llvm.func @test_sub_group_local_id() -> i32 { - // CHECK-NEXT: %[[VAL_276:.*]] = llvm.mlir.addressof @__spirv_BuiltInSubgroupLocalInvocationId : !llvm.ptr - // CHECK-NEXT: %[[VAL_277:.*]] = llvm.load %[[VAL_276]] : !llvm.ptr + // CHECK-NEXT: %[[VAL_276:.*]] = llvm.mlir.addressof @__spirv_BuiltInSubgroupLocalInvocationId : !llvm.ptr + // CHECK-NEXT: %[[VAL_277:.*]] = llvm.load %[[VAL_276]] : !llvm.ptr -> i64 // CHECK-NEXT: %[[VAL_278:.*]] = llvm.trunc %[[VAL_277]] : i64 to i32 // CHECK-NEXT: llvm.return %[[VAL_278]] : i32 // CHECK-NEXT: } From 530ea97a48eec191feade9db8f56ee6aecd9cb3b Mon Sep 17 00:00:00 2001 From: Lukas Sommer Date: Thu, 30 Mar 2023 15:16:23 +0100 Subject: [PATCH 05/11] Handle sycl.cast for opaque pointer case Signed-off-by: Lukas Sommer --- .../lib/Conversion/SYCLToLLVM/SYCLToLLVM.cpp | 18 +++- .../sycl-cast-to-llvm-typed-pointer.mlir | 92 +++++++++++++++++++ .../SYCLToLLVM/sycl-cast-to-llvm.mlir | 40 ++++---- 3 files changed, 124 insertions(+), 26 deletions(-) create mode 100644 mlir-sycl/test/Conversion/SYCLToLLVM/sycl-cast-to-llvm-typed-pointer.mlir diff --git a/mlir-sycl/lib/Conversion/SYCLToLLVM/SYCLToLLVM.cpp b/mlir-sycl/lib/Conversion/SYCLToLLVM/SYCLToLLVM.cpp index 09a0a26e042f6..57badfae4bb17 100644 --- a/mlir-sycl/lib/Conversion/SYCLToLLVM/SYCLToLLVM.cpp +++ b/mlir-sycl/lib/Conversion/SYCLToLLVM/SYCLToLLVM.cpp @@ -945,6 +945,13 @@ class CastPattern final : public ConvertOpToLLVMPattern { !isConvertibleAndHasIdentityMaps(resType)) return failure(); + if (getTypeConverter()->useOpaquePointers()) { + // Bitcasts with opaque pointers are just no-ops, so no need to create + // them here. + rewriter.replaceOp(op, opAdaptor.getSource()); + return success(); + } + // Cast the source memref descriptor's allocate & aligned pointers to the // type of those pointers in the results memref. Location loc = op.getLoc(); @@ -995,6 +1002,13 @@ class BarePtrCastPattern final : public ConvertOpToLLVMPattern { !convSrcType || !convResType) return failure(); + if (getTypeConverter()->useOpaquePointers()) { + // Bitcasts with opaque pointers are just no-ops, so no need to create + // them here. + rewriter.replaceOp(op, opAdaptor.getSource()); + return success(); + } + Location loc = op.getLoc(); LLVMBuilder builder(rewriter, loc); rewriter.replaceOpWithNewOp(op, convResType, @@ -2305,8 +2319,8 @@ void ConvertSYCLToLLVMPass::runOnOperation() { populateReturnOpTypeConversionPattern(patterns, converter); populateCallOpTypeConversionPattern(patterns, converter); populateAnyFunctionOpInterfaceTypeConversionPattern(patterns, converter); - polygeist::populateBareMemRefToLLVMConversionPatterns( - converter, patterns, useOpaquePointers); + polygeist::populateBareMemRefToLLVMConversionPatterns(converter, patterns, + useOpaquePointers); populateSYCLToSPIRVConversionPatterns(converter, patterns); populateSYCLToLLVMConversionPatterns(converter, patterns); diff --git a/mlir-sycl/test/Conversion/SYCLToLLVM/sycl-cast-to-llvm-typed-pointer.mlir b/mlir-sycl/test/Conversion/SYCLToLLVM/sycl-cast-to-llvm-typed-pointer.mlir new file mode 100644 index 0000000000000..4a3f35728aa2b --- /dev/null +++ b/mlir-sycl/test/Conversion/SYCLToLLVM/sycl-cast-to-llvm-typed-pointer.mlir @@ -0,0 +1,92 @@ +// RUN: sycl-mlir-opt -split-input-file -convert-sycl-to-llvm='use-opaque-pointers=0' -verify-diagnostics %s | FileCheck %s + +!sycl_array_1_ = !sycl.array<[1], (memref<1xi64>)> +!sycl_range_1_ = !sycl.range<[1], (!sycl_array_1_)> +func.func @cast_sycl_range_to_array(%arg0: memref) -> memref { + // CHECK-LABEL: llvm.func @cast_sycl_range_to_array( + // CHECK-SAME: [[SRC:%.*]]: !llvm.ptr<[[RANGE1:.*]]>) -> !llvm.ptr<[[ARRAY1:.*]]> + // CHECK-NEXT: [[RES:%.*]] = llvm.bitcast [[SRC]] : !llvm.ptr<[[RANGE1]]> to !llvm.ptr<[[ARRAY1]]> + // CHECK-NEXT: llvm.return [[RES]] : !llvm.ptr<[[ARRAY1]]> + + %0 = "sycl.cast"(%arg0) : (memref) -> memref + func.return %0 : memref +} + +// ----- + +!sycl_array_1_ = !sycl.array<[1], (memref<1xi64>)> +!sycl_id_1_ = !sycl.id<[1], (!sycl_array_1_)> +func.func @cast_sycl_id_to_array(%arg0: memref) -> memref { + // CHECK-LABEL: llvm.func @cast_sycl_id_to_array( + // CHECK-SAME: [[SRC:%.*]]: !llvm.ptr<[[ID1:.*]]>) -> !llvm.ptr<[[ARRAY1]]> + // CHECK-NEXT: [[RES:%.*]] = llvm.bitcast [[SRC]] : !llvm.ptr<[[ID1]]> to !llvm.ptr<[[ARRAY1]]> + // CHECK-NEXT: llvm.return [[RES]] : !llvm.ptr<[[ARRAY1]]> + + %0 = "sycl.cast"(%arg0) : (memref) -> memref + func.return %0: memref +} + +// ----- + +!sycl_id_1_ = !sycl.id<[1], (!sycl.array<[1], (memref<1xi64, 4>)>)> +!sycl_range_1_ = !sycl.range<[1], (!sycl.array<[1], (memref<1xi64, 4>)>)> +!sycl_accessor_1_i32_rw_gb = !sycl.accessor<[1, i32, read_write, global_buffer], (!sycl.accessor_impl_device<[1], (!sycl_id_1_, !sycl_range_1_, !sycl_range_1_)>, !llvm.struct<(ptr)>)> +func.func @cast_sycl_accessor_to_accessor_common(%arg0: memref) -> memref { + // CHECK-LABEL: llvm.func @cast_sycl_accessor_to_accessor_common( + // CHECK-SAME: [[SRC:%.*]]: !llvm.ptr<[[ACC1:.*]]>) -> !llvm.ptr<[[COMMON:.*]]> + // CHECK-NEXT: [[RES:%.*]] = llvm.bitcast [[SRC]] : !llvm.ptr<[[ACC1]]> to !llvm.ptr<[[COMMON]]> + // CHECK-NEXT: llvm.return [[RES]] : !llvm.ptr<[[COMMON]]> + + %0 = "sycl.cast"(%arg0) : (memref) -> memref + func.return %0: memref +} + +!sycl_LocalAccessorBaseDevice_1_ = !sycl.LocalAccessorBaseDevice<[1], (!sycl_range_1_, !sycl_range_1_, !sycl_id_1_)> +!sycl_local_accessor_base_1_i32_rw = !sycl.local_accessor_base<[1, i32, read_write], (!sycl_LocalAccessorBaseDevice_1_, memref)> +func.func @cast_sycl_accessor_to_local_accessor_base(%arg0: memref) -> memref { + // CHECK-LABEL: llvm.func @cast_sycl_accessor_to_local_accessor_base( + // CHECK-SAME: [[SRC:%.*]]: !llvm.ptr<[[ACC1]]>) -> !llvm.ptr<[[LOCALBASE:.*]]> + // CHECK-NEXT: [[RES:%.*]] = llvm.bitcast [[SRC]] : !llvm.ptr<[[ACC1]]> to !llvm.ptr<[[LOCALBASE]]> + // CHECK-NEXT: llvm.return [[RES]] : !llvm.ptr<[[LOCALBASE]]> + + %0 = "sycl.cast"(%arg0) : (memref) -> memref + func.return %0: memref +} + +func.func @cast_sycl_accessor_to_owner_less_base(%arg0: memref) -> memref { + // CHECK-LABEL: llvm.func @cast_sycl_accessor_to_owner_less_base( + // CHECK-SAME: [[SRC:%.*]]: !llvm.ptr<[[ACC1]]>) -> !llvm.ptr<[[OWNERLESSBASE:.*]]> + // CHECK-NEXT: [[RES:%.*]] = llvm.bitcast [[SRC]] : !llvm.ptr<[[ACC1]]> to !llvm.ptr<[[OWNERLESSBASE]]> + // CHECK-NEXT: llvm.return [[RES]] : !llvm.ptr<[[OWNERLESSBASE]]> + + %0 = "sycl.cast"(%arg0) : (memref) -> memref + func.return %0: memref +} + +// ----- + +!sycl_id_1_ = !sycl.id<[1], (!sycl.array<[1], (memref<1xi64, 4>)>)> +!sycl_range_1_ = !sycl.range<[1], (!sycl.array<[1], (memref<1xi64, 4>)>)> +!sycl_LocalAccessorBaseDevice_1_ = !sycl.LocalAccessorBaseDevice<[1], (!sycl_range_1_, !sycl_range_1_, !sycl_id_1_)> +!sycl_local_accessor_base_1_i32_rw = !sycl.local_accessor_base<[1, i32, read_write], (!sycl_LocalAccessorBaseDevice_1_, memref)> +func.func @cast_sycl_local_accessor_base_to_accessor_common(%arg0: memref) -> memref { + // CHECK-LABEL: llvm.func @cast_sycl_local_accessor_base_to_accessor_common( + // CHECK-SAME: [[SRC:%.*]]: !llvm.ptr<[[LAB1:.*]]>) -> !llvm.ptr<[[COMMON]]> + // CHECK-NEXT: [[RES:%.*]] = llvm.bitcast [[SRC]] : !llvm.ptr<[[LAB1]]> to !llvm.ptr<[[COMMON]]> + // CHECK-NEXT: llvm.return [[RES]] : !llvm.ptr<[[COMMON]] + %0 = "sycl.cast"(%arg0) : (memref) -> memref + func.return %0: memref +} + +!sycl_local_accessor_1_i32_rw = !sycl.local_accessor<[1, i32], (!sycl_local_accessor_base_1_i32_rw)> +func.func @cast_sycl_local_accessor_to_local_accessor_base(%arg0: memref) -> memref { + // CHECK-LABEL: llvm.func @cast_sycl_local_accessor_to_local_accessor_base( + // CHECK-SAME: [[SRC:%.*]]: !llvm.ptr<[[LA1:.*]]>) -> !llvm.ptr<[[LAB1]]> + // CHECK-NEXT: [[RES:%.*]] = llvm.bitcast [[SRC]] : !llvm.ptr<[[LA1]]> to !llvm.ptr<[[LAB1]]> + // CHECK-NEXT: llvm.return [[RES]] : !llvm.ptr<[[LAB1]] + + %0 = "sycl.cast"(%arg0) : (memref) -> memref + func.return %0: memref +} + + diff --git a/mlir-sycl/test/Conversion/SYCLToLLVM/sycl-cast-to-llvm.mlir b/mlir-sycl/test/Conversion/SYCLToLLVM/sycl-cast-to-llvm.mlir index a8393474fc0d9..603653fbc1ec4 100644 --- a/mlir-sycl/test/Conversion/SYCLToLLVM/sycl-cast-to-llvm.mlir +++ b/mlir-sycl/test/Conversion/SYCLToLLVM/sycl-cast-to-llvm.mlir @@ -1,13 +1,11 @@ -// RUN: sycl-mlir-opt -split-input-file -convert-sycl-to-llvm -verify-diagnostics %s | FileCheck %s +// RUN: sycl-mlir-opt -split-input-file -convert-sycl-to-llvm='use-opaque-pointers=1' -verify-diagnostics %s | FileCheck %s !sycl_array_1_ = !sycl.array<[1], (memref<1xi64>)> !sycl_range_1_ = !sycl.range<[1], (!sycl_array_1_)> func.func @cast_sycl_range_to_array(%arg0: memref) -> memref { // CHECK-LABEL: llvm.func @cast_sycl_range_to_array( - // CHECK-SAME: [[SRC:%.*]]: !llvm.ptr<[[RANGE1:.*]]>) -> !llvm.ptr<[[ARRAY1:.*]]> - // CHECK-NEXT: [[RES:%.*]] = llvm.bitcast [[SRC]] : !llvm.ptr<[[RANGE1]]> to !llvm.ptr<[[ARRAY1]]> - // CHECK-NEXT: llvm.return [[RES]] : !llvm.ptr<[[ARRAY1]]> - + // CHECK-SAME: [[SRC:%.*]]: !llvm.ptr) -> !llvm.ptr + // CHECK-NEXT: llvm.return [[SRC]] : !llvm.ptr %0 = "sycl.cast"(%arg0) : (memref) -> memref func.return %0 : memref } @@ -18,9 +16,8 @@ func.func @cast_sycl_range_to_array(%arg0: memref) -> memref func.func @cast_sycl_id_to_array(%arg0: memref) -> memref { // CHECK-LABEL: llvm.func @cast_sycl_id_to_array( - // CHECK-SAME: [[SRC:%.*]]: !llvm.ptr<[[ID1:.*]]>) -> !llvm.ptr<[[ARRAY1]]> - // CHECK-NEXT: [[RES:%.*]] = llvm.bitcast [[SRC]] : !llvm.ptr<[[ID1]]> to !llvm.ptr<[[ARRAY1]]> - // CHECK-NEXT: llvm.return [[RES]] : !llvm.ptr<[[ARRAY1]]> + // CHECK-SAME: [[SRC:%.*]]: !llvm.ptr) -> !llvm.ptr + // CHECK-NEXT: llvm.return [[SRC]] : !llvm.ptr %0 = "sycl.cast"(%arg0) : (memref) -> memref func.return %0: memref @@ -30,12 +27,11 @@ func.func @cast_sycl_id_to_array(%arg0: memref) -> memref)>)> !sycl_range_1_ = !sycl.range<[1], (!sycl.array<[1], (memref<1xi64, 4>)>)> -!sycl_accessor_1_i32_rw_gb = !sycl.accessor<[1, i32, read_write, global_buffer], (!sycl.accessor_impl_device<[1], (!sycl_id_1_, !sycl_range_1_, !sycl_range_1_)>, !llvm.struct<(ptr)>)> +!sycl_accessor_1_i32_rw_gb = !sycl.accessor<[1, i32, read_write, global_buffer], (!sycl.accessor_impl_device<[1], (!sycl_id_1_, !sycl_range_1_, !sycl_range_1_)>, !llvm.struct<(ptr<1>)>)> func.func @cast_sycl_accessor_to_accessor_common(%arg0: memref) -> memref { // CHECK-LABEL: llvm.func @cast_sycl_accessor_to_accessor_common( - // CHECK-SAME: [[SRC:%.*]]: !llvm.ptr<[[ACC1:.*]]>) -> !llvm.ptr<[[COMMON:.*]]> - // CHECK-NEXT: [[RES:%.*]] = llvm.bitcast [[SRC]] : !llvm.ptr<[[ACC1]]> to !llvm.ptr<[[COMMON]]> - // CHECK-NEXT: llvm.return [[RES]] : !llvm.ptr<[[COMMON]]> + // CHECK-SAME: [[SRC:%.*]]: !llvm.ptr) -> !llvm.ptr + // CHECK-NEXT: llvm.return [[SRC]] : !llvm.ptr %0 = "sycl.cast"(%arg0) : (memref) -> memref func.return %0: memref @@ -45,9 +41,8 @@ func.func @cast_sycl_accessor_to_accessor_common(%arg0: memref)> func.func @cast_sycl_accessor_to_local_accessor_base(%arg0: memref) -> memref { // CHECK-LABEL: llvm.func @cast_sycl_accessor_to_local_accessor_base( - // CHECK-SAME: [[SRC:%.*]]: !llvm.ptr<[[ACC1]]>) -> !llvm.ptr<[[LOCALBASE:.*]]> - // CHECK-NEXT: [[RES:%.*]] = llvm.bitcast [[SRC]] : !llvm.ptr<[[ACC1]]> to !llvm.ptr<[[LOCALBASE]]> - // CHECK-NEXT: llvm.return [[RES]] : !llvm.ptr<[[LOCALBASE]]> + // CHECK-SAME: [[SRC:%.*]]: !llvm.ptr) -> !llvm.ptr + // CHECK-NEXT: llvm.return [[SRC]] : !llvm.ptr %0 = "sycl.cast"(%arg0) : (memref) -> memref func.return %0: memref @@ -55,9 +50,8 @@ func.func @cast_sycl_accessor_to_local_accessor_base(%arg0: memref) -> memref { // CHECK-LABEL: llvm.func @cast_sycl_accessor_to_owner_less_base( - // CHECK-SAME: [[SRC:%.*]]: !llvm.ptr<[[ACC1]]>) -> !llvm.ptr<[[OWNERLESSBASE:.*]]> - // CHECK-NEXT: [[RES:%.*]] = llvm.bitcast [[SRC]] : !llvm.ptr<[[ACC1]]> to !llvm.ptr<[[OWNERLESSBASE]]> - // CHECK-NEXT: llvm.return [[RES]] : !llvm.ptr<[[OWNERLESSBASE]]> + // CHECK-SAME: [[SRC:%.*]]: !llvm.ptr) -> !llvm.ptr + // CHECK-NEXT: llvm.return [[SRC]] : !llvm.ptr %0 = "sycl.cast"(%arg0) : (memref) -> memref func.return %0: memref @@ -71,9 +65,8 @@ func.func @cast_sycl_accessor_to_owner_less_base(%arg0: memref)> func.func @cast_sycl_local_accessor_base_to_accessor_common(%arg0: memref) -> memref { // CHECK-LABEL: llvm.func @cast_sycl_local_accessor_base_to_accessor_common( - // CHECK-SAME: [[SRC:%.*]]: !llvm.ptr<[[LAB1:.*]]>) -> !llvm.ptr<[[COMMON]]> - // CHECK-NEXT: [[RES:%.*]] = llvm.bitcast [[SRC]] : !llvm.ptr<[[LAB1]]> to !llvm.ptr<[[COMMON]]> - // CHECK-NEXT: llvm.return [[RES]] : !llvm.ptr<[[COMMON]] + // CHECK-SAME: [[SRC:%.*]]: !llvm.ptr) -> !llvm.ptr + // CHECK-NEXT: llvm.return [[SRC]] : !llvm.ptr %0 = "sycl.cast"(%arg0) : (memref) -> memref func.return %0: memref } @@ -81,9 +74,8 @@ func.func @cast_sycl_local_accessor_base_to_accessor_common(%arg0: memref func.func @cast_sycl_local_accessor_to_local_accessor_base(%arg0: memref) -> memref { // CHECK-LABEL: llvm.func @cast_sycl_local_accessor_to_local_accessor_base( - // CHECK-SAME: [[SRC:%.*]]: !llvm.ptr<[[LA1:.*]]>) -> !llvm.ptr<[[LAB1]]> - // CHECK-NEXT: [[RES:%.*]] = llvm.bitcast [[SRC]] : !llvm.ptr<[[LA1]]> to !llvm.ptr<[[LAB1]]> - // CHECK-NEXT: llvm.return [[RES]] : !llvm.ptr<[[LAB1]] + // CHECK-SAME: [[SRC:%.*]]: !llvm.ptr) -> !llvm.ptr + // CHECK-NEXT: llvm.return [[SRC]] : !llvm.ptr %0 = "sycl.cast"(%arg0) : (memref) -> memref func.return %0: memref From 80a07d9727d6b510ac6e4e4490e0ed27529c2318 Mon Sep 17 00:00:00 2001 From: Lukas Sommer Date: Tue, 4 Apr 2023 13:33:23 +0100 Subject: [PATCH 06/11] Fix accessor.subscript verifier for opaque pointer Signed-off-by: Lukas Sommer --- mlir-sycl/lib/Dialect/IR/SYCLOps.cpp | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/mlir-sycl/lib/Dialect/IR/SYCLOps.cpp b/mlir-sycl/lib/Dialect/IR/SYCLOps.cpp index 3f58f38411c3b..01c3547b60a2e 100644 --- a/mlir-sycl/lib/Dialect/IR/SYCLOps.cpp +++ b/mlir-sycl/lib/Dialect/IR/SYCLOps.cpp @@ -146,6 +146,10 @@ LogicalResult SYCLAccessorSubscriptOp::verify() { .Case( [&](auto Ty) { return VerifyElemType(Ty.getElementType()); }) .Case([&](auto Ty) { + if (!Ty.getElementType()) { + // With opaque pointers, there is no element type to inspect. + return success(); + } const Type ElemType = Ty.getElementType(); return (!isa(ElemType)) ? emitOpError( From 339ec7fd60dfb2024964a077cdf936f9d5fcc039 Mon Sep 17 00:00:00 2001 From: Lukas Sommer Date: Tue, 4 Apr 2023 13:34:01 +0100 Subject: [PATCH 07/11] Fix generated getelementptr instructions Signed-off-by: Lukas Sommer --- .../lib/Conversion/SYCLToLLVM/SYCLToLLVM.cpp | 278 +++++++++++------- 1 file changed, 170 insertions(+), 108 deletions(-) diff --git a/mlir-sycl/lib/Conversion/SYCLToLLVM/SYCLToLLVM.cpp b/mlir-sycl/lib/Conversion/SYCLToLLVM/SYCLToLLVM.cpp index 57badfae4bb17..4e42961e2830b 100644 --- a/mlir-sycl/lib/Conversion/SYCLToLLVM/SYCLToLLVM.cpp +++ b/mlir-sycl/lib/Conversion/SYCLToLLVM/SYCLToLLVM.cpp @@ -256,7 +256,7 @@ class GetMemberPatternBase { typename = std::enable_if_t< std::is_constructible_v || is_empty_v>> - Value getRef(OpBuilder &builder, Location loc, Type ty, Value ptr, + Value getRef(OpBuilder &builder, Location loc, Type baseTy, Value ptr, std::optional targetAddressSpace, bool useOpaquePtr, Args &&...args) const { SmallVector indices{0}; @@ -274,7 +274,7 @@ class GetMemberPatternBase { if (origAddressSpace != addressSpace) { if (useOpaquePtr) { ptr = builder.create( - loc, LLVM::LLVMPointerType::get(ty.getContext(), addressSpace), + loc, LLVM::LLVMPointerType::get(baseTy.getContext(), addressSpace), ptr); } else { ptr = builder.create( @@ -288,11 +288,11 @@ class GetMemberPatternBase { if (useOpaquePtr) { const auto ptrTy = - LLVM::LLVMPointerType::get(ty.getContext(), addressSpace); - return builder.create(loc, ptrTy, ty, ptr, indices, + LLVM::LLVMPointerType::get(baseTy.getContext(), addressSpace); + return builder.create(loc, ptrTy, baseTy, ptr, indices, /*inbounds*/ true); } - const auto ptrTy = LLVM::LLVMPointerType::get(ty, addressSpace); + const auto ptrTy = LLVM::LLVMPointerType::get(baseTy, addressSpace); return builder.create(loc, ptrTy, ptr, indices, /*inbounds*/ true); } @@ -305,14 +305,16 @@ class GetMemberPatternBase { typename = std::enable_if_t< std::is_constructible_v || is_empty_v>> - Value loadValue(OpBuilder &builder, Location loc, Type ty, Value ptr, - bool useOpaquePtr, Args &&...args) const { + Value loadValue(OpBuilder &builder, Location loc, Type baseTy, Type ty, + Value ptr, bool useOpaquePtr, Args &&...args) const { + if (useOpaquePtr) { + const auto gep = + getRef(builder, loc, baseTy, ptr, std::nullopt, useOpaquePtr, + std::forward(args)...); + return builder.create(loc, ty, gep); + } const auto gep = getRef(builder, loc, ty, ptr, std::nullopt, useOpaquePtr, std::forward(args)...); - - if (useOpaquePtr) - return builder.create(loc, ty, gep); - return builder.create(loc, gep); } @@ -431,9 +433,12 @@ class LoadMemberPattern : public GetMemberPattern, void rewrite(Op op, OpAdaptor adaptor, ConversionPatternRewriter &rewriter) const final { + // Assume the first operand is the 'this' argument. + const auto baseTy = getTypeConverter()->convertType( + cast(op->getOperand(0).getType()).getElementType()); const auto operands = adaptor.getOperands(); rewriter.replaceOp( - op, loadValue(rewriter, op.getLoc(), + op, loadValue(rewriter, op.getLoc(), baseTy, getTypeConverter()->convertType(op.getType()), operands[0], getTypeConverter()->useOpaquePointers())); } @@ -456,10 +461,13 @@ class LoadMemberDimPattern : public GetMemberPattern, void rewrite(Op op, OpAdaptor adaptor, ConversionPatternRewriter &rewriter) const final { + // Assume the first operand is the 'this' argument. + const auto baseTy = getTypeConverter()->convertType( + cast(op->getOperand(0).getType()).getElementType()); const auto operands = adaptor.getOperands(); rewriter.replaceOp( op, - loadValue(rewriter, op.getLoc(), + loadValue(rewriter, op.getLoc(), baseTy, getTypeConverter()->convertType(op.getType()), operands[0], getTypeConverter()->useOpaquePointers(), operands[1])); } @@ -499,8 +507,10 @@ class GetRangeSizePattern : public ConvertOpToLLVMPattern { using ConvertOpToLLVMPattern::ConvertOpToLLVMPattern; using typename ConvertOpToLLVMPattern::OpAdaptor; - virtual Value getRange(OpBuilder &builder, Location loc, Type ptrTy, - Value thisArg, int32_t index) const = 0; + virtual Value getRange(OpBuilder &builder, Location loc, Type baseTy, + Type ptrTy, Value thisArg, int32_t index) const = 0; + + virtual Type getBaseType(Op op) const = 0; public: virtual ~GetRangeSizePattern() = default; @@ -513,11 +523,12 @@ class GetRangeSizePattern : public ConvertOpToLLVMPattern { const auto elTy = getTypeConverter()->convertType(op.getType()); const auto loc = op.getLoc(); const auto dimension = getDimensions(op.getOperand().getType()); + const auto convBaseTy = getTypeConverter()->convertType(getBaseType(op)); assert(1 <= dimension && dimension < 4 && "Invalid number of dimensions"); Value newValue = rewriter.create(loc, 1, op.getType()); for (unsigned i = 0; i < dimension; ++i) { - const auto size = getRange(rewriter, loc, elTy, thisArg, i); + const auto size = getRange(rewriter, loc, convBaseTy, elTy, thisArg, i); newValue = rewriter.create(loc, newValue, size); } rewriter.replaceOp(op, newValue); @@ -531,10 +542,12 @@ class GetLinearIDPattern : public ConvertOpToLLVMPattern { using typename ConvertOpToLLVMPattern::OpAdaptor; using ConvertOpToLLVMPattern::ConvertOpToLLVMPattern; - virtual Value getID(OpBuilder &builder, Location loc, Type ptrTy, + virtual Value getID(OpBuilder &builder, Location loc, Type baseTy, Type ptrTy, Value thisArg, int32_t index) const = 0; - virtual Value getRange(OpBuilder &builder, Location loc, Type ptrTy, - Value thisArg, int32_t index) const = 0; + virtual Value getRange(OpBuilder &builder, Location loc, Type baseTy, + Type ptrTy, Value thisArg, int32_t index) const = 0; + + virtual Type getBaseType(Op op) const = 0; public: virtual ~GetLinearIDPattern() = default; @@ -547,33 +560,34 @@ class GetLinearIDPattern : public ConvertOpToLLVMPattern { const auto elTy = getTypeConverter()->convertType(op.getType()); const auto loc = op.getLoc(); const auto dimension = getDimensions(op.getOperand().getType()); + const auto convBaseTy = getTypeConverter()->convertType(getBaseType(op)); Value newValue; switch (dimension) { case 1: // get_id(0) - newValue = getID(rewriter, loc, elTy, thisArg, 0); + newValue = getID(rewriter, loc, convBaseTy, elTy, thisArg, 0); break; case 2: { // get_id(0) * get_range(1) + get_id(1) - const auto id0 = getID(rewriter, loc, elTy, thisArg, 0); - const auto r1 = getRange(rewriter, loc, elTy, thisArg, 1); + const auto id0 = getID(rewriter, loc, convBaseTy, elTy, thisArg, 0); + const auto r1 = getRange(rewriter, loc, convBaseTy, elTy, thisArg, 1); const Value prod = rewriter.create(loc, id0, r1); - const auto id1 = getID(rewriter, loc, elTy, thisArg, 1); + const auto id1 = getID(rewriter, loc, convBaseTy, elTy, thisArg, 1); newValue = rewriter.create(loc, prod, id1); break; } case 3: { // get_id(0) * get_range(1) * get_range(2) + get_id(1) * get_range(2) + // get_id(2) - const auto id0 = getID(rewriter, loc, elTy, thisArg, 0); - const auto r1 = getRange(rewriter, loc, elTy, thisArg, 1); + const auto id0 = getID(rewriter, loc, convBaseTy, elTy, thisArg, 0); + const auto r1 = getRange(rewriter, loc, convBaseTy, elTy, thisArg, 1); const Value prod0 = rewriter.create(loc, id0, r1); - const auto r2 = getRange(rewriter, loc, elTy, thisArg, 2); + const auto r2 = getRange(rewriter, loc, convBaseTy, elTy, thisArg, 2); const Value prod1 = rewriter.create(loc, prod0, r2); - const auto id1 = getID(rewriter, loc, elTy, thisArg, 1); + const auto id1 = getID(rewriter, loc, convBaseTy, elTy, thisArg, 1); const Value prod2 = rewriter.create(loc, id1, r2); const Value add = rewriter.create(loc, prod1, prod2); - const auto id2 = getID(rewriter, loc, elTy, thisArg, 2); + const auto id2 = getID(rewriter, loc, convBaseTy, elTy, thisArg, 2); newValue = rewriter.create(loc, add, id2); break; } @@ -1108,8 +1122,9 @@ class AccessorGetPointerPattern for (unsigned i = 0; i < accTy.getDimension(); ++i) { // Res = Res * Mem[I] + Id[I] const auto memI = - getMemRange(builder, loc, resTy, acc, useOpaquePointers, i); - const auto idI = getID(builder, loc, resTy, acc, useOpaquePointers, i); + getMemRange(builder, loc, accTy, resTy, acc, useOpaquePointers, i); + const auto idI = + getID(builder, loc, accTy, resTy, acc, useOpaquePointers, i); res = builder.create( loc, builder.create(loc, res, memI), idI); } @@ -1123,6 +1138,9 @@ class AccessorGetPointerPattern const auto loc = op.getLoc(); const auto indexTy = getTypeConverter()->getIndexType(); const Value zero = rewriter.create(loc, 0, indexTy); + const auto accTy = + cast(op.getAcc().getType().getElementType()); + const auto convAccTy = getTypeConverter()->convertType(accTy); Value index = rewriter.create( loc, zero, getTotalOffset( @@ -1133,7 +1151,7 @@ class AccessorGetPointerPattern const auto ptrTy = cast( getTypeConverter()->convertType(op.getType())); Value ptr = GetMemberPattern::loadValue( - rewriter, loc, ptrTy, opAdaptor.getAcc(), useOpaquePointers); + rewriter, loc, convAccTy, ptrTy, opAdaptor.getAcc(), useOpaquePointers); if (useOpaquePointers) { auto elemType = getTypeConverter()->convertType(op.getType().getElementType()); @@ -1170,11 +1188,15 @@ class AccessorSizePattern using GetRangeSizePattern::GetRangeSizePattern; protected: - Value getRange(OpBuilder &builder, Location loc, Type ty, Value thisArg, - int32_t index) const final { + Value getRange(OpBuilder &builder, Location loc, Type baseTy, Type ty, + Value thisArg, int32_t index) const final { return GetMemberPattern::loadValue( - builder, loc, ty, thisArg, getTypeConverter()->useOpaquePointers(), - index); + builder, loc, baseTy, ty, thisArg, + getTypeConverter()->useOpaquePointers(), index); + } + + Type getBaseType(SYCLAccessorSizeOp op) const final { + return op.getAcc().getType().getElementType(); } }; @@ -1216,7 +1238,7 @@ class AccessorSubscriptPattern const auto gepPtrTy = LLVM::LLVMPointerType::get(ptrTy.getContext(), addressSpace); const auto ptr = GetMemberPattern::loadValue( - builder, loc, gepPtrTy, acc, useOpaquePointers); + builder, loc, accTy, gepPtrTy, acc, useOpaquePointers); const Value gep = builder.create( loc, gepPtrTy, accTy.getType(), ptr, index, /*inbounds*/ true); return (ptrTy.getAddressSpace() == addressSpace) @@ -1226,7 +1248,7 @@ class AccessorSubscriptPattern const auto gepPtrTy = LLVM::LLVMPointerType::get(ptrTy.getElementType(), addressSpace); const auto ptr = GetMemberPattern::loadValue( - builder, loc, gepPtrTy, acc, useOpaquePointers); + builder, loc, accTy, gepPtrTy, acc, useOpaquePointers); const Value gep = builder.create(loc, gepPtrTy, ptr, index, /*inbounds*/ true); return ptrTy == gepPtrTy @@ -1253,7 +1275,7 @@ class AccessorSubscriptIDIndexPattern /// Calculates the linear index out of an id. Value getLinearIndex(OpBuilder &builder, Location loc, AccessorType accTy, - OpAdaptor opAdaptor) const { + Type idTy, OpAdaptor opAdaptor) const { const auto id = opAdaptor.getIndex(); const auto acc = opAdaptor.getAcc(); // size_t Res{0}; @@ -1263,8 +1285,9 @@ class AccessorSubscriptIDIndexPattern for (unsigned i = 0, dim = accTy.getDimension(); i < dim; ++i) { // Res = Res * Mem[I] + Id[I] const auto memI = - getMemRange(builder, loc, resTy, acc, useOpaquePointers, i); - const auto idI = getID(builder, loc, resTy, id, useOpaquePointers, i); + getMemRange(builder, loc, accTy, resTy, acc, useOpaquePointers, i); + const auto idI = + getID(builder, loc, idTy, resTy, id, useOpaquePointers, i); res = builder.create( loc, builder.create(loc, res, memI), idI); } @@ -1287,6 +1310,8 @@ class SubscriptIDOffset : public AccessorSubscriptIDIndexPattern { void rewrite(SYCLAccessorSubscriptOp op, OpAdaptor opAdaptor, ConversionPatternRewriter &rewriter) const final { + const auto convIDTy = getTypeConverter()->convertType( + cast(op.getIndex().getType()).getElementType()); const auto loc = op.getLoc(); const auto ptrTy = cast( getTypeConverter()->convertType(op.getType())); @@ -1296,7 +1321,7 @@ class SubscriptIDOffset : public AccessorSubscriptIDIndexPattern { getLinearIndex( rewriter, loc, cast(op.getAcc().getType().getElementType()), - opAdaptor))); + convIDTy, opAdaptor))); } }; @@ -1380,6 +1405,8 @@ class AtomicSubscriptIDOffset : public AccessorSubscriptIDIndexPattern { void rewrite(SYCLAccessorSubscriptOp op, OpAdaptor opAdaptor, ConversionPatternRewriter &rewriter) const final { + const auto convIDTy = getTypeConverter()->convertType( + cast(op.getIndex().getType()).getElementType()); const auto loc = op.getLoc(); const auto atomicTy = cast(op.getType()); auto *typeConverter = getTypeConverter(); @@ -1395,7 +1422,7 @@ class AtomicSubscriptIDOffset : public AccessorSubscriptIDIndexPattern { getLinearIndex( rewriter, loc, cast(op.getAcc().getType().getElementType()), - opAdaptor)); + convIDTy, opAdaptor)); rewriter.replaceOpWithNewOp(op, undef, ptr, 0); } }; @@ -1434,11 +1461,15 @@ class RangeSizePattern : public GetRangeSizePattern, public: using GetRangeSizePattern::GetRangeSizePattern; - Value getRange(OpBuilder &builder, Location loc, Type ty, Value thisArg, - int32_t index) const final { - return loadValue(builder, loc, ty, thisArg, + Value getRange(OpBuilder &builder, Location loc, Type baseTy, Type ty, + Value thisArg, int32_t index) const final { + return loadValue(builder, loc, baseTy, ty, thisArg, getTypeConverter()->useOpaquePointers(), index); } + + Type getBaseType(SYCLRangeSizeOp op) const final { + return op.getRange().getType().getElementType(); + } }; //===----------------------------------------------------------------------===// @@ -1495,6 +1526,8 @@ class NDRangeGetGroupRangePattern ConversionPatternRewriter &rewriter) const final { const auto loc = op.getLoc(); const auto nd = opAdaptor.getND(); + const auto convNDRangeTy = + getTypeConverter()->convertType(op.getND().getType().getElementType()); const auto rangeTy = op.getType(); const auto convRangeTy = getTypeConverter()->convertType(rangeTy); const auto indexTy = getTypeConverter()->getIndexType(); @@ -1509,10 +1542,10 @@ class NDRangeGetGroupRangePattern for (int32_t i = 0, dim = rangeTy.getDimension(); i < dim; ++i) { const auto lhs = GetMemberPattern::loadValue( - rewriter, loc, indexTy, nd, useOpaquePointers, i); + rewriter, loc, convNDRangeTy, indexTy, nd, useOpaquePointers, i); const auto rhs = GetMemberPattern::loadValue( - rewriter, loc, indexTy, nd, useOpaquePointers, i); + rewriter, loc, convNDRangeTy, indexTy, nd, useOpaquePointers, i); const Value val = rewriter.create(loc, lhs, rhs); const auto ptr = GetMemberPattern::getRef( rewriter, loc, indexTy, alloca, std::nullopt, useOpaquePointers, i); @@ -1616,11 +1649,15 @@ class ItemGetLinearIDPattern public GetMemberPattern, public GetMemberPattern { protected: - Value getRange(OpBuilder &builder, Location loc, Type ty, Value thisArg, - int32_t index) const final { + Value getRange(OpBuilder &builder, Location loc, Type baseTy, Type ty, + Value thisArg, int32_t index) const final { return GetMemberPattern::loadValue( - builder, loc, ty, thisArg, getTypeConverter()->useOpaquePointers(), - index); + builder, loc, baseTy, ty, thisArg, + getTypeConverter()->useOpaquePointers(), index); + } + + Type getBaseType(SYCLItemGetLinearIDOp op) const final { + return op.getItem().getType().getElementType(); } public: @@ -1637,11 +1674,11 @@ class ItemNoOffsetGetLinearIDPattern : public ItemGetLinearIDPattern { .getWithOffset()); } - Value getID(OpBuilder &builder, Location loc, Type ty, Value thisArg, - int32_t index) const final { + Value getID(OpBuilder &builder, Location loc, Type baseTy, Type ty, + Value thisArg, int32_t index) const final { return GetMemberPattern::loadValue( - builder, loc, ty, thisArg, getTypeConverter()->useOpaquePointers(), - index); + builder, loc, baseTy, ty, thisArg, + getTypeConverter()->useOpaquePointers(), index); } }; @@ -1650,13 +1687,13 @@ class ItemOffsetGetLinearIDPattern : public ItemGetLinearIDPattern, public GetMemberPattern { protected: - Value getID(OpBuilder &builder, Location loc, Type ty, Value thisArg, - int32_t index) const final { + Value getID(OpBuilder &builder, Location loc, Type baseTy, Type ty, + Value thisArg, int32_t index) const final { bool useOpaquePointers = getTypeConverter()->useOpaquePointers(); const auto id = GetMemberPattern::loadValue( - builder, loc, ty, thisArg, useOpaquePointers, index); + builder, loc, baseTy, ty, thisArg, useOpaquePointers, index); const auto offset = GetMemberPattern::loadValue( - builder, loc, ty, thisArg, useOpaquePointers, index); + builder, loc, baseTy, ty, thisArg, useOpaquePointers, index); return builder.create(loc, id, offset); } @@ -1709,20 +1746,22 @@ class NDItemGetGlobalLinearIDPattern public GetMemberPattern, public GetMemberPattern { protected: - Value getRange(OpBuilder &builder, Location loc, Type ty, Value thisArg, - int32_t index) const final { - return GetMemberPattern::loadValue(builder, loc, ty, thisArg, - getTypeConverter() - ->useOpaquePointers(), - index); + Value getRange(OpBuilder &builder, Location loc, Type baseTy, Type ty, + Value thisArg, int32_t index) const final { + return GetMemberPattern:: + loadValue(builder, loc, baseTy, ty, thisArg, + getTypeConverter()->useOpaquePointers(), index); } - Value getID(OpBuilder &builder, Location loc, Type ty, Value thisArg, - int32_t index) const final { + Value getID(OpBuilder &builder, Location loc, Type baseTy, Type ty, + Value thisArg, int32_t index) const final { return GetMemberPattern::loadValue( - builder, loc, ty, thisArg, getTypeConverter()->useOpaquePointers(), - index); + builder, loc, baseTy, ty, thisArg, + getTypeConverter()->useOpaquePointers(), index); + } + + Type getBaseType(SYCLNDItemGetGlobalLinearIDOp op) const final { + return op.getNDItem().getType().getElementType(); } public: @@ -1769,20 +1808,22 @@ class NDItemGetLocalLinearIDPattern public GetMemberPattern, public GetMemberPattern { protected: - Value getRange(OpBuilder &builder, Location loc, Type ty, Value thisArg, - int32_t index) const final { - return GetMemberPattern::loadValue(builder, loc, ty, thisArg, - getTypeConverter() - ->useOpaquePointers(), - index); + Value getRange(OpBuilder &builder, Location loc, Type baseTy, Type ty, + Value thisArg, int32_t index) const final { + return GetMemberPattern:: + loadValue(builder, loc, baseTy, ty, thisArg, + getTypeConverter()->useOpaquePointers(), index); } - Value getID(OpBuilder &builder, Location loc, Type ty, Value thisArg, - int32_t index) const final { + Value getID(OpBuilder &builder, Location loc, Type baseTy, Type ty, + Value thisArg, int32_t index) const final { return GetMemberPattern::loadValue( - builder, loc, ty, thisArg, getTypeConverter()->useOpaquePointers(), - index); + builder, loc, baseTy, ty, thisArg, + getTypeConverter()->useOpaquePointers(), index); + } + + Type getBaseType(SYCLNDItemGetLocalLinearIDOp op) const final { + return op.getNDItem().getType().getElementType(); } public: @@ -1899,6 +1940,8 @@ class NDItemGetNDRange ConversionPatternRewriter &rewriter) const final { const auto loc = op.getLoc(); const auto ndItem = opAdaptor.getNDItem(); + const auto convNDItemType = getTypeConverter()->convertType( + op.getNDItem().getType().getElementType()); const auto ndrTy = getTypeConverter()->convertType(op.getType()); bool useOpaquePointers = getTypeConverter()->useOpaquePointers(); @@ -1915,21 +1958,24 @@ class NDItemGetNDRange rewriter.create( loc, GetMemberPattern::loadValue( - rewriter, loc, rangeTy, ndItem, useOpaquePointers), + rewriter, loc, convNDItemType, rangeTy, ndItem, useOpaquePointers), GetMemberPattern::getRef( - rewriter, loc, rangeTy, alloca, std::nullopt, useOpaquePointers)); + rewriter, loc, (useOpaquePointers) ? ndrTy : rangeTy, alloca, + std::nullopt, useOpaquePointers)); rewriter.create( loc, GetMemberPattern::loadValue( - rewriter, loc, rangeTy, ndItem, useOpaquePointers), + rewriter, loc, convNDItemType, rangeTy, ndItem, useOpaquePointers), GetMemberPattern::getRef( - rewriter, loc, rangeTy, alloca, std::nullopt, useOpaquePointers)); + rewriter, loc, (useOpaquePointers) ? ndrTy : rangeTy, alloca, + std::nullopt, useOpaquePointers)); rewriter.create( loc, GetMemberPattern::loadValue( - rewriter, loc, idTy, ndItem, useOpaquePointers), + rewriter, loc, convNDItemType, idTy, ndItem, useOpaquePointers), GetMemberPattern::getRef( - rewriter, loc, idTy, alloca, std::nullopt, useOpaquePointers)); + rewriter, loc, (useOpaquePointers) ? ndrTy : idTy, alloca, + std::nullopt, useOpaquePointers)); if (useOpaquePointers) { rewriter.replaceOpWithNewOp(op, ndrTy, alloca); return success(); @@ -2075,18 +2121,22 @@ class GroupGetGroupLinearIDPattern public GetMemberPattern, public GetMemberPattern { protected: - Value getID(OpBuilder &builder, Location loc, Type ty, Value thisArg, - int32_t index) const final { + Value getID(OpBuilder &builder, Location loc, Type baseTy, Type ty, + Value thisArg, int32_t index) const final { return GetMemberPattern::loadValue( - builder, loc, ty, thisArg, getTypeConverter()->useOpaquePointers(), - index); + builder, loc, baseTy, ty, thisArg, + getTypeConverter()->useOpaquePointers(), index); } - Value getRange(OpBuilder &builder, Location loc, Type ty, Value thisArg, - int32_t index) const final { + Value getRange(OpBuilder &builder, Location loc, Type baseTy, Type ty, + Value thisArg, int32_t index) const final { return GetMemberPattern::loadValue( - builder, loc, ty, thisArg, getTypeConverter()->useOpaquePointers(), - index); + builder, loc, baseTy, ty, thisArg, + getTypeConverter()->useOpaquePointers(), index); + } + + Type getBaseType(SYCLGroupGetGroupLinearIDOp op) const final { + return op.getGroup().getType().getElementType(); } public: @@ -2101,7 +2151,7 @@ class GroupGetGroupLinearIDPattern class GroupGetLocalLinearIDPattern : public GetLinearIDPattern, public GetMemberPattern { - Value getID(OpBuilder &builder, Location loc, Type ty, Value, + Value getID(OpBuilder &builder, Location loc, Type baseTy, Type ty, Value, int32_t offset) const final { const Value dim = builder.create(loc, offset, 32); const Value val = @@ -2109,11 +2159,15 @@ class GroupGetLocalLinearIDPattern return builder.create(loc, ty, val); } - Value getRange(OpBuilder &builder, Location loc, Type ty, Value thisArg, - int32_t offset) const final { + Value getRange(OpBuilder &builder, Location loc, Type baseTy, Type ty, + Value thisArg, int32_t offset) const final { return GetMemberPattern::loadValue( - builder, loc, ty, thisArg, getTypeConverter()->useOpaquePointers(), - offset); + builder, loc, baseTy, ty, thisArg, + getTypeConverter()->useOpaquePointers(), offset); + } + + Type getBaseType(SYCLGroupGetLocalLinearIDOp op) const final { + return op.getGroup().getType().getElementType(); } public: @@ -2134,11 +2188,15 @@ class GroupGetGroupLinearRangePattern SYCLGroupGetGroupLinearRangeOp>::GetRangeSizePattern; protected: - Value getRange(OpBuilder &builder, Location loc, Type ty, Value thisArg, - int32_t index) const final { + Value getRange(OpBuilder &builder, Location loc, Type baseTy, Type ty, + Value thisArg, int32_t index) const final { return GetMemberPattern::loadValue( - builder, loc, ty, thisArg, getTypeConverter()->useOpaquePointers(), - index); + builder, loc, baseTy, ty, thisArg, + getTypeConverter()->useOpaquePointers(), index); + } + + Type getBaseType(SYCLGroupGetGroupLinearRangeOp op) const final { + return op.getGroup().getType().getElementType(); } }; @@ -2156,11 +2214,15 @@ class GroupGetLocalLinearRangePattern SYCLGroupGetLocalLinearRangeOp>::GetRangeSizePattern; protected: - Value getRange(OpBuilder &builder, Location loc, Type ty, Value thisArg, - int32_t index) const final { + Value getRange(OpBuilder &builder, Location loc, Type baseTy, Type ty, + Value thisArg, int32_t index) const final { return GetMemberPattern::loadValue( - builder, loc, ty, thisArg, getTypeConverter()->useOpaquePointers(), - index); + builder, loc, baseTy, ty, thisArg, + getTypeConverter()->useOpaquePointers(), index); + } + + Type getBaseType(SYCLGroupGetLocalLinearRangeOp op) const final { + return op.getGroup().getType().getElementType(); } }; From 592d7f42355a11248a802d9abf93222a26c7ef1f Mon Sep 17 00:00:00 2001 From: Lukas Sommer Date: Tue, 4 Apr 2023 13:34:11 +0100 Subject: [PATCH 08/11] Update more tests Signed-off-by: Lukas Sommer --- ...ycl-constructor-to-llvm-typed-pointer.mlir | 418 ++++ .../SYCLToLLVM/sycl-constructor-to-llvm.mlir | 66 +- ...cl-methods-flat-to-llvm-typed-pointer.mlir | 164 ++ .../SYCLToLLVM/sycl-methods-flat-to-llvm.mlir | 126 +- ...ycl-methods-to-llvm-m32-typed-pointer.mlir | 31 + .../SYCLToLLVM/sycl-methods-to-llvm-m32.mlir | 22 +- .../sycl-methods-to-llvm-typed-pointer.mlir | 1706 +++++++++++++++++ .../SYCLToLLVM/sycl-methods-to-llvm.mlir | 1480 +++++++------- 8 files changed, 3157 insertions(+), 856 deletions(-) create mode 100644 mlir-sycl/test/Conversion/SYCLToLLVM/sycl-constructor-to-llvm-typed-pointer.mlir create mode 100644 mlir-sycl/test/Conversion/SYCLToLLVM/sycl-methods-flat-to-llvm-typed-pointer.mlir create mode 100644 mlir-sycl/test/Conversion/SYCLToLLVM/sycl-methods-to-llvm-m32-typed-pointer.mlir create mode 100644 mlir-sycl/test/Conversion/SYCLToLLVM/sycl-methods-to-llvm-typed-pointer.mlir diff --git a/mlir-sycl/test/Conversion/SYCLToLLVM/sycl-constructor-to-llvm-typed-pointer.mlir b/mlir-sycl/test/Conversion/SYCLToLLVM/sycl-constructor-to-llvm-typed-pointer.mlir new file mode 100644 index 0000000000000..a07f042f29022 --- /dev/null +++ b/mlir-sycl/test/Conversion/SYCLToLLVM/sycl-constructor-to-llvm-typed-pointer.mlir @@ -0,0 +1,418 @@ +// RUN: sycl-mlir-opt -split-input-file -convert-sycl-to-llvm='use-opaque-pointers=0' -verify-diagnostics %s | FileCheck %s + +//===-------------------------------------------------------------------------------------------------===// +// Constructors for sycl::accessor::accessor() +//===-------------------------------------------------------------------------------------------------===// + +!sycl_id_1_ = !sycl.id<[1], (!sycl.array<[1], (memref<1xi64, 4>)>)> +!sycl_range_1_ = !sycl.range<[1], (!sycl.array<[1], (memref<1xi64, 4>)>)> +!sycl_accessor_1_i32_rw_gb = !sycl.accessor<[1, i32, read_write, global_buffer], (!sycl.accessor_impl_device<[1], (!sycl_id_1_, !sycl_range_1_, !sycl_range_1_)>, !llvm.struct<(ptr)>)> + +// CHECK: llvm.func @_ZN2cl4sycl8accessorIiLi1ELNS0_6access4modeE1026ELNS2_6targetE2014ELNS2_11placeholderE0ENS0_3ext6oneapi22accessor_property_listIJEEEEC2Ev([[THIS_PTR_TYPE:!llvm.ptr) + +func.func @accessorInt1ReadWriteGlobalBufferFalseCtor(%arg0: memref) { + // CHECK: llvm.call @_ZN2cl4sycl8accessorIiLi1ELNS0_6access4modeE1026ELNS2_6targetE2014ELNS2_11placeholderE0ENS0_3ext6oneapi22accessor_property_listIJEEEEC2Ev({{.*}}) : ([[THIS_PTR_TYPE]]) -> () + sycl.constructor @accessor(%arg0) {MangledFunctionName = @_ZN2cl4sycl8accessorIiLi1ELNS0_6access4modeE1026ELNS2_6targetE2014ELNS2_11placeholderE0ENS0_3ext6oneapi22accessor_property_listIJEEEEC2Ev} : (memref) + return +} + +// ----- + +//===-------------------------------------------------------------------------------------------------===// +// Constructors for sycl::id::id() +//===-------------------------------------------------------------------------------------------------===// + +!sycl_id_1_ = !sycl.id<[1], (!sycl.array<[1], (memref<1xi64, 4>)>)> +// CHECK: llvm.func @_ZN2cl4sycl2idILi1EEC2Ev([[THIS_PTR_TYPE:!llvm.ptr) + +func.func @id1Ctor(%arg0: memref) { + // CHECK: llvm.call @_ZN2cl4sycl2idILi1EEC2Ev({{.*}}) : ([[THIS_PTR_TYPE]]) -> () + sycl.constructor @id(%arg0) {MangledFunctionName = @_ZN2cl4sycl2idILi1EEC2Ev} : (memref) + return +} + +// ----- + +!sycl_id_2_ = !sycl.id<[2], (!sycl.array<[2], (memref<2xi64, 4>)>)> +// CHECK: llvm.func @_ZN2cl4sycl2idILi2EEC2Ev([[THIS_PTR_TYPE:!llvm.ptr) + +func.func @id2Ctor(%arg0: memref) { + // CHECK: llvm.call @_ZN2cl4sycl2idILi2EEC2Ev({{.*}}) : ([[THIS_PTR_TYPE]]) -> () + sycl.constructor @id(%arg0) {MangledFunctionName = @_ZN2cl4sycl2idILi2EEC2Ev} : (memref) + return +} + +// ----- + +!sycl_id_3_ = !sycl.id<[3], (!sycl.array<[3], (memref<3xi64, 4>)>)> +// CHECK: llvm.func @_ZN2cl4sycl2idILi3EEC2Ev([[THIS_PTR_TYPE:!llvm.ptr) + +func.func @id3Ctor(%arg0: memref) { + // CHECK: llvm.call @_ZN2cl4sycl2idILi3EEC2Ev({{.*}}) : ([[THIS_PTR_TYPE]]) -> () + sycl.constructor @id(%arg0) {MangledFunctionName = @_ZN2cl4sycl2idILi3EEC2Ev} : (memref) + return +} + +// ----- + +//===-------------------------------------------------------------------------------------------------===// +// Constructors for cl::sycl::id::id(std::enable_if<(n)==(n), unsigned long>::type) +//===-------------------------------------------------------------------------------------------------===// + +!sycl_id_1_ = !sycl.id<[1], (!sycl.array<[1], (memref<1xi64, 4>)>)> +// CHECK: llvm.func @_ZN2cl4sycl2idILi1EEC2ILi1EEENSt9enable_ifIXeqT_Li1EEmE4typeE([[THIS_PTR_TYPE:!llvm.ptr, i64) + +func.func @id1CtorSizeT(%arg0: memref, %arg1: i64) { + // CHECK: llvm.call @_ZN2cl4sycl2idILi1EEC2ILi1EEENSt9enable_ifIXeqT_Li1EEmE4typeE({{.*}}, {{.*}}) : ([[THIS_PTR_TYPE]], i64) -> () + sycl.constructor @id(%arg0, %arg1) {MangledFunctionName = @_ZN2cl4sycl2idILi1EEC2ILi1EEENSt9enable_ifIXeqT_Li1EEmE4typeE} : (memref, i64) + return +} + +// ----- + +!sycl_id_2_ = !sycl.id<[2], (!sycl.array<[2], (memref<2xi64, 4>)>)> +// CHECK: llvm.func @_ZN2cl4sycl2idILi2EEC2ILi2EEENSt9enable_ifIXeqT_Li2EEmE4typeE([[THIS_PTR_TYPE:!llvm.ptr, i64) + +func.func @id2CtorSizeT(%arg0: memref, %arg1: i64) { + // CHECK: llvm.call @_ZN2cl4sycl2idILi2EEC2ILi2EEENSt9enable_ifIXeqT_Li2EEmE4typeE({{.*}}, {{.*}}) : ([[THIS_PTR_TYPE]], i64) -> () + sycl.constructor @id(%arg0, %arg1) {MangledFunctionName = @_ZN2cl4sycl2idILi2EEC2ILi2EEENSt9enable_ifIXeqT_Li2EEmE4typeE} : (memref, i64) + return +} + +// ----- + +!sycl_id_3_ = !sycl.id<[3], (!sycl.array<[3], (memref<3xi64, 4>)>)> +// CHECK: llvm.func @_ZN2cl4sycl2idILi3EEC2ILi3EEENSt9enable_ifIXeqT_Li3EEmE4typeE([[THIS_PTR_TYPE:!llvm.ptr, i64) + +func.func @id3CtorSizeT(%arg0: memref, %arg1: i64) { + // CHECK: llvm.call @_ZN2cl4sycl2idILi3EEC2ILi3EEENSt9enable_ifIXeqT_Li3EEmE4typeE({{.*}}, {{.*}}) : ([[THIS_PTR_TYPE]], i64) -> () + sycl.constructor @id(%arg0, %arg1) {MangledFunctionName = @_ZN2cl4sycl2idILi3EEC2ILi3EEENSt9enable_ifIXeqT_Li3EEmE4typeE} : (memref, i64) + return +} + +// ----- + +//===-------------------------------------------------------------------------------------------------===// +// Constructors for cl::sycl::id::id(std::enable_if<(n)==(n), unsigned long>::type, unsigned long) +//===-------------------------------------------------------------------------------------------------===// + +!sycl_id_1_ = !sycl.id<[1], (!sycl.array<[1], (memref<1xi64, 4>)>)> +// CHECK: llvm.func @_ZN2cl4sycl2idILi1EEC2ILi1EEENSt9enable_ifIXeqT_Li1EEmE4typeEm([[THIS_PTR_TYPE:!llvm.ptr, i64, i64) + +func.func @id1CtorRange(%arg0: memref, %arg1: i64, %arg2: i64) { + // CHECK: llvm.call @_ZN2cl4sycl2idILi1EEC2ILi1EEENSt9enable_ifIXeqT_Li1EEmE4typeEm({{.*}}, {{.*}}, {{.*}}) : ([[THIS_PTR_TYPE]], i64, i64) -> () + sycl.constructor @id(%arg0, %arg1, %arg2) {MangledFunctionName = @_ZN2cl4sycl2idILi1EEC2ILi1EEENSt9enable_ifIXeqT_Li1EEmE4typeEm} : (memref, i64, i64) + return +} + +// ----- + +!sycl_id_2_ = !sycl.id<[2], (!sycl.array<[2], (memref<2xi64, 4>)>)> +// CHECK: llvm.func @_ZN2cl4sycl2idILi2EEC2ILi2EEENSt9enable_ifIXeqT_Li2EEmE4typeEm([[THIS_PTR_TYPE:!llvm.ptr, i64, i64) + +func.func @id2CtorRange(%arg0: memref, %arg1: i64, %arg2: i64) { + // CHECK: llvm.call @_ZN2cl4sycl2idILi2EEC2ILi2EEENSt9enable_ifIXeqT_Li2EEmE4typeEm({{.*}}, {{.*}}, {{.*}}) : ([[THIS_PTR_TYPE]], i64, i64) -> () + sycl.constructor @id(%arg0, %arg1, %arg2) {MangledFunctionName = @_ZN2cl4sycl2idILi2EEC2ILi2EEENSt9enable_ifIXeqT_Li2EEmE4typeEm} : (memref, i64, i64) + return +} + +// ----- + +!sycl_id_3_ = !sycl.id<[3], (!sycl.array<[3], (memref<3xi64, 4>)>)> +// CHECK: llvm.func @_ZN2cl4sycl2idILi3EEC2ILi3EEENSt9enable_ifIXeqT_Li3EEmE4typeEm([[THIS_PTR_TYPE:!llvm.ptr, i64, i64) + +func.func @id3CtorRange(%arg0: memref, %arg1: i64, %arg2: i64) { + // CHECK: llvm.call @_ZN2cl4sycl2idILi3EEC2ILi3EEENSt9enable_ifIXeqT_Li3EEmE4typeEm({{.*}}, {{.*}}, {{.*}}) : ([[THIS_PTR_TYPE]], i64, i64) -> () + sycl.constructor @id(%arg0, %arg1, %arg2) {MangledFunctionName = @_ZN2cl4sycl2idILi3EEC2ILi3EEENSt9enable_ifIXeqT_Li3EEmE4typeEm} : (memref, i64, i64) + return +} + +// ----- + +//===-------------------------------------------------------------------------------------------------===// +// Constructors for cl::sycl::id::id(std::enable_if<(n)==(n), unsigned long>::type, unsigned long, unsigned long) +//===-------------------------------------------------------------------------------------------------===// + +!sycl_id_1_ = !sycl.id<[1], (!sycl.array<[1], (memref<1xi64, 4>)>)> +// CHECK: llvm.func @_ZN2cl4sycl2idILi1EEC2ILi1EEENSt9enable_ifIXeqT_Li1EEmE4typeEmm([[THIS_PTR_TYPE:!llvm.ptr, i64, i64, i64) + +func.func @id1CtorItem(%arg0: memref, %arg1: i64, %arg2: i64, %arg3: i64) { + // CHECK: llvm.call @_ZN2cl4sycl2idILi1EEC2ILi1EEENSt9enable_ifIXeqT_Li1EEmE4typeEmm({{.*}}, {{.*}}, {{.*}}, {{.*}}) : ([[THIS_PTR_TYPE]], i64, i64, i64) -> () + sycl.constructor @id(%arg0, %arg1, %arg2, %arg3) {MangledFunctionName = @_ZN2cl4sycl2idILi1EEC2ILi1EEENSt9enable_ifIXeqT_Li1EEmE4typeEmm} : (memref, i64, i64, i64) + return +} + +// ----- + +!sycl_id_2_ = !sycl.id<[2], (!sycl.array<[2], (memref<2xi64, 4>)>)> +// CHECK: llvm.func @_ZN2cl4sycl2idILi2EEC2ILi2EEENSt9enable_ifIXeqT_Li2EEmE4typeEmm([[THIS_PTR_TYPE:!llvm.ptr, i64, i64, i64) + +func.func @id2CtorItem(%arg0: memref, %arg1: i64, %arg2: i64, %arg3: i64) { + // CHECK: llvm.call @_ZN2cl4sycl2idILi2EEC2ILi2EEENSt9enable_ifIXeqT_Li2EEmE4typeEmm({{.*}}, {{.*}}, {{.*}}, {{.*}}) : ([[THIS_PTR_TYPE]], i64, i64, i64) -> () + sycl.constructor @id(%arg0, %arg1, %arg2, %arg3) {MangledFunctionName = @_ZN2cl4sycl2idILi2EEC2ILi2EEENSt9enable_ifIXeqT_Li2EEmE4typeEmm} : (memref, i64, i64, i64) + return +} + +// ----- + +!sycl_id_3_ = !sycl.id<[3], (!sycl.array<[3], (memref<3xi64, 4>)>)> +// CHECK: llvm.func @_ZN2cl4sycl2idILi3EEC2ILi3EEENSt9enable_ifIXeqT_Li3EEmE4typeEmm([[THIS_PTR_TYPE:!llvm.ptr, i64, i64, i64) + +func.func @id3CtorItem(%arg0: memref, %arg1: i64, %arg2: i64, %arg3: i64) { + // CHECK: llvm.call @_ZN2cl4sycl2idILi3EEC2ILi3EEENSt9enable_ifIXeqT_Li3EEmE4typeEmm({{.*}}, {{.*}}, {{.*}}, {{.*}}) : ([[THIS_PTR_TYPE]], i64, i64, i64) -> () + sycl.constructor @id(%arg0, %arg1, %arg2, %arg3) {MangledFunctionName = @_ZN2cl4sycl2idILi3EEC2ILi3EEENSt9enable_ifIXeqT_Li3EEmE4typeEmm} : (memref, i64, i64, i64) + return +} + +// ----- + +//===-------------------------------------------------------------------------------------------------===// +// Constructors sycl::id::id(sycl::id const&, sycl::id const&) +//===-------------------------------------------------------------------------------------------------===// + +!sycl_id_1_ = !sycl.id<[1], (!sycl.array<[1], (memref<1xi64, 4>)>)> +// CHECK: llvm.func @_ZN2cl4sycl2idILi1EEC1ERKS2_([[THIS_PTR_TYPE:!llvm.ptr, memref) + +func.func @id1CopyCtor(%arg0: memref, %arg1: memref) { + // CHECK: llvm.call @_ZN2cl4sycl2idILi1EEC1ERKS2_({{.*}}, {{.*}}) : ([[THIS_PTR_TYPE]], [[THIS_PTR_TYPE]]) -> () + sycl.constructor @id(%arg0, %arg1) {MangledFunctionName = @_ZN2cl4sycl2idILi1EEC1ERKS2_} : (memref, memref) + return +} + +// ----- + +!sycl_id_2_ = !sycl.id<[2], (!sycl.array<[2], (memref<2xi64, 4>)>)> +// CHECK: llvm.func @_ZN2cl4sycl2idILi2EEC1ERKS2_([[THIS_PTR_TYPE:!llvm.ptr, memref) + +func.func @id2CopyCtor(%arg0: memref, %arg1: memref) { + // CHECK: llvm.call @_ZN2cl4sycl2idILi2EEC1ERKS2_({{.*}}, {{.*}}) : ([[THIS_PTR_TYPE]], [[THIS_PTR_TYPE]]) -> () + sycl.constructor @id(%arg0, %arg1) {MangledFunctionName = @_ZN2cl4sycl2idILi2EEC1ERKS2_} : (memref, memref) + return +} + +// ----- + +!sycl_id_3_ = !sycl.id<[3], (!sycl.array<[3], (memref<3xi64, 4>)>)> +// CHECK: llvm.func @_ZN2cl4sycl2idILi3EEC1ERKS2_([[THIS_PTR_TYPE:!llvm.ptr, memref) + +func.func @id3CopyCtor(%arg0: memref, %arg1: memref) { + // CHECK: llvm.call @_ZN2cl4sycl2idILi3EEC1ERKS2_({{.*}}, {{.*}}) : ([[THIS_PTR_TYPE]], [[THIS_PTR_TYPE]]) -> () + sycl.constructor @id(%arg0, %arg1) {MangledFunctionName = @_ZN2cl4sycl2idILi3EEC1ERKS2_} : (memref, memref) + return +} + +// ----- + +//===-------------------------------------------------------------------------------------------------===// +// Constructors for sycl::range::range() +//===-------------------------------------------------------------------------------------------------===// + +!sycl_range_1_ = !sycl.range<[1], (!sycl.array<[1], (memref<1xi64, 4>)>)> +// CHECK: llvm.func @_ZN2cl4sycl5rangeILi1EEC2Ev([[THIS_PTR_TYPE:!llvm.ptr) + +func.func @range1Ctor(%arg0: memref) { + // CHECK: llvm.call @_ZN2cl4sycl5rangeILi1EEC2Ev({{.*}}) : ([[THIS_PTR_TYPE]]) -> () + sycl.constructor @range(%arg0) {MangledFunctionName = @_ZN2cl4sycl5rangeILi1EEC2Ev} : (memref) + return +} + +// ----- + +!sycl_range_2_ = !sycl.range<[2], (!sycl.array<[2], (memref<2xi64, 4>)>)> +// CHECK: llvm.func @_ZN2cl4sycl5rangeILi2EEC2Ev([[THIS_PTR_TYPE:!llvm.ptr) + +func.func @range2Ctor(%arg0: memref) { + // CHECK: llvm.call @_ZN2cl4sycl5rangeILi2EEC2Ev({{.*}}) : ([[THIS_PTR_TYPE]]) -> () + sycl.constructor @range(%arg0) {MangledFunctionName = @_ZN2cl4sycl5rangeILi2EEC2Ev} : (memref) + return +} + +// ----- + +!sycl_range_3_ = !sycl.range<[3], (!sycl.array<[3], (memref<2xi64, 4>)>)> +// CHECK: llvm.func @_ZN2cl4sycl5rangeILi3EEC2Ev([[THIS_PTR_TYPE:!llvm.ptr) + +func.func @range3Ctor(%arg0: memref) { + // CHECK: llvm.call @_ZN2cl4sycl5rangeILi3EEC2Ev({{.*}}) : ([[THIS_PTR_TYPE]]) -> () + sycl.constructor @range(%arg0) {MangledFunctionName = @_ZN2cl4sycl5rangeILi3EEC2Ev} : (memref) + return +} + +// ----- + +//===-------------------------------------------------------------------------------------------------===// +// Constructors for cl::sycl::range::range(std::enable_if<(n)==(n), unsigned long>::type) +//===-------------------------------------------------------------------------------------------------===// + +!sycl_range_1_ = !sycl.range<[1], (!sycl.array<[1], (memref<1xi64, 4>)>)> +// CHECK: llvm.func @_ZN2cl4sycl5rangeILi1EEC2ILi1EEENSt9enable_ifIXeqT_Li1EEmE4typeE([[THIS_PTR_TYPE:!llvm.ptr, i64) + +func.func @range1CtorSizeT(%arg0: memref, %arg1: i64) { + // CHECK: llvm.call @_ZN2cl4sycl5rangeILi1EEC2ILi1EEENSt9enable_ifIXeqT_Li1EEmE4typeE({{.*}}, {{.*}}) : ([[THIS_PTR_TYPE]], i64) -> () + sycl.constructor @range(%arg0, %arg1) {MangledFunctionName = @_ZN2cl4sycl5rangeILi1EEC2ILi1EEENSt9enable_ifIXeqT_Li1EEmE4typeE} : (memref, i64) + return +} + +// ----- + +!sycl_range_2_ = !sycl.range<[2], (!sycl.array<[2], (memref<2xi64, 4>)>)> +// CHECK: llvm.func @_ZN2cl4sycl5rangeILi2EEC2ILi2EEENSt9enable_ifIXeqT_Li2EEmE4typeE([[THIS_PTR_TYPE:!llvm.ptr, i64) + +func.func @range2CtorSizeT(%arg0: memref, %arg1: i64) { + // CHECK: llvm.call @_ZN2cl4sycl5rangeILi2EEC2ILi2EEENSt9enable_ifIXeqT_Li2EEmE4typeE({{.*}}, {{.*}}) : ([[THIS_PTR_TYPE]], i64) -> () + sycl.constructor @range(%arg0, %arg1) {MangledFunctionName = @_ZN2cl4sycl5rangeILi2EEC2ILi2EEENSt9enable_ifIXeqT_Li2EEmE4typeE} : (memref, i64) + return +} + +// ----- + +!sycl_range_3_ = !sycl.range<[3], (!sycl.array<[3], (memref<2xi64, 4>)>)> +// CHECK: llvm.func @_ZN2cl4sycl5rangeILi3EEC2ILi3EEENSt9enable_ifIXeqT_Li3EEmE4typeE([[THIS_PTR_TYPE:!llvm.ptr, i64) + +func.func @range3CtorSizeT(%arg0: memref, %arg1: i64) { + // CHECK: llvm.call @_ZN2cl4sycl5rangeILi3EEC2ILi3EEENSt9enable_ifIXeqT_Li3EEmE4typeE({{.*}}, {{.*}}) : ([[THIS_PTR_TYPE]], i64) -> () + sycl.constructor @range(%arg0, %arg1) {MangledFunctionName = @_ZN2cl4sycl5rangeILi3EEC2ILi3EEENSt9enable_ifIXeqT_Li3EEmE4typeE} : (memref, i64) + return +} + +// ----- + +//===-------------------------------------------------------------------------------------------------===// +// Constructors for cl::sycl::range::range(std::enable_if<(n)==(n), unsigned long>::type, unsigned long) +//===-------------------------------------------------------------------------------------------------===// + +!sycl_range_1_ = !sycl.range<[1], (!sycl.array<[1], (memref<1xi64, 4>)>)> +// CHECK: llvm.func @_ZN2cl4sycl5rangeILi1EEC2ILi1EEENSt9enable_ifIXeqT_Li1EEmE4typeEm([[THIS_PTR_TYPE:!llvm.ptr, i64, i64) + +func.func @range1Ctor2SizeT(%arg0: memref, %arg1: i64, %arg2: i64) { + // CHECK: llvm.call @_ZN2cl4sycl5rangeILi1EEC2ILi1EEENSt9enable_ifIXeqT_Li1EEmE4typeEm({{.*}}, {{.*}}, {{.*}}) : ([[THIS_PTR_TYPE]], i64, i64) -> () + sycl.constructor @range(%arg0, %arg1, %arg2) {MangledFunctionName = @_ZN2cl4sycl5rangeILi1EEC2ILi1EEENSt9enable_ifIXeqT_Li1EEmE4typeEm} : (memref, i64, i64) + return +} + +// ----- + +!sycl_range_2_ = !sycl.range<[2], (!sycl.array<[2], (memref<2xi64, 4>)>)> +// CHECK: llvm.func @_ZN2cl4sycl5rangeILi2EEC2ILi2EEENSt9enable_ifIXeqT_Li2EEmE4typeEm([[THIS_PTR_TYPE:!llvm.ptr, i64, i64) + +func.func @range2Ctor2SizeT(%arg0: memref, %arg1: i64, %arg2: i64) { + // CHECK: llvm.call @_ZN2cl4sycl5rangeILi2EEC2ILi2EEENSt9enable_ifIXeqT_Li2EEmE4typeEm({{.*}}, {{.*}}, {{.*}}) : ([[THIS_PTR_TYPE]], i64, i64) -> () + sycl.constructor @range(%arg0, %arg1, %arg2) {MangledFunctionName = @_ZN2cl4sycl5rangeILi2EEC2ILi2EEENSt9enable_ifIXeqT_Li2EEmE4typeEm} : (memref, i64, i64) + return +} + +// ----- + +!sycl_range_3_ = !sycl.range<[3], (!sycl.array<[3], (memref<2xi64, 4>)>)> +// CHECK: llvm.func @_ZN2cl4sycl5rangeILi3EEC2ILi3EEENSt9enable_ifIXeqT_Li3EEmE4typeEm([[THIS_PTR_TYPE:!llvm.ptr, i64, i64) + +func.func @range3Ctor2SizeT(%arg0: memref, %arg1: i64, %arg2: i64) { + // CHECK: llvm.call @_ZN2cl4sycl5rangeILi3EEC2ILi3EEENSt9enable_ifIXeqT_Li3EEmE4typeEm({{.*}}, {{.*}}, {{.*}}) : ([[THIS_PTR_TYPE]], i64, i64) -> () + sycl.constructor @range(%arg0, %arg1, %arg2) {MangledFunctionName = @_ZN2cl4sycl5rangeILi3EEC2ILi3EEENSt9enable_ifIXeqT_Li3EEmE4typeEm} : (memref, i64, i64) + return +} + +// ----- + +//===-------------------------------------------------------------------------------------------------===// +// Constructors for cl::sycl::range::range(std::enable_if<(n)==(n), unsigned long>::type, unsigned long, unsigned long) +//===-------------------------------------------------------------------------------------------------===// + +!sycl_range_1_ = !sycl.range<[1], (!sycl.array<[1], (memref<1xi64, 4>)>)> +// CHECK: llvm.func @_ZN2cl4sycl5rangeILi1EEC2ILi1EEENSt9enable_ifIXeqT_Li1EEmE4typeEmm([[THIS_PTR_TYPE:!llvm.ptr, i64, i64, i64) + +func.func @range1Ctor3SizeT(%arg0: memref, %arg1: i64, %arg2: i64, %arg3: i64) { + // CHECK: llvm.call @_ZN2cl4sycl5rangeILi1EEC2ILi1EEENSt9enable_ifIXeqT_Li1EEmE4typeEmm({{.*}}, {{.*}}, {{.*}}, {{.*}}) : ([[THIS_PTR_TYPE]], i64, i64, i64) -> () + sycl.constructor @range(%arg0, %arg1, %arg2, %arg3) {MangledFunctionName = @_ZN2cl4sycl5rangeILi1EEC2ILi1EEENSt9enable_ifIXeqT_Li1EEmE4typeEmm} : (memref, i64, i64, i64) + return +} + +// ----- + +!sycl_range_2_ = !sycl.range<[2], (!sycl.array<[2], (memref<2xi64, 4>)>)> +// CHECK: llvm.func @_ZN2cl4sycl5rangeILi2EEC2ILi2EEENSt9enable_ifIXeqT_Li2EEmE4typeEmm([[THIS_PTR_TYPE:!llvm.ptr, i64, i64, i64) + +func.func @range2Ctor3SizeT(%arg0: memref, %arg1: i64, %arg2: i64, %arg3: i64) { + // CHECK: llvm.call @_ZN2cl4sycl5rangeILi2EEC2ILi2EEENSt9enable_ifIXeqT_Li2EEmE4typeEmm({{.*}}, {{.*}}, {{.*}}, {{.*}}) : ([[THIS_PTR_TYPE]], i64, i64, i64) -> () + sycl.constructor @range(%arg0, %arg1, %arg2, %arg3) {MangledFunctionName = @_ZN2cl4sycl5rangeILi2EEC2ILi2EEENSt9enable_ifIXeqT_Li2EEmE4typeEmm} : (memref, i64, i64, i64) + return +} + +// ----- + +!sycl_range_3_ = !sycl.range<[3], (!sycl.array<[3], (memref<2xi64, 4>)>)> +// CHECK: llvm.func @_ZN2cl4sycl5rangeILi3EEC2ILi3EEENSt9enable_ifIXeqT_Li3EEmE4typeEmm([[THIS_PTR_TYPE:!llvm.ptr, i64, i64, i64) + +func.func @range3Ctor3SizeT(%arg0: memref, %arg1: i64, %arg2: i64, %arg3: i64) { + // CHECK: llvm.call @_ZN2cl4sycl5rangeILi3EEC2ILi3EEENSt9enable_ifIXeqT_Li3EEmE4typeEmm({{.*}}, {{.*}}, {{.*}}, {{.*}}) : ([[THIS_PTR_TYPE]], i64, i64, i64) -> () + sycl.constructor @range(%arg0, %arg1, %arg2, %arg3) {MangledFunctionName = @_ZN2cl4sycl5rangeILi3EEC2ILi3EEENSt9enable_ifIXeqT_Li3EEmE4typeEmm} : (memref, i64, i64, i64) + return +} + +// ----- + +//===-------------------------------------------------------------------------------------------------===// +// Constructors sycl::range::id(sycl::range const&, sycl::range const&) +//===-------------------------------------------------------------------------------------------------===// + +!sycl_range_1_ = !sycl.range<[1], (!sycl.array<[1], (memref<1xi64, 4>)>)> +// CHECK: llvm.func @_ZN2cl4sycl5rangeILi1EEC1ERKS2_([[THIS_PTR_TYPE:!llvm.ptr, memref) + +func.func @range1CopyCtor(%arg0: memref, %arg1: memref) { + // CHECK: llvm.call @_ZN2cl4sycl5rangeILi1EEC1ERKS2_({{.*}}, {{.*}}) : ([[THIS_PTR_TYPE]], [[THIS_PTR_TYPE]]) -> () + sycl.constructor @range(%arg0, %arg1) {MangledFunctionName = @_ZN2cl4sycl5rangeILi1EEC1ERKS2_} : (memref, memref) + return +} + +// ----- + +!sycl_range_2_ = !sycl.range<[2], (!sycl.array<[2], (memref<2xi64, 4>)>)> +// CHECK: llvm.func @_ZN2cl4sycl5rangeILi2EEC1ERKS2_([[THIS_PTR_TYPE:!llvm.ptr, memref) + +func.func @range2CopyCtor(%arg0: memref, %arg1: memref) { + // CHECK: llvm.call @_ZN2cl4sycl5rangeILi2EEC1ERKS2_({{.*}}, {{.*}}) : ([[THIS_PTR_TYPE]], [[THIS_PTR_TYPE]]) -> () + sycl.constructor @range(%arg0, %arg1) {MangledFunctionName = @_ZN2cl4sycl5rangeILi2EEC1ERKS2_} : (memref, memref) + return +} + +// ----- + +!sycl_range_3_ = !sycl.range<[3], (!sycl.array<[3], (memref<2xi64, 4>)>)> +// CHECK: llvm.func @_ZN2cl4sycl5rangeILi3EEC1ERKS2_([[THIS_PTR_TYPE:!llvm.ptr, memref) + +func.func @range3CopyCtor(%arg0: memref, %arg1: memref) { + // CHECK: llvm.call @_ZN2cl4sycl5rangeILi3EEC1ERKS2_({{.*}}, {{.*}}) : ([[THIS_PTR_TYPE]], [[THIS_PTR_TYPE]]) -> () + sycl.constructor @range(%arg0, %arg1) {MangledFunctionName = @_ZN2cl4sycl5rangeILi3EEC1ERKS2_} : (memref, memref) + return +} diff --git a/mlir-sycl/test/Conversion/SYCLToLLVM/sycl-constructor-to-llvm.mlir b/mlir-sycl/test/Conversion/SYCLToLLVM/sycl-constructor-to-llvm.mlir index c90e7cd0dfa7a..1c074b45577eb 100644 --- a/mlir-sycl/test/Conversion/SYCLToLLVM/sycl-constructor-to-llvm.mlir +++ b/mlir-sycl/test/Conversion/SYCLToLLVM/sycl-constructor-to-llvm.mlir @@ -1,4 +1,4 @@ -// RUN: sycl-mlir-opt -split-input-file -convert-sycl-to-llvm -verify-diagnostics %s | FileCheck %s +// RUN: sycl-mlir-opt -split-input-file -convert-sycl-to-llvm='use-opaque-pointers=1' -verify-diagnostics %s | FileCheck %s //===-------------------------------------------------------------------------------------------------===// // Constructors for sycl::accessor::accessor() @@ -6,9 +6,9 @@ !sycl_id_1_ = !sycl.id<[1], (!sycl.array<[1], (memref<1xi64, 4>)>)> !sycl_range_1_ = !sycl.range<[1], (!sycl.array<[1], (memref<1xi64, 4>)>)> -!sycl_accessor_1_i32_rw_gb = !sycl.accessor<[1, i32, read_write, global_buffer], (!sycl.accessor_impl_device<[1], (!sycl_id_1_, !sycl_range_1_, !sycl_range_1_)>, !llvm.struct<(ptr)>)> +!sycl_accessor_1_i32_rw_gb = !sycl.accessor<[1, i32, read_write, global_buffer], (!sycl.accessor_impl_device<[1], (!sycl_id_1_, !sycl_range_1_, !sycl_range_1_)>, !llvm.struct<(ptr<1>)>)> -// CHECK: llvm.func @_ZN2cl4sycl8accessorIiLi1ELNS0_6access4modeE1026ELNS2_6targetE2014ELNS2_11placeholderE0ENS0_3ext6oneapi22accessor_property_listIJEEEEC2Ev([[THIS_PTR_TYPE:!llvm.ptr) func.func @accessorInt1ReadWriteGlobalBufferFalseCtor(%arg0: memref) { @@ -24,7 +24,7 @@ func.func @accessorInt1ReadWriteGlobalBufferFalseCtor(%arg0: memref)>)> -// CHECK: llvm.func @_ZN2cl4sycl2idILi1EEC2Ev([[THIS_PTR_TYPE:!llvm.ptr) func.func @id1Ctor(%arg0: memref) { @@ -36,7 +36,7 @@ func.func @id1Ctor(%arg0: memref) { // ----- !sycl_id_2_ = !sycl.id<[2], (!sycl.array<[2], (memref<2xi64, 4>)>)> -// CHECK: llvm.func @_ZN2cl4sycl2idILi2EEC2Ev([[THIS_PTR_TYPE:!llvm.ptr) func.func @id2Ctor(%arg0: memref) { @@ -48,7 +48,7 @@ func.func @id2Ctor(%arg0: memref) { // ----- !sycl_id_3_ = !sycl.id<[3], (!sycl.array<[3], (memref<3xi64, 4>)>)> -// CHECK: llvm.func @_ZN2cl4sycl2idILi3EEC2Ev([[THIS_PTR_TYPE:!llvm.ptr) func.func @id3Ctor(%arg0: memref) { @@ -64,7 +64,7 @@ func.func @id3Ctor(%arg0: memref) { //===-------------------------------------------------------------------------------------------------===// !sycl_id_1_ = !sycl.id<[1], (!sycl.array<[1], (memref<1xi64, 4>)>)> -// CHECK: llvm.func @_ZN2cl4sycl2idILi1EEC2ILi1EEENSt9enable_ifIXeqT_Li1EEmE4typeE([[THIS_PTR_TYPE:!llvm.ptr, i64) func.func @id1CtorSizeT(%arg0: memref, %arg1: i64) { @@ -76,7 +76,7 @@ func.func @id1CtorSizeT(%arg0: memref, %arg1: i64) { // ----- !sycl_id_2_ = !sycl.id<[2], (!sycl.array<[2], (memref<2xi64, 4>)>)> -// CHECK: llvm.func @_ZN2cl4sycl2idILi2EEC2ILi2EEENSt9enable_ifIXeqT_Li2EEmE4typeE([[THIS_PTR_TYPE:!llvm.ptr, i64) func.func @id2CtorSizeT(%arg0: memref, %arg1: i64) { @@ -88,7 +88,7 @@ func.func @id2CtorSizeT(%arg0: memref, %arg1: i64) { // ----- !sycl_id_3_ = !sycl.id<[3], (!sycl.array<[3], (memref<3xi64, 4>)>)> -// CHECK: llvm.func @_ZN2cl4sycl2idILi3EEC2ILi3EEENSt9enable_ifIXeqT_Li3EEmE4typeE([[THIS_PTR_TYPE:!llvm.ptr, i64) func.func @id3CtorSizeT(%arg0: memref, %arg1: i64) { @@ -104,7 +104,7 @@ func.func @id3CtorSizeT(%arg0: memref, %arg1: i64) { //===-------------------------------------------------------------------------------------------------===// !sycl_id_1_ = !sycl.id<[1], (!sycl.array<[1], (memref<1xi64, 4>)>)> -// CHECK: llvm.func @_ZN2cl4sycl2idILi1EEC2ILi1EEENSt9enable_ifIXeqT_Li1EEmE4typeEm([[THIS_PTR_TYPE:!llvm.ptr, i64, i64) func.func @id1CtorRange(%arg0: memref, %arg1: i64, %arg2: i64) { @@ -116,7 +116,7 @@ func.func @id1CtorRange(%arg0: memref, %arg1: i64, %arg2: i64) { // ----- !sycl_id_2_ = !sycl.id<[2], (!sycl.array<[2], (memref<2xi64, 4>)>)> -// CHECK: llvm.func @_ZN2cl4sycl2idILi2EEC2ILi2EEENSt9enable_ifIXeqT_Li2EEmE4typeEm([[THIS_PTR_TYPE:!llvm.ptr, i64, i64) func.func @id2CtorRange(%arg0: memref, %arg1: i64, %arg2: i64) { @@ -128,7 +128,7 @@ func.func @id2CtorRange(%arg0: memref, %arg1: i64, %arg2: i64) { // ----- !sycl_id_3_ = !sycl.id<[3], (!sycl.array<[3], (memref<3xi64, 4>)>)> -// CHECK: llvm.func @_ZN2cl4sycl2idILi3EEC2ILi3EEENSt9enable_ifIXeqT_Li3EEmE4typeEm([[THIS_PTR_TYPE:!llvm.ptr, i64, i64) func.func @id3CtorRange(%arg0: memref, %arg1: i64, %arg2: i64) { @@ -144,7 +144,7 @@ func.func @id3CtorRange(%arg0: memref, %arg1: i64, %arg2: i64) { //===-------------------------------------------------------------------------------------------------===// !sycl_id_1_ = !sycl.id<[1], (!sycl.array<[1], (memref<1xi64, 4>)>)> -// CHECK: llvm.func @_ZN2cl4sycl2idILi1EEC2ILi1EEENSt9enable_ifIXeqT_Li1EEmE4typeEmm([[THIS_PTR_TYPE:!llvm.ptr, i64, i64, i64) func.func @id1CtorItem(%arg0: memref, %arg1: i64, %arg2: i64, %arg3: i64) { @@ -156,7 +156,7 @@ func.func @id1CtorItem(%arg0: memref, %arg1: i64, %arg2: i64, %ar // ----- !sycl_id_2_ = !sycl.id<[2], (!sycl.array<[2], (memref<2xi64, 4>)>)> -// CHECK: llvm.func @_ZN2cl4sycl2idILi2EEC2ILi2EEENSt9enable_ifIXeqT_Li2EEmE4typeEmm([[THIS_PTR_TYPE:!llvm.ptr, i64, i64, i64) func.func @id2CtorItem(%arg0: memref, %arg1: i64, %arg2: i64, %arg3: i64) { @@ -168,7 +168,7 @@ func.func @id2CtorItem(%arg0: memref, %arg1: i64, %arg2: i64, %ar // ----- !sycl_id_3_ = !sycl.id<[3], (!sycl.array<[3], (memref<3xi64, 4>)>)> -// CHECK: llvm.func @_ZN2cl4sycl2idILi3EEC2ILi3EEENSt9enable_ifIXeqT_Li3EEmE4typeEmm([[THIS_PTR_TYPE:!llvm.ptr, i64, i64, i64) func.func @id3CtorItem(%arg0: memref, %arg1: i64, %arg2: i64, %arg3: i64) { @@ -184,7 +184,7 @@ func.func @id3CtorItem(%arg0: memref, %arg1: i64, %arg2: i64, %ar //===-------------------------------------------------------------------------------------------------===// !sycl_id_1_ = !sycl.id<[1], (!sycl.array<[1], (memref<1xi64, 4>)>)> -// CHECK: llvm.func @_ZN2cl4sycl2idILi1EEC1ERKS2_([[THIS_PTR_TYPE:!llvm.ptr, memref) func.func @id1CopyCtor(%arg0: memref, %arg1: memref) { @@ -196,7 +196,7 @@ func.func @id1CopyCtor(%arg0: memref, %arg1: memref)>)> -// CHECK: llvm.func @_ZN2cl4sycl2idILi2EEC1ERKS2_([[THIS_PTR_TYPE:!llvm.ptr, memref) func.func @id2CopyCtor(%arg0: memref, %arg1: memref) { @@ -208,7 +208,7 @@ func.func @id2CopyCtor(%arg0: memref, %arg1: memref)>)> -// CHECK: llvm.func @_ZN2cl4sycl2idILi3EEC1ERKS2_([[THIS_PTR_TYPE:!llvm.ptr, memref) func.func @id3CopyCtor(%arg0: memref, %arg1: memref) { @@ -224,7 +224,7 @@ func.func @id3CopyCtor(%arg0: memref, %arg1: memref)>)> -// CHECK: llvm.func @_ZN2cl4sycl5rangeILi1EEC2Ev([[THIS_PTR_TYPE:!llvm.ptr) func.func @range1Ctor(%arg0: memref) { @@ -236,7 +236,7 @@ func.func @range1Ctor(%arg0: memref) { // ----- !sycl_range_2_ = !sycl.range<[2], (!sycl.array<[2], (memref<2xi64, 4>)>)> -// CHECK: llvm.func @_ZN2cl4sycl5rangeILi2EEC2Ev([[THIS_PTR_TYPE:!llvm.ptr) func.func @range2Ctor(%arg0: memref) { @@ -248,7 +248,7 @@ func.func @range2Ctor(%arg0: memref) { // ----- !sycl_range_3_ = !sycl.range<[3], (!sycl.array<[3], (memref<2xi64, 4>)>)> -// CHECK: llvm.func @_ZN2cl4sycl5rangeILi3EEC2Ev([[THIS_PTR_TYPE:!llvm.ptr) func.func @range3Ctor(%arg0: memref) { @@ -264,7 +264,7 @@ func.func @range3Ctor(%arg0: memref) { //===-------------------------------------------------------------------------------------------------===// !sycl_range_1_ = !sycl.range<[1], (!sycl.array<[1], (memref<1xi64, 4>)>)> -// CHECK: llvm.func @_ZN2cl4sycl5rangeILi1EEC2ILi1EEENSt9enable_ifIXeqT_Li1EEmE4typeE([[THIS_PTR_TYPE:!llvm.ptr, i64) func.func @range1CtorSizeT(%arg0: memref, %arg1: i64) { @@ -276,7 +276,7 @@ func.func @range1CtorSizeT(%arg0: memref, %arg1: i64) { // ----- !sycl_range_2_ = !sycl.range<[2], (!sycl.array<[2], (memref<2xi64, 4>)>)> -// CHECK: llvm.func @_ZN2cl4sycl5rangeILi2EEC2ILi2EEENSt9enable_ifIXeqT_Li2EEmE4typeE([[THIS_PTR_TYPE:!llvm.ptr, i64) func.func @range2CtorSizeT(%arg0: memref, %arg1: i64) { @@ -288,7 +288,7 @@ func.func @range2CtorSizeT(%arg0: memref, %arg1: i64) { // ----- !sycl_range_3_ = !sycl.range<[3], (!sycl.array<[3], (memref<2xi64, 4>)>)> -// CHECK: llvm.func @_ZN2cl4sycl5rangeILi3EEC2ILi3EEENSt9enable_ifIXeqT_Li3EEmE4typeE([[THIS_PTR_TYPE:!llvm.ptr, i64) func.func @range3CtorSizeT(%arg0: memref, %arg1: i64) { @@ -304,7 +304,7 @@ func.func @range3CtorSizeT(%arg0: memref, %arg1: i64) { //===-------------------------------------------------------------------------------------------------===// !sycl_range_1_ = !sycl.range<[1], (!sycl.array<[1], (memref<1xi64, 4>)>)> -// CHECK: llvm.func @_ZN2cl4sycl5rangeILi1EEC2ILi1EEENSt9enable_ifIXeqT_Li1EEmE4typeEm([[THIS_PTR_TYPE:!llvm.ptr, i64, i64) func.func @range1Ctor2SizeT(%arg0: memref, %arg1: i64, %arg2: i64) { @@ -316,7 +316,7 @@ func.func @range1Ctor2SizeT(%arg0: memref, %arg1: i64, %arg2: // ----- !sycl_range_2_ = !sycl.range<[2], (!sycl.array<[2], (memref<2xi64, 4>)>)> -// CHECK: llvm.func @_ZN2cl4sycl5rangeILi2EEC2ILi2EEENSt9enable_ifIXeqT_Li2EEmE4typeEm([[THIS_PTR_TYPE:!llvm.ptr, i64, i64) func.func @range2Ctor2SizeT(%arg0: memref, %arg1: i64, %arg2: i64) { @@ -328,7 +328,7 @@ func.func @range2Ctor2SizeT(%arg0: memref, %arg1: i64, %arg2: // ----- !sycl_range_3_ = !sycl.range<[3], (!sycl.array<[3], (memref<2xi64, 4>)>)> -// CHECK: llvm.func @_ZN2cl4sycl5rangeILi3EEC2ILi3EEENSt9enable_ifIXeqT_Li3EEmE4typeEm([[THIS_PTR_TYPE:!llvm.ptr, i64, i64) func.func @range3Ctor2SizeT(%arg0: memref, %arg1: i64, %arg2: i64) { @@ -344,7 +344,7 @@ func.func @range3Ctor2SizeT(%arg0: memref, %arg1: i64, %arg2: //===-------------------------------------------------------------------------------------------------===// !sycl_range_1_ = !sycl.range<[1], (!sycl.array<[1], (memref<1xi64, 4>)>)> -// CHECK: llvm.func @_ZN2cl4sycl5rangeILi1EEC2ILi1EEENSt9enable_ifIXeqT_Li1EEmE4typeEmm([[THIS_PTR_TYPE:!llvm.ptr, i64, i64, i64) func.func @range1Ctor3SizeT(%arg0: memref, %arg1: i64, %arg2: i64, %arg3: i64) { @@ -356,7 +356,7 @@ func.func @range1Ctor3SizeT(%arg0: memref, %arg1: i64, %arg2: // ----- !sycl_range_2_ = !sycl.range<[2], (!sycl.array<[2], (memref<2xi64, 4>)>)> -// CHECK: llvm.func @_ZN2cl4sycl5rangeILi2EEC2ILi2EEENSt9enable_ifIXeqT_Li2EEmE4typeEmm([[THIS_PTR_TYPE:!llvm.ptr, i64, i64, i64) func.func @range2Ctor3SizeT(%arg0: memref, %arg1: i64, %arg2: i64, %arg3: i64) { @@ -368,7 +368,7 @@ func.func @range2Ctor3SizeT(%arg0: memref, %arg1: i64, %arg2: // ----- !sycl_range_3_ = !sycl.range<[3], (!sycl.array<[3], (memref<2xi64, 4>)>)> -// CHECK: llvm.func @_ZN2cl4sycl5rangeILi3EEC2ILi3EEENSt9enable_ifIXeqT_Li3EEmE4typeEmm([[THIS_PTR_TYPE:!llvm.ptr, i64, i64, i64) func.func @range3Ctor3SizeT(%arg0: memref, %arg1: i64, %arg2: i64, %arg3: i64) { @@ -384,7 +384,7 @@ func.func @range3Ctor3SizeT(%arg0: memref, %arg1: i64, %arg2: //===-------------------------------------------------------------------------------------------------===// !sycl_range_1_ = !sycl.range<[1], (!sycl.array<[1], (memref<1xi64, 4>)>)> -// CHECK: llvm.func @_ZN2cl4sycl5rangeILi1EEC1ERKS2_([[THIS_PTR_TYPE:!llvm.ptr, memref) func.func @range1CopyCtor(%arg0: memref, %arg1: memref) { @@ -396,7 +396,7 @@ func.func @range1CopyCtor(%arg0: memref, %arg1: memref)>)> -// CHECK: llvm.func @_ZN2cl4sycl5rangeILi2EEC1ERKS2_([[THIS_PTR_TYPE:!llvm.ptr, memref) func.func @range2CopyCtor(%arg0: memref, %arg1: memref) { @@ -408,7 +408,7 @@ func.func @range2CopyCtor(%arg0: memref, %arg1: memref)>)> -// CHECK: llvm.func @_ZN2cl4sycl5rangeILi3EEC1ERKS2_([[THIS_PTR_TYPE:!llvm.ptr, memref) func.func @range3CopyCtor(%arg0: memref, %arg1: memref) { diff --git a/mlir-sycl/test/Conversion/SYCLToLLVM/sycl-methods-flat-to-llvm-typed-pointer.mlir b/mlir-sycl/test/Conversion/SYCLToLLVM/sycl-methods-flat-to-llvm-typed-pointer.mlir new file mode 100644 index 0000000000000..b44ce11a0afa9 --- /dev/null +++ b/mlir-sycl/test/Conversion/SYCLToLLVM/sycl-methods-flat-to-llvm-typed-pointer.mlir @@ -0,0 +1,164 @@ +// RUN: sycl-mlir-opt -split-input-file -convert-sycl-to-llvm='use-opaque-pointers=0' %s | FileCheck %s + +//===----------------------------------------------------------------------===// +// sycl.range.get with reference result type +//===----------------------------------------------------------------------===// + +!sycl_range_3_ = !sycl.range<[3], (!sycl.array<[3], (memref<3xi64>)>)> + +// CHECK-LABEL: llvm.func @test( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[RANGE3:.*]]>, +// CHECK-SAME: %[[VAL_1:.*]]: i32) -> !llvm.ptr { +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.addrspacecast %[[VAL_0]] : !llvm.ptr<[[RANGE3]]> to !llvm.ptr<[[RANGE3]], 4> +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.getelementptr inbounds %[[VAL_2]][0, 0, 0, %[[VAL_1]]] : (!llvm.ptr<[[RANGE3]], 4>, i32) -> !llvm.ptr +// CHECK-NEXT: llvm.return %[[VAL_3]] : !llvm.ptr +// CHECK-NEXT: } +func.func @test(%range: memref, %idx: i32) -> memref { + %0 = sycl.range.get %range[%idx] { ArgumentTypes = [memref, i32], FunctionName = @"operator[]", MangledFunctionName = @"operator[]", TypeName = @"range" } : (memref, i32) -> memref + return %0 : memref +} + +// ----- + +//===----------------------------------------------------------------------===// +// sycl.id.get with reference result type +//===----------------------------------------------------------------------===// + +!sycl_id_3_ = !sycl.id<[3], (!sycl.array<[3], (memref<3xi64>)>)> + +// CHECK-LABEL: llvm.func @test( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[ID3:.*]]>, +// CHECK-SAME: %[[VAL_1:.*]]: i32) -> !llvm.ptr { +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.addrspacecast %[[VAL_0]] : !llvm.ptr<[[ID3]]> to !llvm.ptr<[[ID3]], 4> +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.getelementptr inbounds %[[VAL_2]][0, 0, 0, %[[VAL_1]]] : (!llvm.ptr<[[ID3]], 4>, i32) -> !llvm.ptr +// CHECK-NEXT: llvm.return %[[VAL_3]] : !llvm.ptr +// CHECK-NEXT: } +func.func @test(%id: memref, %idx: i32) -> memref { + %0 = sycl.id.get %id[%idx] { ArgumentTypes = [memref, i32], FunctionName = @"operator[]", MangledFunctionName = @"operator[]", TypeName = @"id" } : (memref, i32) -> memref + return %0 : memref +} + +// ----- + +//===----------------------------------------------------------------------===// +// sycl.accessor.subscript with scalar offset and 1D accessor +//===----------------------------------------------------------------------===// + +!sycl_id_1_ = !sycl.id<[1], (!sycl.array<[1], (memref<1xi64>)>)> +!sycl_range_1_ = !sycl.range<[1], (!sycl.array<[1], (memref<1xi64>)>)> +!sycl_accessor_impl_device_1_ = !sycl.accessor_impl_device<[1], (!sycl_id_1_, !sycl_range_1_, !sycl_range_1_)> +!sycl_accessor_1_i32_rw_gb = !sycl.accessor<[1, i32, read_write, global_buffer], (!sycl_accessor_impl_device_1_, !llvm.struct<(ptr)>)> + +// CHECK-LABEL: llvm.func @test( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[ACCESSOR1:.*]]>, +// CHECK-SAME: %[[VAL_1:.*]]: i64) -> !llvm.ptr { +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0] : (!llvm.ptr<[[ACCESSOR1]]>) -> !llvm.ptr> +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.load %[[VAL_2]] : !llvm.ptr> +// CHECK-NEXT: %[[VAL_4:.*]] = llvm.getelementptr inbounds %[[VAL_3]][%[[VAL_1]]] : (!llvm.ptr, i64) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_5:.*]] = llvm.addrspacecast %[[VAL_4]] : !llvm.ptr to !llvm.ptr +// CHECK-NEXT: llvm.return %[[VAL_5]] : !llvm.ptr +// CHECK-NEXT: } +func.func @test(%acc: memref, %idx: i64) -> memref { + %0 = sycl.accessor.subscript %acc[%idx] { ArgumentTypes = [memref, i64], FunctionName = @"operator[]", MangledFunctionName = @"operator[]", TypeName = @"id" } : (memref, i64) -> memref + return %0 : memref +} + +// ----- + +//===----------------------------------------------------------------------===// +// sycl.accessor.subscript with id offset +//===----------------------------------------------------------------------===// + +!sycl_id_1_ = !sycl.id<[1], (!sycl.array<[1], (memref<1xi64>)>)> +!sycl_range_1_ = !sycl.range<[1], (!sycl.array<[1], (memref<1xi64>)>)> +!sycl_accessor_impl_device_1_ = !sycl.accessor_impl_device<[1], (!sycl_id_1_, !sycl_range_1_, !sycl_range_1_)> +!sycl_accessor_1_i32_rw_gb = !sycl.accessor<[1, i32, read_write, global_buffer], (!sycl_accessor_impl_device_1_, !llvm.struct<(ptr)>)> +!sycl_id_2_ = !sycl.id<[2], (!sycl.array<[2], (memref<2xi64>)>)> +!sycl_range_2_ = !sycl.range<[2], (!sycl.array<[2], (memref<2xi64>)>)> +!sycl_accessor_impl_device_2_ = !sycl.accessor_impl_device<[2], (!sycl_id_2_, !sycl_range_2_, !sycl_range_2_)> +!sycl_accessor_2_i32_rw_gb = !sycl.accessor<[2, i32, read_write, global_buffer], (!sycl_accessor_impl_device_2_, !llvm.struct<(ptr)>)> +!sycl_id_3_ = !sycl.id<[3], (!sycl.array<[3], (memref<3xi64>)>)> +!sycl_range_3_ = !sycl.range<[3], (!sycl.array<[3], (memref<3xi64>)>)> +!sycl_accessor_impl_device_3_ = !sycl.accessor_impl_device<[3], (!sycl_id_3_, !sycl_range_3_, !sycl_range_3_)> +!sycl_accessor_3_i32_rw_gb = !sycl.accessor<[3, i32, read_write, global_buffer], (!sycl_accessor_impl_device_3_, !llvm.struct<(ptr)>)> + +// CHECK-LABEL: llvm.func @test_1( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[ACCESSOR1]]>, +// CHECK-SAME: %[[VAL_1:.*]]: !llvm.ptr<[[ID1:.*]]>) -> !llvm.ptr { +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.mlir.constant(0 : i64) : i64 +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 2, 0, 0, 0] : (!llvm.ptr<[[ACCESSOR1]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_4:.*]] = llvm.load %[[VAL_3]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_5:.*]] = llvm.getelementptr inbounds %[[VAL_1]][0, 0, 0, 0] : (!llvm.ptr<[[ID1]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_6:.*]] = llvm.load %[[VAL_5]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_7:.*]] = llvm.mul %[[VAL_2]], %[[VAL_4]] : i64 +// CHECK-NEXT: %[[VAL_8:.*]] = llvm.add %[[VAL_7]], %[[VAL_6]] : i64 +// CHECK-NEXT: %[[VAL_9:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0] : (!llvm.ptr<[[ACCESSOR1]]>) -> !llvm.ptr> +// CHECK-NEXT: %[[VAL_10:.*]] = llvm.load %[[VAL_9]] : !llvm.ptr> +// CHECK-NEXT: %[[VAL_11:.*]] = llvm.getelementptr inbounds %[[VAL_10]][%[[VAL_8]]] : (!llvm.ptr, i64) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_12:.*]] = llvm.addrspacecast %[[VAL_11]] : !llvm.ptr to !llvm.ptr +// CHECK-NEXT: llvm.return %[[VAL_12]] : !llvm.ptr +// CHECK-NEXT: } +func.func @test_1(%acc: memref, %idx: memref) -> memref { + %0 = sycl.accessor.subscript %acc[%idx] { ArgumentTypes = [memref, memref], FunctionName = @"operator[]", MangledFunctionName = @"operator[]", TypeName = @"id" } : (memref, memref) -> memref + return %0 : memref +} + +// CHECK-LABEL: llvm.func @test_2( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[ACCESSOR2:.*]]>, +// CHECK-SAME: %[[VAL_1:.*]]: !llvm.ptr<[[ID2:.*]]>) -> !llvm.ptr { +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.mlir.constant(0 : i64) : i64 +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 2, 0, 0, 0] : (!llvm.ptr<[[ACCESSOR2]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_4:.*]] = llvm.load %[[VAL_3]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_5:.*]] = llvm.getelementptr inbounds %[[VAL_1]][0, 0, 0, 0] : (!llvm.ptr<[[ID2]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_6:.*]] = llvm.load %[[VAL_5]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_7:.*]] = llvm.mul %[[VAL_2]], %[[VAL_4]] : i64 +// CHECK-NEXT: %[[VAL_8:.*]] = llvm.add %[[VAL_7]], %[[VAL_6]] : i64 +// CHECK-NEXT: %[[VAL_9:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 2, 0, 0, 1] : (!llvm.ptr<[[ACCESSOR2]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_10:.*]] = llvm.load %[[VAL_9]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_11:.*]] = llvm.getelementptr inbounds %[[VAL_1]][0, 0, 0, 1] : (!llvm.ptr<[[ID2]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_12:.*]] = llvm.load %[[VAL_11]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_13:.*]] = llvm.mul %[[VAL_8]], %[[VAL_10]] : i64 +// CHECK-NEXT: %[[VAL_14:.*]] = llvm.add %[[VAL_13]], %[[VAL_12]] : i64 +// CHECK-NEXT: %[[VAL_15:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0] : (!llvm.ptr<[[ACCESSOR2]]>) -> !llvm.ptr> +// CHECK-NEXT: %[[VAL_16:.*]] = llvm.load %[[VAL_15]] : !llvm.ptr> +// CHECK-NEXT: %[[VAL_17:.*]] = llvm.getelementptr inbounds %[[VAL_16]][%[[VAL_14]]] : (!llvm.ptr, i64) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_18:.*]] = llvm.addrspacecast %[[VAL_17]] : !llvm.ptr to !llvm.ptr +// CHECK-NEXT: llvm.return %[[VAL_18]] : !llvm.ptr +// CHECK-NEXT: } +func.func @test_2(%acc: memref, %idx: memref) -> memref { + %0 = sycl.accessor.subscript %acc[%idx] { ArgumentTypes = [memref, memref], FunctionName = @"operator[]", MangledFunctionName = @"operator[]", TypeName = @"id" } : (memref, memref) -> memref + return %0 : memref +} + +// CHECK-LABEL: llvm.func @test_3( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[ACCESSOR3:.*]]>, +// CHECK-SAME: %[[VAL_1:.*]]: !llvm.ptr<[[ID3]]>) -> !llvm.ptr { +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.mlir.constant(0 : i64) : i64 +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 2, 0, 0, 0] : (!llvm.ptr<[[ACCESSOR3]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_4:.*]] = llvm.load %[[VAL_3]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_5:.*]] = llvm.getelementptr inbounds %[[VAL_1]][0, 0, 0, 0] : (!llvm.ptr<[[ID3]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_6:.*]] = llvm.load %[[VAL_5]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_7:.*]] = llvm.mul %[[VAL_2]], %[[VAL_4]] : i64 +// CHECK-NEXT: %[[VAL_8:.*]] = llvm.add %[[VAL_7]], %[[VAL_6]] : i64 +// CHECK-NEXT: %[[VAL_9:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 2, 0, 0, 1] : (!llvm.ptr<[[ACCESSOR3]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_10:.*]] = llvm.load %[[VAL_9]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_11:.*]] = llvm.getelementptr inbounds %[[VAL_1]][0, 0, 0, 1] : (!llvm.ptr<[[ID3]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_12:.*]] = llvm.load %[[VAL_11]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_13:.*]] = llvm.mul %[[VAL_8]], %[[VAL_10]] : i64 +// CHECK-NEXT: %[[VAL_14:.*]] = llvm.add %[[VAL_13]], %[[VAL_12]] : i64 +// CHECK-NEXT: %[[VAL_15:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 2, 0, 0, 2] : (!llvm.ptr<[[ACCESSOR3]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_16:.*]] = llvm.load %[[VAL_15]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_17:.*]] = llvm.getelementptr inbounds %[[VAL_1]][0, 0, 0, 2] : (!llvm.ptr<[[ID3]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_18:.*]] = llvm.load %[[VAL_17]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_19:.*]] = llvm.mul %[[VAL_14]], %[[VAL_16]] : i64 +// CHECK-NEXT: %[[VAL_20:.*]] = llvm.add %[[VAL_19]], %[[VAL_18]] : i64 +// CHECK-NEXT: %[[VAL_21:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0] : (!llvm.ptr<[[ACCESSOR3]]>) -> !llvm.ptr> +// CHECK-NEXT: %[[VAL_22:.*]] = llvm.load %[[VAL_21]] : !llvm.ptr> +// CHECK-NEXT: %[[VAL_23:.*]] = llvm.getelementptr inbounds %[[VAL_22]][%[[VAL_20]]] : (!llvm.ptr, i64) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_24:.*]] = llvm.addrspacecast %[[VAL_23]] : !llvm.ptr to !llvm.ptr +// CHECK-NEXT: llvm.return %[[VAL_24]] : !llvm.ptr +// CHECK-NEXT: } +func.func @test_3(%acc: memref, %idx: memref) -> memref { + %0 = sycl.accessor.subscript %acc[%idx] { ArgumentTypes = [memref, memref], FunctionName = @"operator[]", MangledFunctionName = @"operator[]", TypeName = @"id" } : (memref, memref) -> memref + return %0 : memref +} diff --git a/mlir-sycl/test/Conversion/SYCLToLLVM/sycl-methods-flat-to-llvm.mlir b/mlir-sycl/test/Conversion/SYCLToLLVM/sycl-methods-flat-to-llvm.mlir index c88323f53c479..aae351bbdf2e6 100644 --- a/mlir-sycl/test/Conversion/SYCLToLLVM/sycl-methods-flat-to-llvm.mlir +++ b/mlir-sycl/test/Conversion/SYCLToLLVM/sycl-methods-flat-to-llvm.mlir @@ -1,4 +1,4 @@ -// RUN: sycl-mlir-opt -split-input-file -convert-sycl-to-llvm %s | FileCheck %s +// RUN: sycl-mlir-opt -split-input-file -convert-sycl-to-llvm='use-opaque-pointers=1' %s | FileCheck %s //===----------------------------------------------------------------------===// // sycl.range.get with reference result type @@ -7,11 +7,11 @@ !sycl_range_3_ = !sycl.range<[3], (!sycl.array<[3], (memref<3xi64>)>)> // CHECK-LABEL: llvm.func @test( -// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[RANGE3:.*]]>, -// CHECK-SAME: %[[VAL_1:.*]]: i32) -> !llvm.ptr { -// CHECK-NEXT: %[[VAL_2:.*]] = llvm.addrspacecast %[[VAL_0]] : !llvm.ptr<[[RANGE3]]> to !llvm.ptr<[[RANGE3]], 4> -// CHECK-NEXT: %[[VAL_3:.*]] = llvm.getelementptr inbounds %[[VAL_2]][0, 0, 0, %[[VAL_1]]] : (!llvm.ptr<[[RANGE3]], 4>, i32) -> !llvm.ptr -// CHECK-NEXT: llvm.return %[[VAL_3]] : !llvm.ptr +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr, +// CHECK-SAME: %[[VAL_1:.*]]: i32) -> !llvm.ptr<4> { +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.addrspacecast %[[VAL_0]] : !llvm.ptr to !llvm.ptr<4> +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.getelementptr inbounds %[[VAL_2]][0, 0, 0, %[[VAL_1]]] : (!llvm.ptr<4>, i32) -> !llvm.ptr<4>, i64 +// CHECK-NEXT: llvm.return %[[VAL_3]] : !llvm.ptr<4> // CHECK-NEXT: } func.func @test(%range: memref, %idx: i32) -> memref { %0 = sycl.range.get %range[%idx] { ArgumentTypes = [memref, i32], FunctionName = @"operator[]", MangledFunctionName = @"operator[]", TypeName = @"range" } : (memref, i32) -> memref @@ -27,11 +27,11 @@ func.func @test(%range: memref, %idx: i32) -> memref !sycl_id_3_ = !sycl.id<[3], (!sycl.array<[3], (memref<3xi64>)>)> // CHECK-LABEL: llvm.func @test( -// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[ID3:.*]]>, -// CHECK-SAME: %[[VAL_1:.*]]: i32) -> !llvm.ptr { -// CHECK-NEXT: %[[VAL_2:.*]] = llvm.addrspacecast %[[VAL_0]] : !llvm.ptr<[[ID3]]> to !llvm.ptr<[[ID3]], 4> -// CHECK-NEXT: %[[VAL_3:.*]] = llvm.getelementptr inbounds %[[VAL_2]][0, 0, 0, %[[VAL_1]]] : (!llvm.ptr<[[ID3]], 4>, i32) -> !llvm.ptr -// CHECK-NEXT: llvm.return %[[VAL_3]] : !llvm.ptr +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr, +// CHECK-SAME: %[[VAL_1:.*]]: i32) -> !llvm.ptr<4> { +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.addrspacecast %[[VAL_0]] : !llvm.ptr to !llvm.ptr<4> +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.getelementptr inbounds %[[VAL_2]][0, 0, 0, %[[VAL_1]]] : (!llvm.ptr<4>, i32) -> !llvm.ptr<4>, i64 +// CHECK-NEXT: llvm.return %[[VAL_3]] : !llvm.ptr<4> // CHECK-NEXT: } func.func @test(%id: memref, %idx: i32) -> memref { %0 = sycl.id.get %id[%idx] { ArgumentTypes = [memref, i32], FunctionName = @"operator[]", MangledFunctionName = @"operator[]", TypeName = @"id" } : (memref, i32) -> memref @@ -50,13 +50,13 @@ func.func @test(%id: memref, %idx: i32) -> memref { !sycl_accessor_1_i32_rw_gb = !sycl.accessor<[1, i32, read_write, global_buffer], (!sycl_accessor_impl_device_1_, !llvm.struct<(ptr)>)> // CHECK-LABEL: llvm.func @test( -// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[ACCESSOR1:.*]]>, -// CHECK-SAME: %[[VAL_1:.*]]: i64) -> !llvm.ptr { -// CHECK-NEXT: %[[VAL_2:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0] : (!llvm.ptr<[[ACCESSOR1]]>) -> !llvm.ptr> -// CHECK-NEXT: %[[VAL_3:.*]] = llvm.load %[[VAL_2]] : !llvm.ptr> -// CHECK-NEXT: %[[VAL_4:.*]] = llvm.getelementptr inbounds %[[VAL_3]][%[[VAL_1]]] : (!llvm.ptr, i64) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_5:.*]] = llvm.addrspacecast %[[VAL_4]] : !llvm.ptr to !llvm.ptr -// CHECK-NEXT: llvm.return %[[VAL_5]] : !llvm.ptr +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr, +// CHECK-SAME: %[[VAL_1:.*]]: i64) -> !llvm.ptr<4> { +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0] : (!llvm.ptr) -> !llvm.ptr, !sycl_accessor_1_i32_rw_gb +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.load %[[VAL_2]] : !llvm.ptr -> !llvm.ptr<1> +// CHECK-NEXT: %[[VAL_4:.*]] = llvm.getelementptr inbounds %[[VAL_3]][%[[VAL_1]]] : (!llvm.ptr<1>, i64) -> !llvm.ptr<1>, i32 +// CHECK-NEXT: %[[VAL_5:.*]] = llvm.addrspacecast %[[VAL_4]] : !llvm.ptr<1> to !llvm.ptr<4> +// CHECK-NEXT: llvm.return %[[VAL_5]] : !llvm.ptr<4> // CHECK-NEXT: } func.func @test(%acc: memref, %idx: i64) -> memref { %0 = sycl.accessor.subscript %acc[%idx] { ArgumentTypes = [memref, i64], FunctionName = @"operator[]", MangledFunctionName = @"operator[]", TypeName = @"id" } : (memref, i64) -> memref @@ -83,20 +83,20 @@ func.func @test(%acc: memref, %idx: i64) -> memref !sycl_accessor_3_i32_rw_gb = !sycl.accessor<[3, i32, read_write, global_buffer], (!sycl_accessor_impl_device_3_, !llvm.struct<(ptr)>)> // CHECK-LABEL: llvm.func @test_1( -// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[ACCESSOR1]]>, -// CHECK-SAME: %[[VAL_1:.*]]: !llvm.ptr<[[ID1:.*]]>) -> !llvm.ptr { +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr, +// CHECK-SAME: %[[VAL_1:.*]]: !llvm.ptr) -> !llvm.ptr<4> { // CHECK-NEXT: %[[VAL_2:.*]] = llvm.mlir.constant(0 : i64) : i64 -// CHECK-NEXT: %[[VAL_3:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 2, 0, 0, 0] : (!llvm.ptr<[[ACCESSOR1]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_4:.*]] = llvm.load %[[VAL_3]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_5:.*]] = llvm.getelementptr inbounds %[[VAL_1]][0, 0, 0, 0] : (!llvm.ptr<[[ID1]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_6:.*]] = llvm.load %[[VAL_5]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 2, 0, 0, 0] : (!llvm.ptr) -> !llvm.ptr, !sycl_accessor_1_i32_rw_gb +// CHECK-NEXT: %[[VAL_4:.*]] = llvm.load %[[VAL_3]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_5:.*]] = llvm.getelementptr inbounds %[[VAL_1]][0, 0, 0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::id.1", {{.*}}> +// CHECK-NEXT: %[[VAL_6:.*]] = llvm.load %[[VAL_5]] : !llvm.ptr -> i64 // CHECK-NEXT: %[[VAL_7:.*]] = llvm.mul %[[VAL_2]], %[[VAL_4]] : i64 // CHECK-NEXT: %[[VAL_8:.*]] = llvm.add %[[VAL_7]], %[[VAL_6]] : i64 -// CHECK-NEXT: %[[VAL_9:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0] : (!llvm.ptr<[[ACCESSOR1]]>) -> !llvm.ptr> -// CHECK-NEXT: %[[VAL_10:.*]] = llvm.load %[[VAL_9]] : !llvm.ptr> -// CHECK-NEXT: %[[VAL_11:.*]] = llvm.getelementptr inbounds %[[VAL_10]][%[[VAL_8]]] : (!llvm.ptr, i64) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_12:.*]] = llvm.addrspacecast %[[VAL_11]] : !llvm.ptr to !llvm.ptr -// CHECK-NEXT: llvm.return %[[VAL_12]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_9:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0] : (!llvm.ptr) -> !llvm.ptr, !sycl_accessor_1_i32_rw_gb +// CHECK-NEXT: %[[VAL_10:.*]] = llvm.load %[[VAL_9]] : !llvm.ptr -> !llvm.ptr<1> +// CHECK-NEXT: %[[VAL_11:.*]] = llvm.getelementptr inbounds %[[VAL_10]][%[[VAL_8]]] : (!llvm.ptr<1>, i64) -> !llvm.ptr<1> +// CHECK-NEXT: %[[VAL_12:.*]] = llvm.addrspacecast %[[VAL_11]] : !llvm.ptr<1> to !llvm.ptr<4> +// CHECK-NEXT: llvm.return %[[VAL_12]] : !llvm.ptr<4> // CHECK-NEXT: } func.func @test_1(%acc: memref, %idx: memref) -> memref { %0 = sycl.accessor.subscript %acc[%idx] { ArgumentTypes = [memref, memref], FunctionName = @"operator[]", MangledFunctionName = @"operator[]", TypeName = @"id" } : (memref, memref) -> memref @@ -104,26 +104,26 @@ func.func @test_1(%acc: memref, %idx: memref, -// CHECK-SAME: %[[VAL_1:.*]]: !llvm.ptr<[[ID2:.*]]>) -> !llvm.ptr { +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr, +// CHECK-SAME: %[[VAL_1:.*]]: !llvm.ptr) -> !llvm.ptr<4> { // CHECK-NEXT: %[[VAL_2:.*]] = llvm.mlir.constant(0 : i64) : i64 -// CHECK-NEXT: %[[VAL_3:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 2, 0, 0, 0] : (!llvm.ptr<[[ACCESSOR2]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_4:.*]] = llvm.load %[[VAL_3]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_5:.*]] = llvm.getelementptr inbounds %[[VAL_1]][0, 0, 0, 0] : (!llvm.ptr<[[ID2]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_6:.*]] = llvm.load %[[VAL_5]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 2, 0, 0, 0] : (!llvm.ptr) -> !llvm.ptr, !sycl_accessor_2_i32_rw_gb +// CHECK-NEXT: %[[VAL_4:.*]] = llvm.load %[[VAL_3]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_5:.*]] = llvm.getelementptr inbounds %[[VAL_1]][0, 0, 0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::id.2", {{.*}}> +// CHECK-NEXT: %[[VAL_6:.*]] = llvm.load %[[VAL_5]] : !llvm.ptr -> i64 // CHECK-NEXT: %[[VAL_7:.*]] = llvm.mul %[[VAL_2]], %[[VAL_4]] : i64 // CHECK-NEXT: %[[VAL_8:.*]] = llvm.add %[[VAL_7]], %[[VAL_6]] : i64 -// CHECK-NEXT: %[[VAL_9:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 2, 0, 0, 1] : (!llvm.ptr<[[ACCESSOR2]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_10:.*]] = llvm.load %[[VAL_9]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_11:.*]] = llvm.getelementptr inbounds %[[VAL_1]][0, 0, 0, 1] : (!llvm.ptr<[[ID2]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_12:.*]] = llvm.load %[[VAL_11]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_9:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 2, 0, 0, 1] : (!llvm.ptr) -> !llvm.ptr, !sycl_accessor_2_i32_rw_gb +// CHECK-NEXT: %[[VAL_10:.*]] = llvm.load %[[VAL_9]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_11:.*]] = llvm.getelementptr inbounds %[[VAL_1]][0, 0, 0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::id.2", {{.*}}> +// CHECK-NEXT: %[[VAL_12:.*]] = llvm.load %[[VAL_11]] : !llvm.ptr -> i64 // CHECK-NEXT: %[[VAL_13:.*]] = llvm.mul %[[VAL_8]], %[[VAL_10]] : i64 // CHECK-NEXT: %[[VAL_14:.*]] = llvm.add %[[VAL_13]], %[[VAL_12]] : i64 -// CHECK-NEXT: %[[VAL_15:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0] : (!llvm.ptr<[[ACCESSOR2]]>) -> !llvm.ptr> -// CHECK-NEXT: %[[VAL_16:.*]] = llvm.load %[[VAL_15]] : !llvm.ptr> -// CHECK-NEXT: %[[VAL_17:.*]] = llvm.getelementptr inbounds %[[VAL_16]][%[[VAL_14]]] : (!llvm.ptr, i64) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_18:.*]] = llvm.addrspacecast %[[VAL_17]] : !llvm.ptr to !llvm.ptr -// CHECK-NEXT: llvm.return %[[VAL_18]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_15:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0] : (!llvm.ptr) -> !llvm.ptr, !sycl_accessor_2_i32_rw_gb +// CHECK-NEXT: %[[VAL_16:.*]] = llvm.load %[[VAL_15]] : !llvm.ptr -> !llvm.ptr<1> +// CHECK-NEXT: %[[VAL_17:.*]] = llvm.getelementptr inbounds %[[VAL_16]][%[[VAL_14]]] : (!llvm.ptr<1>, i64) -> !llvm.ptr<1>, i32 +// CHECK-NEXT: %[[VAL_18:.*]] = llvm.addrspacecast %[[VAL_17]] : !llvm.ptr<1> to !llvm.ptr<4> +// CHECK-NEXT: llvm.return %[[VAL_18]] : !llvm.ptr<4> // CHECK-NEXT: } func.func @test_2(%acc: memref, %idx: memref) -> memref { %0 = sycl.accessor.subscript %acc[%idx] { ArgumentTypes = [memref, memref], FunctionName = @"operator[]", MangledFunctionName = @"operator[]", TypeName = @"id" } : (memref, memref) -> memref @@ -131,32 +131,32 @@ func.func @test_2(%acc: memref, %idx: memref, -// CHECK-SAME: %[[VAL_1:.*]]: !llvm.ptr<[[ID3]]>) -> !llvm.ptr { +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr, +// CHECK-SAME: %[[VAL_1:.*]]: !llvm.ptr) -> !llvm.ptr<4> { // CHECK-NEXT: %[[VAL_2:.*]] = llvm.mlir.constant(0 : i64) : i64 -// CHECK-NEXT: %[[VAL_3:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 2, 0, 0, 0] : (!llvm.ptr<[[ACCESSOR3]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_4:.*]] = llvm.load %[[VAL_3]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_5:.*]] = llvm.getelementptr inbounds %[[VAL_1]][0, 0, 0, 0] : (!llvm.ptr<[[ID3]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_6:.*]] = llvm.load %[[VAL_5]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 2, 0, 0, 0] : (!llvm.ptr) -> !llvm.ptr, !sycl_accessor_3_i32_rw_gb +// CHECK-NEXT: %[[VAL_4:.*]] = llvm.load %[[VAL_3]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_5:.*]] = llvm.getelementptr inbounds %[[VAL_1]][0, 0, 0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::id.3", {{.*}}> +// CHECK-NEXT: %[[VAL_6:.*]] = llvm.load %[[VAL_5]] : !llvm.ptr -> i64 // CHECK-NEXT: %[[VAL_7:.*]] = llvm.mul %[[VAL_2]], %[[VAL_4]] : i64 // CHECK-NEXT: %[[VAL_8:.*]] = llvm.add %[[VAL_7]], %[[VAL_6]] : i64 -// CHECK-NEXT: %[[VAL_9:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 2, 0, 0, 1] : (!llvm.ptr<[[ACCESSOR3]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_10:.*]] = llvm.load %[[VAL_9]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_11:.*]] = llvm.getelementptr inbounds %[[VAL_1]][0, 0, 0, 1] : (!llvm.ptr<[[ID3]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_12:.*]] = llvm.load %[[VAL_11]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_9:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 2, 0, 0, 1] : (!llvm.ptr) -> !llvm.ptr, !sycl_accessor_3_i32_rw_gb +// CHECK-NEXT: %[[VAL_10:.*]] = llvm.load %[[VAL_9]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_11:.*]] = llvm.getelementptr inbounds %[[VAL_1]][0, 0, 0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::id.3", {{.*}}> +// CHECK-NEXT: %[[VAL_12:.*]] = llvm.load %[[VAL_11]] : !llvm.ptr -> i64 // CHECK-NEXT: %[[VAL_13:.*]] = llvm.mul %[[VAL_8]], %[[VAL_10]] : i64 // CHECK-NEXT: %[[VAL_14:.*]] = llvm.add %[[VAL_13]], %[[VAL_12]] : i64 -// CHECK-NEXT: %[[VAL_15:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 2, 0, 0, 2] : (!llvm.ptr<[[ACCESSOR3]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_16:.*]] = llvm.load %[[VAL_15]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_17:.*]] = llvm.getelementptr inbounds %[[VAL_1]][0, 0, 0, 2] : (!llvm.ptr<[[ID3]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_18:.*]] = llvm.load %[[VAL_17]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_15:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 2, 0, 0, 2] : (!llvm.ptr) -> !llvm.ptr, !sycl_accessor_3_i32_rw_gb +// CHECK-NEXT: %[[VAL_16:.*]] = llvm.load %[[VAL_15]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_17:.*]] = llvm.getelementptr inbounds %[[VAL_1]][0, 0, 0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::id.3", {{.*}}> +// CHECK-NEXT: %[[VAL_18:.*]] = llvm.load %[[VAL_17]] : !llvm.ptr -> i64 // CHECK-NEXT: %[[VAL_19:.*]] = llvm.mul %[[VAL_14]], %[[VAL_16]] : i64 // CHECK-NEXT: %[[VAL_20:.*]] = llvm.add %[[VAL_19]], %[[VAL_18]] : i64 -// CHECK-NEXT: %[[VAL_21:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0] : (!llvm.ptr<[[ACCESSOR3]]>) -> !llvm.ptr> -// CHECK-NEXT: %[[VAL_22:.*]] = llvm.load %[[VAL_21]] : !llvm.ptr> -// CHECK-NEXT: %[[VAL_23:.*]] = llvm.getelementptr inbounds %[[VAL_22]][%[[VAL_20]]] : (!llvm.ptr, i64) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_24:.*]] = llvm.addrspacecast %[[VAL_23]] : !llvm.ptr to !llvm.ptr -// CHECK-NEXT: llvm.return %[[VAL_24]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_21:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0] : (!llvm.ptr) -> !llvm.ptr, !sycl_accessor_3_i32_rw_gb +// CHECK-NEXT: %[[VAL_22:.*]] = llvm.load %[[VAL_21]] : !llvm.ptr -> !llvm.ptr<1> +// CHECK-NEXT: %[[VAL_23:.*]] = llvm.getelementptr inbounds %[[VAL_22]][%[[VAL_20]]] : (!llvm.ptr<1>, i64) -> !llvm.ptr<1> +// CHECK-NEXT: %[[VAL_24:.*]] = llvm.addrspacecast %[[VAL_23]] : !llvm.ptr<1> to !llvm.ptr<4> +// CHECK-NEXT: llvm.return %[[VAL_24]] : !llvm.ptr<4> // CHECK-NEXT: } func.func @test_3(%acc: memref, %idx: memref) -> memref { %0 = sycl.accessor.subscript %acc[%idx] { ArgumentTypes = [memref, memref], FunctionName = @"operator[]", MangledFunctionName = @"operator[]", TypeName = @"id" } : (memref, memref) -> memref diff --git a/mlir-sycl/test/Conversion/SYCLToLLVM/sycl-methods-to-llvm-m32-typed-pointer.mlir b/mlir-sycl/test/Conversion/SYCLToLLVM/sycl-methods-to-llvm-m32-typed-pointer.mlir new file mode 100644 index 0000000000000..4805a99a23ee2 --- /dev/null +++ b/mlir-sycl/test/Conversion/SYCLToLLVM/sycl-methods-to-llvm-m32-typed-pointer.mlir @@ -0,0 +1,31 @@ +// RUN: sycl-mlir-opt -split-input-file -convert-sycl-to-llvm="index-bitwidth=32 use-opaque-pointers=0" %s | FileCheck %s + +//===-------------------------------------------------------------------------------------------------===// +// sycl.accessor.get_pointer +//===-------------------------------------------------------------------------------------------------===// + +!sycl_id_1_ = !sycl.id<[1], (!sycl.array<[1], (memref<1xi32>)>)> +!sycl_range_1_ = !sycl.range<[1], (!sycl.array<[1], (memref<1xi32>)>)> +!sycl_accessor_impl_device_1_ = !sycl.accessor_impl_device<[1], (!sycl_id_1_, !sycl_range_1_, !sycl_range_1_)> +!sycl_accessor_1_i32_rw_gb = !sycl.accessor<[1, i32, read_write, global_buffer], (!sycl_accessor_impl_device_1_, !llvm.struct<(ptr)>)> + +// CHECK-LABEL: llvm.func @test( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[ACCESSOR1:.*]]>) -> !llvm.ptr { +// CHECK-NEXT: %0 = llvm.mlir.constant(0 : i32) : i32 +// CHECK-NEXT: %1 = llvm.mlir.constant(0 : i32) : i32 +// CHECK-NEXT: %2 = llvm.getelementptr inbounds %arg0[0, 0, 2, 0, 0, 0] : (!llvm.ptr<[[ACCESSOR1]]>) -> !llvm.ptr +// CHECK-NEXT: %3 = llvm.load %2 : !llvm.ptr +// CHECK-NEXT: %4 = llvm.getelementptr inbounds %arg0[0, 0, 0, 0, 0, 0] : (!llvm.ptr<[[ACCESSOR1]]>) -> !llvm.ptr +// CHECK-NEXT: %5 = llvm.load %4 : !llvm.ptr +// CHECK-NEXT: %6 = llvm.mul %1, %3 : i32 +// CHECK-NEXT: %7 = llvm.add %6, %5 : i32 +// CHECK-NEXT: %8 = llvm.sub %0, %7 : i32 +// CHECK-NEXT: %9 = llvm.getelementptr inbounds %arg0[0, 1, 0] : (!llvm.ptr<[[ACCESSOR1]]>) -> !llvm.ptr> +// CHECK-NEXT: %10 = llvm.load %9 : !llvm.ptr> +// CHECK-NEXT: %11 = llvm.getelementptr inbounds %10[%8] : (!llvm.ptr, i32) -> !llvm.ptr +// CHECK-NEXT: llvm.return %11 : !llvm.ptr +// CHECK-NEXT: } +func.func @test(%acc: memref) -> memref { + %0 = sycl.accessor.get_pointer(%acc) { ArgumentTypes = [memref], FunctionName = @"get_pointer", MangledFunctionName = @"get_pointer", TypeName = @"accessor" } : (memref) -> memref + return %0 : memref +} diff --git a/mlir-sycl/test/Conversion/SYCLToLLVM/sycl-methods-to-llvm-m32.mlir b/mlir-sycl/test/Conversion/SYCLToLLVM/sycl-methods-to-llvm-m32.mlir index 32cf5bbd44ccd..0c94440a3e961 100644 --- a/mlir-sycl/test/Conversion/SYCLToLLVM/sycl-methods-to-llvm-m32.mlir +++ b/mlir-sycl/test/Conversion/SYCLToLLVM/sycl-methods-to-llvm-m32.mlir @@ -1,4 +1,4 @@ -// RUN: sycl-mlir-opt -split-input-file -convert-sycl-to-llvm="index-bitwidth=32" %s | FileCheck %s +// RUN: sycl-mlir-opt -split-input-file -convert-sycl-to-llvm="index-bitwidth=32 use-opaque-pointers=1" %s | FileCheck %s //===-------------------------------------------------------------------------------------------------===// // sycl.accessor.get_pointer @@ -7,23 +7,23 @@ !sycl_id_1_ = !sycl.id<[1], (!sycl.array<[1], (memref<1xi32>)>)> !sycl_range_1_ = !sycl.range<[1], (!sycl.array<[1], (memref<1xi32>)>)> !sycl_accessor_impl_device_1_ = !sycl.accessor_impl_device<[1], (!sycl_id_1_, !sycl_range_1_, !sycl_range_1_)> -!sycl_accessor_1_i32_rw_gb = !sycl.accessor<[1, i32, read_write, global_buffer], (!sycl_accessor_impl_device_1_, !llvm.struct<(ptr)>)> +!sycl_accessor_1_i32_rw_gb = !sycl.accessor<[1, i32, read_write, global_buffer], (!sycl_accessor_impl_device_1_, !llvm.struct<(ptr<1>)>)> // CHECK-LABEL: llvm.func @test( -// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[ACCESSOR1:.*]]>) -> !llvm.ptr { +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr) -> !llvm.ptr<1> { // CHECK-NEXT: %0 = llvm.mlir.constant(0 : i32) : i32 // CHECK-NEXT: %1 = llvm.mlir.constant(0 : i32) : i32 -// CHECK-NEXT: %2 = llvm.getelementptr inbounds %arg0[0, 0, 2, 0, 0, 0] : (!llvm.ptr<[[ACCESSOR1]]>) -> !llvm.ptr -// CHECK-NEXT: %3 = llvm.load %2 : !llvm.ptr -// CHECK-NEXT: %4 = llvm.getelementptr inbounds %arg0[0, 0, 0, 0, 0, 0] : (!llvm.ptr<[[ACCESSOR1]]>) -> !llvm.ptr -// CHECK-NEXT: %5 = llvm.load %4 : !llvm.ptr +// CHECK-NEXT: %2 = llvm.getelementptr inbounds %arg0[0, 0, 2, 0, 0, 0] : (!llvm.ptr) -> !llvm.ptr +// CHECK-NEXT: %3 = llvm.load %2 : !llvm.ptr +// CHECK-NEXT: %4 = llvm.getelementptr inbounds %arg0[0, 0, 0, 0, 0, 0] : (!llvm.ptr) -> !llvm.ptr +// CHECK-NEXT: %5 = llvm.load %4 : !llvm.ptr // CHECK-NEXT: %6 = llvm.mul %1, %3 : i32 // CHECK-NEXT: %7 = llvm.add %6, %5 : i32 // CHECK-NEXT: %8 = llvm.sub %0, %7 : i32 -// CHECK-NEXT: %9 = llvm.getelementptr inbounds %arg0[0, 1, 0] : (!llvm.ptr<[[ACCESSOR1]]>) -> !llvm.ptr> -// CHECK-NEXT: %10 = llvm.load %9 : !llvm.ptr> -// CHECK-NEXT: %11 = llvm.getelementptr inbounds %10[%8] : (!llvm.ptr, i32) -> !llvm.ptr -// CHECK-NEXT: llvm.return %11 : !llvm.ptr +// CHECK-NEXT: %9 = llvm.getelementptr inbounds %arg0[0, 1, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::accessor.1", {{.*}}> +// CHECK-NEXT: %10 = llvm.load %9 : !llvm.ptr -> !llvm.ptr<1> +// CHECK-NEXT: %11 = llvm.getelementptr inbounds %10[%8] : (!llvm.ptr<1>, i32) -> !llvm.ptr<1>, i32 +// CHECK-NEXT: llvm.return %11 : !llvm.ptr<1> // CHECK-NEXT: } func.func @test(%acc: memref) -> memref { %0 = sycl.accessor.get_pointer(%acc) { ArgumentTypes = [memref], FunctionName = @"get_pointer", MangledFunctionName = @"get_pointer", TypeName = @"accessor" } : (memref) -> memref diff --git a/mlir-sycl/test/Conversion/SYCLToLLVM/sycl-methods-to-llvm-typed-pointer.mlir b/mlir-sycl/test/Conversion/SYCLToLLVM/sycl-methods-to-llvm-typed-pointer.mlir new file mode 100644 index 0000000000000..72b5ff1318c01 --- /dev/null +++ b/mlir-sycl/test/Conversion/SYCLToLLVM/sycl-methods-to-llvm-typed-pointer.mlir @@ -0,0 +1,1706 @@ +// RUN: sycl-mlir-opt -split-input-file -convert-sycl-to-llvm='use-opaque-pointers=0' %s | FileCheck %s + +//===-------------------------------------------------------------------------------------------------===// +// sycl.range.get with scalar result type +//===-------------------------------------------------------------------------------------------------===// + +!sycl_range_3_ = !sycl.range<[3], (!sycl.array<[3], (memref<3xi64>)>)> + +// CHECK-LABEL: llvm.func @test( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[RANGE3:.*]]>, +// CHECK-SAME: %[[VAL_1:.*]]: i32) -> i64 { +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, %[[VAL_1]]] : (!llvm.ptr<[[RANGE3]]>, i32) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.load %[[VAL_2]] : !llvm.ptr +// CHECK-NEXT: llvm.return %[[VAL_3]] : i64 +// CHECK-NEXT: } +func.func @test(%range: memref, %idx: i32) -> i64 { + %0 = sycl.range.get %range[%idx] { ArgumentTypes = [memref, i32], FunctionName = @"get", MangledFunctionName = @"get", TypeName = @"range" } : (memref, i32) -> i64 + return %0 : i64 +} + +// ----- + +//===-------------------------------------------------------------------------------------------------===// +// sycl.range.get with reference result type +//===-------------------------------------------------------------------------------------------------===// + +!sycl_range_3_ = !sycl.range<[3], (!sycl.array<[3], (memref<3xi64>)>)> + +// CHECK-LABEL: llvm.func @test( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[RANGE3]]>, +// CHECK-SAME: %[[VAL_1:.*]]: i32) -> !llvm.ptr { +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, %[[VAL_1]]] : (!llvm.ptr<[[RANGE3]]>, i32) -> !llvm.ptr +// CHECK-NEXT: llvm.return %[[VAL_2]] : !llvm.ptr +// CHECK-NEXT: } +func.func @test(%range: memref, %idx: i32) -> memref { + %0 = sycl.range.get %range[%idx] { ArgumentTypes = [memref, i32], FunctionName = @"operator[]", MangledFunctionName = @"operator[]", TypeName = @"range" } : (memref, i32) -> memref + return %0 : memref +} + +// ----- + +//===-------------------------------------------------------------------------------------------------===// +// sycl.range.size +//===-------------------------------------------------------------------------------------------------===// + +!sycl_range_1_ = !sycl.range<[1], (!sycl.array<[1], (memref<1xi64>)>)> +!sycl_range_2_ = !sycl.range<[2], (!sycl.array<[2], (memref<2xi64>)>)> +!sycl_range_3_ = !sycl.range<[3], (!sycl.array<[3], (memref<3xi64>)>)> + +// CHECK-LABEL: llvm.func @test_1( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[RANGE1:.*]]>) -> i64 { +// CHECK-NEXT: %[[VAL_1:.*]] = llvm.mlir.constant(1 : i64) : i64 +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 0] : (!llvm.ptr<[[RANGE1]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.load %[[VAL_2]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_4:.*]] = llvm.mul %[[VAL_1]], %[[VAL_3]] : i64 +// CHECK-NEXT: llvm.return %[[VAL_4]] : i64 +// CHECK-NEXT: } +func.func @test_1(%range: memref) -> i64 { + %0 = sycl.range.size(%range) { ArgumentTypes = [memref], FunctionName = @"size", MangledFunctionName = @"size", TypeName = @"range" } : (memref) -> i64 + return %0 : i64 +} + +// CHECK-LABEL: llvm.func @test_2( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[RANGE2:.*]]>) -> i64 { +// CHECK-NEXT: %[[VAL_1:.*]] = llvm.mlir.constant(1 : i64) : i64 +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 0] : (!llvm.ptr<[[RANGE2]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.load %[[VAL_2]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_4:.*]] = llvm.mul %[[VAL_1]], %[[VAL_3]] : i64 +// CHECK-NEXT: %[[VAL_5:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 1] : (!llvm.ptr<[[RANGE2]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_6:.*]] = llvm.load %[[VAL_5]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_7:.*]] = llvm.mul %[[VAL_4]], %[[VAL_6]] : i64 +// CHECK-NEXT: llvm.return %[[VAL_7]] : i64 +// CHECK-NEXT: } +func.func @test_2(%range: memref) -> i64 { + %0 = sycl.range.size(%range) { ArgumentTypes = [memref], FunctionName = @"size", MangledFunctionName = @"size", TypeName = @"range" } : (memref) -> i64 + return %0 : i64 +} + +// CHECK-LABEL: llvm.func @test_3( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[RANGE3]]>) -> i64 { +// CHECK-NEXT: %[[VAL_1:.*]] = llvm.mlir.constant(1 : i64) : i64 +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 0] : (!llvm.ptr<[[RANGE3]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.load %[[VAL_2]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_4:.*]] = llvm.mul %[[VAL_1]], %[[VAL_3]] : i64 +// CHECK-NEXT: %[[VAL_5:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 1] : (!llvm.ptr<[[RANGE3]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_6:.*]] = llvm.load %[[VAL_5]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_7:.*]] = llvm.mul %[[VAL_4]], %[[VAL_6]] : i64 +// CHECK-NEXT: %[[VAL_8:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 2] : (!llvm.ptr<[[RANGE3]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_9:.*]] = llvm.load %[[VAL_8]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_10:.*]] = llvm.mul %[[VAL_7]], %[[VAL_9]] : i64 +// CHECK-NEXT: llvm.return %[[VAL_10]] : i64 +// CHECK-NEXT: } +func.func @test_3(%range: memref) -> i64 { + %0 = sycl.range.size(%range) { ArgumentTypes = [memref], FunctionName = @"size", MangledFunctionName = @"size", TypeName = @"range" } : (memref) -> i64 + return %0 : i64 +} + +// ----- + +//===-------------------------------------------------------------------------------------------------===// +// sycl.id.get with scalar result type +//===-------------------------------------------------------------------------------------------------===// + +!sycl_id_3_ = !sycl.id<[3], (!sycl.array<[3], (memref<3xi64>)>)> + +// CHECK-LABEL: llvm.func @test( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[ID3:.*]]>, +// CHECK-SAME: %[[VAL_1:.*]]: i32) -> i64 { +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, %[[VAL_1]]] : (!llvm.ptr<[[ID3]]>, i32) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.load %[[VAL_2]] : !llvm.ptr +// CHECK-NEXT: llvm.return %[[VAL_3]] : i64 +// CHECK-NEXT: } +func.func @test(%id: memref, %idx: i32) -> i64 { + %0 = sycl.id.get %id[%idx] { ArgumentTypes = [memref, i32], FunctionName = @"get", MangledFunctionName = @"get", TypeName = @"id" } : (memref, i32) -> i64 + return %0 : i64 +} + +// ----- + +//===-------------------------------------------------------------------------------------------------===// +// sycl.id.get with scalar result type and no argument +//===-------------------------------------------------------------------------------------------------===// + +!sycl_id_1_ = !sycl.id<[1], (!sycl.array<[1], (memref<1xi64>)>)> + +// CHECK-LABEL: llvm.func @test( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[ID1:.*]]>) -> i64 { +// CHECK: %[[VAL_1:.*]] = llvm.mlir.constant(0 : i32) : i32 +// CHECK: %[[VAL_2:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, %[[VAL_1]]] : (!llvm.ptr<[[ID1]]>, i32) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.load %[[VAL_2]] : !llvm.ptr +// CHECK-NEXT: llvm.return %[[VAL_3]] : i64 +// CHECK-NEXT: } +func.func @test(%id: memref) -> i64 { + %0 = sycl.id.get %id[] { ArgumentTypes = [memref], FunctionName = @"operator unsigned long", MangledFunctionName = @"operator unsigned long", TypeName = @"id" } : (memref) -> i64 + return %0 : i64 +} + +// ----- + +//===-------------------------------------------------------------------------------------------------===// +// sycl.id.get with reference result type +//===-------------------------------------------------------------------------------------------------===// + +!sycl_id_3_ = !sycl.id<[3], (!sycl.array<[3], (memref<3xi64>)>)> + +// CHECK-LABEL: llvm.func @test( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[ID3]]>, +// CHECK-SAME: %[[VAL_1:.*]]: i32) -> !llvm.ptr { +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, %[[VAL_1]]] : (!llvm.ptr<[[ID3]]>, i32) -> !llvm.ptr +// CHECK-NEXT: llvm.return %[[VAL_2]] : !llvm.ptr +// CHECK-NEXT: } +func.func @test(%id: memref, %idx: i32) -> memref { + %0 = sycl.id.get %id[%idx] { ArgumentTypes = [memref, i32], FunctionName = @"operator[]", MangledFunctionName = @"operator[]", TypeName = @"id" } : (memref, i32) -> memref + return %0 : memref +} + +// ----- + +//===-------------------------------------------------------------------------------------------------===// +// sycl.accessor.get_pointer +//===-------------------------------------------------------------------------------------------------===// + +!sycl_id_1_ = !sycl.id<[1], (!sycl.array<[1], (memref<1xi64>)>)> +!sycl_range_1_ = !sycl.range<[1], (!sycl.array<[1], (memref<1xi64>)>)> +!sycl_accessor_impl_device_1_ = !sycl.accessor_impl_device<[1], (!sycl_id_1_, !sycl_range_1_, !sycl_range_1_)> +!sycl_accessor_1_i32_rw_gb = !sycl.accessor<[1, i32, read_write, global_buffer], (!sycl_accessor_impl_device_1_, !llvm.struct<(ptr)>)> + +// CHECK-LABEL: llvm.func @test( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[ACCESSOR1:.*]]>) -> !llvm.ptr { +// CHECK-NEXT: %[[VAL_1:.*]] = llvm.mlir.constant(0 : i64) : i64 +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.mlir.constant(0 : i64) : i64 +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 2, 0, 0, 0] : (!llvm.ptr<[[ACCESSOR1]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_4:.*]] = llvm.load %[[VAL_3]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_5:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 0, 0, 0] : (!llvm.ptr<[[ACCESSOR1]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_6:.*]] = llvm.load %[[VAL_5]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_7:.*]] = llvm.mul %[[VAL_2]], %[[VAL_4]] : i64 +// CHECK-NEXT: %[[VAL_8:.*]] = llvm.add %[[VAL_7]], %[[VAL_6]] : i64 +// CHECK-NEXT: %[[VAL_9:.*]] = llvm.sub %[[VAL_1]], %[[VAL_8]] : i64 +// CHECK-NEXT: %[[VAL_10:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0] : (!llvm.ptr<[[ACCESSOR1]]>) -> !llvm.ptr> +// CHECK-NEXT: %[[VAL_11:.*]] = llvm.load %[[VAL_10]] : !llvm.ptr> +// CHECK-NEXT: %[[VAL_12:.*]] = llvm.getelementptr inbounds %[[VAL_11]][%[[VAL_9]]] : (!llvm.ptr, i64) -> !llvm.ptr +// CHECK-NEXT: llvm.return %[[VAL_12]] : !llvm.ptr +// CHECK-NEXT: } +func.func @test(%acc: memref) -> memref { + %0 = sycl.accessor.get_pointer(%acc) { ArgumentTypes = [memref], FunctionName = @"get_pointer", MangledFunctionName = @"get_pointer", TypeName = @"accessor" } : (memref) -> memref + return %0 : memref +} + +// ----- + +//===-------------------------------------------------------------------------------------------------===// +// sycl.accessor.get_range +//===-------------------------------------------------------------------------------------------------===// + +!sycl_id_1_ = !sycl.id<[1], (!sycl.array<[1], (memref<1xi64>)>)> +!sycl_range_1_ = !sycl.range<[1], (!sycl.array<[1], (memref<1xi64>)>)> +!sycl_accessor_impl_device_1_ = !sycl.accessor_impl_device<[1], (!sycl_id_1_, !sycl_range_1_, !sycl_range_1_)> +!sycl_accessor_1_i32_rw_gb = !sycl.accessor<[1, i32, read_write, global_buffer], (!sycl_accessor_impl_device_1_, !llvm.struct<(ptr)>)> + +// CHECK-LABEL: llvm.func @test( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[ACCESSOR1:.*]]>) -> !llvm.[[RANGE1:.*]] { +// CHECK-NEXT: %[[VAL_1:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 1] : (!llvm.ptr<[[ACCESSOR1]]>) -> !llvm.ptr<[[RANGE1]]> +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] : !llvm.ptr<[[RANGE1]]> +// CHECK-NEXT: llvm.return %[[VAL_2]] : !llvm.[[RANGE1]] +// CHECK-NEXT: } +func.func @test(%acc: memref) -> !sycl_range_1_ { + %0 = sycl.accessor.get_range(%acc) { ArgumentTypes = [memref], FunctionName = @"get_range", MangledFunctionName = @"get_range", TypeName = @"accessor" } : (memref) -> !sycl_range_1_ + return %0 : !sycl_range_1_ +} + +// ----- + +//===-------------------------------------------------------------------------------------------------===// +// sycl.accessor.size +//===-------------------------------------------------------------------------------------------------===// + +!sycl_id_1_ = !sycl.id<[1], (!sycl.array<[1], (memref<1xi64>)>)> +!sycl_range_1_ = !sycl.range<[1], (!sycl.array<[1], (memref<1xi64>)>)> +!sycl_accessor_impl_device_1_ = !sycl.accessor_impl_device<[1], (!sycl_id_1_, !sycl_range_1_, !sycl_range_1_)> +!sycl_accessor_1_i32_rw_gb = !sycl.accessor<[1, i32, read_write, global_buffer], (!sycl_accessor_impl_device_1_, !llvm.struct<(ptr)>)> + +// CHECK-LABEL: llvm.func @test( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[ACCESSOR1:.*]]>) -> i64 { +// CHECK-NEXT: %[[VAL_1:.*]] = llvm.mlir.constant(1 : i64) : i64 +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 1, 0, 0, 0] : (!llvm.ptr<[[ACCESSOR1]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.load %[[VAL_2]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_4:.*]] = llvm.mul %[[VAL_1]], %[[VAL_3]] : i64 +// CHECK-NEXT: llvm.return %[[VAL_4]] : i64 +// CHECK-NEXT: } +func.func @test(%acc: memref) -> i64 { + %0 = sycl.accessor.size(%acc) { ArgumentTypes = [memref], FunctionName = @"size", MangledFunctionName = @"size", TypeName = @"accessor" } : (memref) -> i64 + return %0 : i64 +} + +// ----- + +//===-------------------------------------------------------------------------------------------------===// +// sycl.accessor.subscript with scalar offset and 1D accessor +//===-------------------------------------------------------------------------------------------------===// + +!sycl_id_1_ = !sycl.id<[1], (!sycl.array<[1], (memref<1xi64>)>)> +!sycl_range_1_ = !sycl.range<[1], (!sycl.array<[1], (memref<1xi64>)>)> +!sycl_accessor_impl_device_1_ = !sycl.accessor_impl_device<[1], (!sycl_id_1_, !sycl_range_1_, !sycl_range_1_)> +!sycl_accessor_1_i32_rw_gb = !sycl.accessor<[1, i32, read_write, global_buffer], (!sycl_accessor_impl_device_1_, !llvm.struct<(ptr)>)> + +// CHECK-LABEL: llvm.func @test( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[ACCESSOR1:.*]]>, +// CHECK-SAME: %[[VAL_1:.*]]: i64) -> !llvm.ptr { +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0] : (!llvm.ptr<[[ACCESSOR1]]>) -> !llvm.ptr> +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.load %[[VAL_2]] : !llvm.ptr> +// CHECK-NEXT: %[[VAL_4:.*]] = llvm.getelementptr inbounds %[[VAL_3]][%[[VAL_1]]] : (!llvm.ptr, i64) -> !llvm.ptr +// CHECK-NEXT: llvm.return %[[VAL_4]] : !llvm.ptr +// CHECK-NEXT: } +func.func @test(%acc: memref, %idx: i64) -> memref { + %0 = sycl.accessor.subscript %acc[%idx] { ArgumentTypes = [memref, i64], FunctionName = @"operator[]", MangledFunctionName = @"operator[]", TypeName = @"id" } : (memref, i64) -> memref + return %0 : memref +} + +// ----- + +//===-------------------------------------------------------------------------------------------------===// +// sycl.accessor.subscript with scalar offset and ND accessor +//===-------------------------------------------------------------------------------------------------===// + +!sycl_id_1_ = !sycl.id<[1], (!sycl.array<[1], (memref<1xi64>)>)> +!sycl_id_2_ = !sycl.id<[2], (!sycl.array<[2], (memref<2xi64>)>)> +!sycl_id_3_ = !sycl.id<[3], (!sycl.array<[3], (memref<3xi64>)>)> +!sycl_range_2_ = !sycl.range<[2], (!sycl.array<[2], (memref<2xi64>)>)> +!sycl_accessor_impl_device_2_ = !sycl.accessor_impl_device<[2], (!sycl_id_2_, !sycl_range_2_, !sycl_range_2_)> +!sycl_accessor_2_i32_rw_gb = !sycl.accessor<[2, i32, read_write, global_buffer], (!sycl_accessor_impl_device_2_, !llvm.struct<(ptr)>)> +!sycl_range_3_ = !sycl.range<[3], (!sycl.array<[3], (memref<3xi64>)>)> +!sycl_accessor_impl_device_3_ = !sycl.accessor_impl_device<[3], (!sycl_id_3_, !sycl_range_3_, !sycl_range_3_)> +!sycl_accessor_3_i32_rw_gb = !sycl.accessor<[3, i32, read_write, global_buffer], (!sycl_accessor_impl_device_3_, !llvm.struct<(ptr)>)> +!sycl_accessor_subscript_2_ = !sycl.accessor_subscript<[2], (!sycl_id_2_, !sycl_accessor_2_i32_rw_gb)> +!sycl_accessor_subscript_3_ = !sycl.accessor_subscript<[3], (!sycl_id_3_, !sycl_accessor_3_i32_rw_gb)> + +// CHECK-LABEL: llvm.func @test_2( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[ACCESSOR2:.*]]>, %[[VAL_1:.*]]: i64) -> !llvm.[[ACCESSORSUBS2:.*]] { +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.mlir.undef : !llvm.[[ACCESSORSUBS2]] +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.insertvalue %[[VAL_1]], %[[VAL_2]][0, 0, 0, 0] : !llvm.[[ACCESSORSUBS2]] +// CHECK-NEXT: %[[VAL_4:.*]] = llvm.mlir.constant(0 : i64) : i64 +// CHECK-NEXT: %[[VAL_5:.*]] = llvm.load %[[VAL_0]] : !llvm.ptr<[[ACCESSOR2]]> +// CHECK-NEXT: %[[VAL_6:.*]] = llvm.insertvalue %[[VAL_5]], %[[VAL_3]][1] : !llvm.[[ACCESSORSUBS2]] +// CHECK-NEXT: llvm.return %[[VAL_6]] : !llvm.[[ACCESSORSUBS2]] +// CHECK-NEXT: } +func.func @test_2(%acc: memref, %idx: i64) -> !sycl_accessor_subscript_2_ { + %0 = sycl.accessor.subscript %acc[%idx] { ArgumentTypes = [memref, i64], FunctionName = @"operator[]", MangledFunctionName = @"operator[]", TypeName = @"id" } : (memref, i64) -> !sycl_accessor_subscript_2_ + return %0 : !sycl_accessor_subscript_2_ +} + +// CHECK-LABEL: llvm.func @test_3( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[ACCESSOR3:.*]]>, %[[VAL_1:.*]]: i64) -> !llvm.[[ACCESSORSUBS3:.*]] { +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.mlir.undef : !llvm.[[ACCESSORSUBS3]] +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.insertvalue %[[VAL_1]], %[[VAL_2]][0, 0, 0, 0] : !llvm.[[ACCESSORSUBS3]] +// CHECK-NEXT: %[[VAL_4:.*]] = llvm.mlir.constant(0 : i64) : i64 +// CHECK-NEXT: %[[VAL_5:.*]] = llvm.insertvalue %[[VAL_4]], %[[VAL_3]][0, 0, 0, 1] : !llvm.[[ACCESSORSUBS3]] +// CHECK-NEXT: %[[VAL_6:.*]] = llvm.load %[[VAL_0]] : !llvm.ptr<[[ACCESSOR3]]> +// CHECK-NEXT: %[[VAL_7:.*]] = llvm.insertvalue %[[VAL_6]], %[[VAL_5]][1] : !llvm.[[ACCESSORSUBS3]] +// CHECK-NEXT: llvm.return %[[VAL_7]] : !llvm.[[ACCESSORSUBS3]] +// CHECK-NEXT: } +func.func @test_3(%acc: memref, %idx: i64) -> !sycl_accessor_subscript_3_ { + %0 = sycl.accessor.subscript %acc[%idx] { ArgumentTypes = [memref, i64], FunctionName = @"operator[]", MangledFunctionName = @"operator[]", TypeName = @"id" } : (memref, i64) -> !sycl_accessor_subscript_3_ + return %0 : !sycl_accessor_subscript_3_ +} + +// ----- + +//===-------------------------------------------------------------------------------------------------===// +// sycl.accessor.subscript with id offset +//===-------------------------------------------------------------------------------------------------===// + +!sycl_id_1_ = !sycl.id<[1], (!sycl.array<[1], (memref<1xi64>)>)> +!sycl_range_1_ = !sycl.range<[1], (!sycl.array<[1], (memref<1xi64>)>)> +!sycl_accessor_impl_device_1_ = !sycl.accessor_impl_device<[1], (!sycl_id_1_, !sycl_range_1_, !sycl_range_1_)> +!sycl_accessor_1_i32_rw_gb = !sycl.accessor<[1, i32, read_write, global_buffer], (!sycl_accessor_impl_device_1_, !llvm.struct<(ptr)>)> +!sycl_id_2_ = !sycl.id<[2], (!sycl.array<[2], (memref<2xi64>)>)> +!sycl_range_2_ = !sycl.range<[2], (!sycl.array<[2], (memref<2xi64>)>)> +!sycl_accessor_impl_device_2_ = !sycl.accessor_impl_device<[2], (!sycl_id_2_, !sycl_range_2_, !sycl_range_2_)> +!sycl_accessor_2_i32_rw_gb = !sycl.accessor<[2, i32, read_write, global_buffer], (!sycl_accessor_impl_device_2_, !llvm.struct<(ptr)>)> +!sycl_id_3_ = !sycl.id<[3], (!sycl.array<[3], (memref<3xi64>)>)> +!sycl_range_3_ = !sycl.range<[3], (!sycl.array<[3], (memref<3xi64>)>)> +!sycl_accessor_impl_device_3_ = !sycl.accessor_impl_device<[3], (!sycl_id_3_, !sycl_range_3_, !sycl_range_3_)> +!sycl_accessor_3_i32_rw_gb = !sycl.accessor<[3, i32, read_write, global_buffer], (!sycl_accessor_impl_device_3_, !llvm.struct<(ptr)>)> +!my_struct = !llvm.struct<(i32, f32)> +!sycl_accessor_1_struct_rw_gb = !sycl.accessor<[1, !my_struct, read_write, global_buffer], (!sycl_accessor_impl_device_1_, !llvm.struct<(ptr)>)> + +// CHECK-LABEL: llvm.func @test_1( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[ACCESSOR1]]>, +// CHECK-SAME: %[[VAL_1:.*]]: !llvm.ptr<[[ID1]]>) -> !llvm.ptr { +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.mlir.constant(0 : i64) : i64 +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 2, 0, 0, 0] : (!llvm.ptr<[[ACCESSOR1]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_4:.*]] = llvm.load %[[VAL_3]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_5:.*]] = llvm.getelementptr inbounds %[[VAL_1]][0, 0, 0, 0] : (!llvm.ptr<[[ID1]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_6:.*]] = llvm.load %[[VAL_5]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_7:.*]] = llvm.mul %[[VAL_2]], %[[VAL_4]] : i64 +// CHECK-NEXT: %[[VAL_8:.*]] = llvm.add %[[VAL_7]], %[[VAL_6]] : i64 +// CHECK-NEXT: %[[VAL_9:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0] : (!llvm.ptr<[[ACCESSOR1]]>) -> !llvm.ptr> +// CHECK-NEXT: %[[VAL_10:.*]] = llvm.load %[[VAL_9]] : !llvm.ptr> +// CHECK-NEXT: %[[VAL_11:.*]] = llvm.getelementptr inbounds %[[VAL_10]][%[[VAL_8]]] : (!llvm.ptr, i64) -> !llvm.ptr +// CHECK-NEXT: llvm.return %[[VAL_11]] : !llvm.ptr +// CHECK-NEXT: } +func.func @test_1(%acc: memref, %idx: memref) -> memref { + %0 = sycl.accessor.subscript %acc[%idx] { ArgumentTypes = [memref, memref], FunctionName = @"operator[]", MangledFunctionName = @"operator[]", TypeName = @"id" } : (memref, memref) -> memref + return %0 : memref +} + +// CHECK-LABEL: llvm.func @test_2( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[ACCESSOR2]]>, +// CHECK-SAME: %[[VAL_1:.*]]: !llvm.ptr<[[ID2:.*]]>) -> !llvm.ptr { +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.mlir.constant(0 : i64) : i64 +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 2, 0, 0, 0] : (!llvm.ptr<[[ACCESSOR2]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_4:.*]] = llvm.load %[[VAL_3]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_5:.*]] = llvm.getelementptr inbounds %[[VAL_1]][0, 0, 0, 0] : (!llvm.ptr<[[ID2]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_6:.*]] = llvm.load %[[VAL_5]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_7:.*]] = llvm.mul %[[VAL_2]], %[[VAL_4]] : i64 +// CHECK-NEXT: %[[VAL_8:.*]] = llvm.add %[[VAL_7]], %[[VAL_6]] : i64 +// CHECK-NEXT: %[[VAL_9:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 2, 0, 0, 1] : (!llvm.ptr<[[ACCESSOR2]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_10:.*]] = llvm.load %[[VAL_9]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_11:.*]] = llvm.getelementptr inbounds %[[VAL_1]][0, 0, 0, 1] : (!llvm.ptr<[[ID2]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_12:.*]] = llvm.load %[[VAL_11]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_13:.*]] = llvm.mul %[[VAL_8]], %[[VAL_10]] : i64 +// CHECK-NEXT: %[[VAL_14:.*]] = llvm.add %[[VAL_13]], %[[VAL_12]] : i64 +// CHECK-NEXT: %[[VAL_15:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0] : (!llvm.ptr<[[ACCESSOR2]]>) -> !llvm.ptr> +// CHECK-NEXT: %[[VAL_16:.*]] = llvm.load %[[VAL_15]] : !llvm.ptr> +// CHECK-NEXT: %[[VAL_17:.*]] = llvm.getelementptr inbounds %[[VAL_16]][%[[VAL_14]]] : (!llvm.ptr, i64) -> !llvm.ptr +// CHECK-NEXT: llvm.return %[[VAL_17]] : !llvm.ptr +// CHECK-NEXT: } +func.func @test_2(%acc: memref, %idx: memref) -> memref { + %0 = sycl.accessor.subscript %acc[%idx] { ArgumentTypes = [memref, memref], FunctionName = @"operator[]", MangledFunctionName = @"operator[]", TypeName = @"id" } : (memref, memref) -> memref + return %0 : memref +} + +// CHECK-LABEL: llvm.func @test_3( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[ACCESSOR3:.*]]>, +// CHECK-SAME: %[[VAL_1:.*]]: !llvm.ptr<[[ID3]]>) -> !llvm.ptr { +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.mlir.constant(0 : i64) : i64 +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 2, 0, 0, 0] : (!llvm.ptr<[[ACCESSOR3]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_4:.*]] = llvm.load %[[VAL_3]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_5:.*]] = llvm.getelementptr inbounds %[[VAL_1]][0, 0, 0, 0] : (!llvm.ptr<[[ID3]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_6:.*]] = llvm.load %[[VAL_5]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_7:.*]] = llvm.mul %[[VAL_2]], %[[VAL_4]] : i64 +// CHECK-NEXT: %[[VAL_8:.*]] = llvm.add %[[VAL_7]], %[[VAL_6]] : i64 +// CHECK-NEXT: %[[VAL_9:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 2, 0, 0, 1] : (!llvm.ptr<[[ACCESSOR3]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_10:.*]] = llvm.load %[[VAL_9]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_11:.*]] = llvm.getelementptr inbounds %[[VAL_1]][0, 0, 0, 1] : (!llvm.ptr<[[ID3]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_12:.*]] = llvm.load %[[VAL_11]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_13:.*]] = llvm.mul %[[VAL_8]], %[[VAL_10]] : i64 +// CHECK-NEXT: %[[VAL_14:.*]] = llvm.add %[[VAL_13]], %[[VAL_12]] : i64 +// CHECK-NEXT: %[[VAL_15:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 2, 0, 0, 2] : (!llvm.ptr<[[ACCESSOR3]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_16:.*]] = llvm.load %[[VAL_15]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_17:.*]] = llvm.getelementptr inbounds %[[VAL_1]][0, 0, 0, 2] : (!llvm.ptr<[[ID3]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_18:.*]] = llvm.load %[[VAL_17]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_19:.*]] = llvm.mul %[[VAL_14]], %[[VAL_16]] : i64 +// CHECK-NEXT: %[[VAL_20:.*]] = llvm.add %[[VAL_19]], %[[VAL_18]] : i64 +// CHECK-NEXT: %[[VAL_21:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0] : (!llvm.ptr<[[ACCESSOR3]]>) -> !llvm.ptr> +// CHECK-NEXT: %[[VAL_22:.*]] = llvm.load %[[VAL_21]] : !llvm.ptr> +// CHECK-NEXT: %[[VAL_23:.*]] = llvm.getelementptr inbounds %[[VAL_22]][%[[VAL_20]]] : (!llvm.ptr, i64) -> !llvm.ptr +// CHECK-NEXT: llvm.return %[[VAL_23]] : !llvm.ptr +// CHECK-NEXT: } +func.func @test_3(%acc: memref, %idx: memref) -> memref { + %0 = sycl.accessor.subscript %acc[%idx] { ArgumentTypes = [memref, memref], FunctionName = @"operator[]", MangledFunctionName = @"operator[]", TypeName = @"id" } : (memref, memref) -> memref + return %0 : memref +} + +// CHECK-LABEL: llvm.func @test_struct( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[ACCESSORSTR:.*]]>, %[[VAL_1:.*]]: !llvm.ptr<[[ID1]]>) -> !llvm.ptr, 1> { +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.mlir.constant(0 : i64) : i64 +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 2, 0, 0, 0] : (!llvm.ptr<[[ACCESSORSTR]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_4:.*]] = llvm.load %[[VAL_3]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_5:.*]] = llvm.getelementptr inbounds %[[VAL_1]][0, 0, 0, 0] : (!llvm.ptr<[[ID1]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_6:.*]] = llvm.load %[[VAL_5]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_7:.*]] = llvm.mul %[[VAL_2]], %[[VAL_4]] : i64 +// CHECK-NEXT: %[[VAL_8:.*]] = llvm.add %[[VAL_7]], %[[VAL_6]] : i64 +// CHECK-NEXT: %[[VAL_9:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0] : (!llvm.ptr<[[ACCESSORSTR]]>) -> !llvm.ptr, 1>> +// CHECK-NEXT: %[[VAL_10:.*]] = llvm.load %[[VAL_9]] : !llvm.ptr, 1>> +// CHECK-NEXT: %[[VAL_11:.*]] = llvm.getelementptr inbounds %[[VAL_10]][%[[VAL_8]]] : (!llvm.ptr, 1>, i64) -> !llvm.ptr, 1> +// CHECK-NEXT: llvm.return %[[VAL_11]] : !llvm.ptr, 1> +// CHECK-NEXT: } +func.func @test_struct(%acc: memref, %idx: memref) -> !llvm.ptr, 1> { + %0 = sycl.accessor.subscript %acc[%idx] { ArgumentTypes = [memref, memref], FunctionName = @"operator[]", MangledFunctionName = @"operator[]", TypeName = @"id" } : (memref, memref) -> !llvm.ptr, 1> + return %0 : !llvm.ptr, 1> +} + +// ----- + + +//===----------------------------------------------------------------------===// +// sycl.accessor.subscript with id offset and atomic return type +//===----------------------------------------------------------------------===// + +!sycl_id_1_ = !sycl.id<[1], (!sycl.array<[1], (memref<1xi64, 4>)>)> +!sycl_range_1_ = !sycl.range<[1], (!sycl.array<[1], (memref<1xi64, 4>)>)> +!sycl_accessor_impl_device_1_ = !sycl.accessor_impl_device<[1], (!sycl_id_1_, !sycl_range_1_, !sycl_range_1_)> +!sycl_accessor_1_i32_ato_gb = !sycl.accessor<[1, i32, atomic, global_buffer], (!sycl_accessor_impl_device_1_, !llvm.struct<(ptr)>)> +!sycl_atomic_i32_glo = !sycl.atomic<[i32, global], (memref)> + +// CHECK-LABEL: llvm.func @test( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[ACCESSOR1:.*]]>, +// CHECK-SAME: %[[VAL_1:.*]]: !llvm.ptr<[[ID1:.*]]>) -> !llvm.[[ATOM1:.*]] { +// CHECK-DAG: %[[VAL_2:.*]] = llvm.mlir.undef : !llvm.[[ATOM1]] +// CHECK-DAG: %[[VAL_3:.*]] = llvm.mlir.constant(0 : i64) : i64 +// CHECK: %[[VAL_4:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 2, 0, 0, 0] : (!llvm.ptr<[[ACCESSOR1]]>) -> !llvm.ptr +// CHECK: %[[VAL_5:.*]] = llvm.load %[[VAL_4]] : !llvm.ptr +// CHECK: %[[VAL_6:.*]] = llvm.getelementptr inbounds %[[VAL_1]][0, 0, 0, 0] : (!llvm.ptr<[[ID1]]>) -> !llvm.ptr +// CHECK: %[[VAL_7:.*]] = llvm.load %[[VAL_6]] : !llvm.ptr +// CHECK: %[[VAL_8:.*]] = llvm.mul %[[VAL_3]], %[[VAL_5]] : i64 +// CHECK: %[[VAL_9:.*]] = llvm.add %[[VAL_8]], %[[VAL_7]] : i64 +// CHECK: %[[VAL_10:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0] : (!llvm.ptr<[[ACCESSOR1]]>) -> !llvm.ptr> +// CHECK: %[[VAL_11:.*]] = llvm.load %[[VAL_10]] : !llvm.ptr> +// CHECK: %[[VAL_12:.*]] = llvm.getelementptr inbounds %[[VAL_11]]{{\[}}%[[VAL_9]]] : (!llvm.ptr, i64) -> !llvm.ptr +// CHECK: %[[VAL_13:.*]] = llvm.insertvalue %[[VAL_12]], %[[VAL_2]][0] : !llvm.[[ATOM1]] +// CHECK: llvm.return %[[VAL_13]] : !llvm.[[ATOM1]] +func.func @test(%acc: memref, %idx: memref) -> !sycl_atomic_i32_glo { + %0 = sycl.accessor.subscript %acc[%idx] { ArgumentTypes = [memref, memref], FunctionName = @"operator[]", MangledFunctionName = @"operator[]", TypeName = @"id" } : (memref, memref) -> !sycl_atomic_i32_glo + return %0 : !sycl_atomic_i32_glo +} + +// ----- + +!sycl_id_1_ = !sycl.id<[1], (!sycl.array<[1], (memref<1xi64>)>)> +!sycl_range_1_ = !sycl.range<[1], (!sycl.array<[1], (memref<1xi64>)>)> +!sycl_nd_range_1_ = !sycl.nd_range<[1], (!sycl_range_1_, !sycl_range_1_, !sycl_id_1_)> + +// CHECK-LABEL: llvm.func @test( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[NDRANGE1:.*]]>) -> !llvm.[[RANGE1]] { +// CHECK-NEXT: %[[VAL_1:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0] : (!llvm.ptr<[[NDRANGE1]]>) -> !llvm.ptr<[[RANGE1]]> +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] : !llvm.ptr<[[RANGE1]]> +// CHECK-NEXT: llvm.return %[[VAL_2]] : !llvm.[[RANGE1]] +// CHECK-NEXT: } +func.func @test(%nd: memref) -> !sycl_range_1_ { + %0 = sycl.nd_range.get_global_range(%nd) { ArgumentTypes = [memref], FunctionName = @"get_global_range", MangledFunctionName = @"get_global_range", TypeName = @"nd_range" } : (memref) -> !sycl_range_1_ + return %0 : !sycl_range_1_ +} + +// ----- + +!sycl_id_1_ = !sycl.id<[1], (!sycl.array<[1], (memref<1xi64>)>)> +!sycl_range_1_ = !sycl.range<[1], (!sycl.array<[1], (memref<1xi64>)>)> +!sycl_nd_range_1_ = !sycl.nd_range<[1], (!sycl_range_1_, !sycl_range_1_, !sycl_id_1_)> + +// CHECK-LABEL: llvm.func @test( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[NDRANGE1]]>) -> !llvm.[[RANGE1]] { +// CHECK-NEXT: %[[VAL_1:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1] : (!llvm.ptr<[[NDRANGE1]]>) -> !llvm.ptr<[[RANGE1]]> +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] : !llvm.ptr<[[RANGE1]]> +// CHECK-NEXT: llvm.return %[[VAL_2]] : !llvm.[[RANGE1]] +// CHECK-NEXT: } +func.func @test(%nd: memref) -> !sycl_range_1_ { + %0 = sycl.nd_range.get_local_range(%nd) { ArgumentTypes = [memref], FunctionName = @"get_local_range", MangledFunctionName = @"get_local_range", TypeName = @"nd_range" } : (memref) -> !sycl_range_1_ + return %0 : !sycl_range_1_ +} + +// ----- + +!sycl_id_3_ = !sycl.id<[3], (!sycl.array<[3], (memref<3xi64>)>)> +!sycl_range_3_ = !sycl.range<[3], (!sycl.array<[3], (memref<3xi64>)>)> +!sycl_nd_range_3_ = !sycl.nd_range<[3], (!sycl_range_3_, !sycl_range_3_, !sycl_id_3_)> + +// CHECK-LABEL: llvm.func @test( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[NDRANGE3:.*]]>) -> !llvm.[[RANGE3]] { +// CHECK-NEXT: %[[VAL_1:.*]] = llvm.mlir.constant(1 : i64) : i64 +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.alloca %[[VAL_1]] x !llvm.[[RANGE3]] : (i64) -> !llvm.ptr<[[RANGE3]]> +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 0, 0] : (!llvm.ptr<[[NDRANGE3]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_4:.*]] = llvm.load %[[VAL_3]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_5:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0, 0, 0] : (!llvm.ptr<[[NDRANGE3]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_6:.*]] = llvm.load %[[VAL_5]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_7:.*]] = llvm.udiv %[[VAL_4]], %[[VAL_6]] : i64 +// CHECK-NEXT: %[[VAL_8:.*]] = llvm.getelementptr inbounds %[[VAL_2]][0, 0, 0, 0] : (!llvm.ptr<[[RANGE3]]>) -> !llvm.ptr +// CHECK-NEXT: llvm.store %[[VAL_7]], %[[VAL_8]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_9:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 0, 1] : (!llvm.ptr<[[NDRANGE3]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_10:.*]] = llvm.load %[[VAL_9]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_11:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0, 0, 1] : (!llvm.ptr<[[NDRANGE3]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_12:.*]] = llvm.load %[[VAL_11]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_13:.*]] = llvm.udiv %[[VAL_10]], %[[VAL_12]] : i64 +// CHECK-NEXT: %[[VAL_14:.*]] = llvm.getelementptr inbounds %[[VAL_2]][0, 0, 0, 1] : (!llvm.ptr<[[RANGE3]]>) -> !llvm.ptr +// CHECK-NEXT: llvm.store %[[VAL_13]], %[[VAL_14]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_15:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 0, 2] : (!llvm.ptr<[[NDRANGE3]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_16:.*]] = llvm.load %[[VAL_15]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_17:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0, 0, 2] : (!llvm.ptr<[[NDRANGE3]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_18:.*]] = llvm.load %[[VAL_17]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_19:.*]] = llvm.udiv %[[VAL_16]], %[[VAL_18]] : i64 +// CHECK-NEXT: %[[VAL_20:.*]] = llvm.getelementptr inbounds %[[VAL_2]][0, 0, 0, 2] : (!llvm.ptr<[[RANGE3]]>) -> !llvm.ptr +// CHECK-NEXT: llvm.store %[[VAL_19]], %[[VAL_20]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_21:.*]] = llvm.load %[[VAL_2]] : !llvm.ptr<[[RANGE3]]> +// CHECK-NEXT: llvm.return %[[VAL_21]] : !llvm.[[RANGE3]] +// CHECK-NEXT: } +func.func @test(%nd: memref) -> !sycl_range_3_ { + %0 = sycl.nd_range.get_group_range(%nd) { ArgumentTypes = [memref], FunctionName = @"get_group_range", MangledFunctionName = @"get_group_range", TypeName = @"nd_range" } : (memref) -> !sycl_range_3_ + return %0 : !sycl_range_3_ +} + +// ----- + +!sycl_id_1_ = !sycl.id<[1], (!sycl.array<[1], (memref<1xi64>)>)> +!sycl_range_1_ = !sycl.range<[1], (!sycl.array<[1], (memref<1xi64>)>)> +!sycl_item_base_1_ = !sycl.item_base<[1, false], (!sycl_range_1_, !sycl_id_1_)> +!sycl_item_1_ = !sycl.item<[1, false], (!sycl_item_base_1_)> + +// CHECK-LABEL: llvm.func @test( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[ITEM1:.*]]>) -> !llvm.[[ID1]] { +// CHECK-NEXT: %[[VAL_1:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 1] : (!llvm.ptr<[[ITEM1]]>) -> !llvm.ptr<[[ID1]]> +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] : !llvm.ptr<[[ID1]]> +// CHECK-NEXT: llvm.return %[[VAL_2]] : !llvm.[[ID1]] +// CHECK-NEXT: } +func.func @test(%item: memref) -> !sycl_id_1_ { + %0 = sycl.item.get_id(%item) { ArgumentTypes = [memref], FunctionName = @"get_id", MangledFunctionName = @"get_id", TypeName = @"item" } : (memref) -> !sycl_id_1_ + return %0 : !sycl_id_1_ +} + +// ----- + +!sycl_id_1_ = !sycl.id<[1], (!sycl.array<[1], (memref<1xi64>)>)> +!sycl_range_1_ = !sycl.range<[1], (!sycl.array<[1], (memref<1xi64>)>)> +!sycl_item_base_1_ = !sycl.item_base<[1, false], (!sycl_range_1_, !sycl_id_1_)> +!sycl_item_1_ = !sycl.item<[1, false], (!sycl_item_base_1_)> + +// CHECK-LABEL: llvm.func @test( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[ITEM1]]>, +// CHECK-SAME: %[[VAL_1:.*]]: i32) -> i64 { +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 1, 0, 0, %[[VAL_1]]] : (!llvm.ptr<[[ITEM1]]>, i32) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.load %[[VAL_2]] : !llvm.ptr +// CHECK-NEXT: llvm.return %[[VAL_3]] : i64 +// CHECK-NEXT: } +func.func @test(%item: memref, %i: i32) -> i64 { + %0 = sycl.item.get_id(%item, %i) { ArgumentTypes = [memref, i32], FunctionName = @"get_id", MangledFunctionName = @"get_id", TypeName = @"item" } : (memref, i32) -> i64 + return %0 : i64 +} + +// ----- + +!sycl_id_1_ = !sycl.id<[1], (!sycl.array<[1], (memref<1xi64>)>)> +!sycl_range_1_ = !sycl.range<[1], (!sycl.array<[1], (memref<1xi64>)>)> +!sycl_item_base_1_ = !sycl.item_base<[1, false], (!sycl_range_1_, !sycl_id_1_)> +!sycl_item_1_ = !sycl.item<[1, false], (!sycl_item_base_1_)> + +// CHECK-LABEL: llvm.func @test( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[ITEM1]]>) -> i64 { +// CHECK: %[[VAL_1:.*]] = llvm.mlir.constant(0 : i32) : i32 +// CHECK: %[[VAL_2:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 1, 0, 0, %[[VAL_1]]] : (!llvm.ptr<[[ITEM1]]>, i32) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.load %[[VAL_2]] : !llvm.ptr +// CHECK-NEXT: llvm.return %[[VAL_3]] : i64 +// CHECK-NEXT: } +func.func @test(%item: memref) -> i64 { + %0 = sycl.item.get_id(%item) { ArgumentTypes = [memref], FunctionName = @"operator unsigned long", MangledFunctionName = @"operator unsigned long", TypeName = @"item" } : (memref) -> i64 + return %0 : i64 +} + +// ----- + +!sycl_id_1_ = !sycl.id<[1], (!sycl.array<[1], (memref<1xi64>)>)> +!sycl_range_1_ = !sycl.range<[1], (!sycl.array<[1], (memref<1xi64>)>)> +!sycl_item_base_1_ = !sycl.item_base<[1, false], (!sycl_range_1_, !sycl_id_1_)> +!sycl_item_1_ = !sycl.item<[1, false], (!sycl_item_base_1_)> + +// CHECK-LABEL: llvm.func @test( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[ITEM1]]>) -> !llvm.[[RANGE1]] { +// CHECK-NEXT: %[[VAL_1:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0] : (!llvm.ptr<[[ITEM1]]>) -> !llvm.ptr<[[RANGE1]]> +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] : !llvm.ptr<[[RANGE1]]> +// CHECK-NEXT: llvm.return %[[VAL_2]] : !llvm.[[RANGE1]] +// CHECK-NEXT: } +func.func @test(%item: memref) -> !sycl_range_1_ { + %0 = sycl.item.get_range(%item) { ArgumentTypes = [memref], FunctionName = @"get_range", MangledFunctionName = @"get_range", TypeName = @"item" } : (memref) -> !sycl_range_1_ + return %0 : !sycl_range_1_ +} + +// ----- + +!sycl_id_1_ = !sycl.id<[1], (!sycl.array<[1], (memref<1xi64>)>)> +!sycl_range_1_ = !sycl.range<[1], (!sycl.array<[1], (memref<1xi64>)>)> +!sycl_item_base_1_ = !sycl.item_base<[1, false], (!sycl_range_1_, !sycl_id_1_)> +!sycl_item_1_ = !sycl.item<[1, false], (!sycl_item_base_1_)> + +// CHECK-LABEL: llvm.func @test( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[ITEM1]]>, +// CHECK-SAME: %[[VAL_1:.*]]: i32) -> i64 { +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 0, 0, %[[VAL_1]]] : (!llvm.ptr<[[ITEM1]]>, i32) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.load %[[VAL_2]] : !llvm.ptr +// CHECK-NEXT: llvm.return %[[VAL_3]] : i64 +// CHECK-NEXT: } +func.func @test(%item: memref, %i: i32) -> i64 { + %0 = sycl.item.get_range(%item, %i) { ArgumentTypes = [memref, i32], FunctionName = @"get_range", MangledFunctionName = @"get_range", TypeName = @"item" } : (memref, i32) -> i64 + return %0 : i64 +} + +// ----- + +!sycl_id_1_ = !sycl.id<[1], (!sycl.array<[1], (memref<1xi64>)>)> +!sycl_range_1_ = !sycl.range<[1], (!sycl.array<[1], (memref<1xi64>)>)> +!sycl_item_base_1_ = !sycl.item_base<[1, false], (!sycl_range_1_, !sycl_id_1_)> +!sycl_item_1_ = !sycl.item<[1, false], (!sycl_item_base_1_)> +!sycl_id_2_ = !sycl.id<[2], (!sycl.array<[2], (memref<2xi64>)>)> +!sycl_range_2_ = !sycl.range<[2], (!sycl.array<[2], (memref<2xi64>)>)> +!sycl_item_base_2_ = !sycl.item_base<[2, false], (!sycl_range_2_, !sycl_id_2_)> +!sycl_item_2_ = !sycl.item<[2, false], (!sycl_item_base_2_)> +!sycl_id_3_ = !sycl.id<[3], (!sycl.array<[3], (memref<3xi64>)>)> +!sycl_range_3_ = !sycl.range<[3], (!sycl.array<[3], (memref<3xi64>)>)> +!sycl_item_base_3_ = !sycl.item_base<[3, false], (!sycl_range_3_, !sycl_id_3_)> +!sycl_item_3_ = !sycl.item<[3, false], (!sycl_item_base_3_)> + +// CHECK-LABEL: llvm.func @test_1( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[ITEM1]]>) -> i64 { +// CHECK-NEXT: %[[VAL_1:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 1, 0, 0, 0] : (!llvm.ptr<[[ITEM1]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] : !llvm.ptr +// CHECK-NEXT: llvm.return %[[VAL_2]] : i64 +// CHECK-NEXT: } +func.func @test_1(%item: memref) -> i64 { + %0 = sycl.item.get_linear_id(%item) { ArgumentTypes = [memref], FunctionName = @"get_linear_id", MangledFunctionName = @"get_linear_id", TypeName = @"item" } : (memref) -> i64 + return %0 : i64 +} + +// CHECK-LABEL: llvm.func @test_2( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[ITEM2:.*]]>) -> i64 { +// CHECK-NEXT: %[[VAL_1:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 1, 0, 0, 0] : (!llvm.ptr<[[ITEM2]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 0, 0, 1] : (!llvm.ptr<[[ITEM2]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_4:.*]] = llvm.load %[[VAL_3]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_5:.*]] = llvm.mul %[[VAL_2]], %[[VAL_4]] : i64 +// CHECK-NEXT: %[[VAL_6:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 1, 0, 0, 1] : (!llvm.ptr<[[ITEM2]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_7:.*]] = llvm.load %[[VAL_6]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_8:.*]] = llvm.add %[[VAL_5]], %[[VAL_7]] : i64 +// CHECK-NEXT: llvm.return %[[VAL_8]] : i64 +// CHECK-NEXT: } +func.func @test_2(%item: memref) -> i64 { + %0 = sycl.item.get_linear_id(%item) { ArgumentTypes = [memref], FunctionName = @"get_linear_id", MangledFunctionName = @"get_linear_id", TypeName = @"item" } : (memref) -> i64 + return %0 : i64 +} + +// CHECK-LABEL: llvm.func @test_3( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[ITEM3:.*]]>) -> i64 { +// CHECK-NEXT: %[[VAL_1:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 1, 0, 0, 0] : (!llvm.ptr<[[ITEM3]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 0, 0, 1] : (!llvm.ptr<[[ITEM3]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_4:.*]] = llvm.load %[[VAL_3]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_5:.*]] = llvm.mul %[[VAL_2]], %[[VAL_4]] : i64 +// CHECK-NEXT: %[[VAL_6:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 0, 0, 2] : (!llvm.ptr<[[ITEM3]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_7:.*]] = llvm.load %[[VAL_6]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_8:.*]] = llvm.mul %[[VAL_5]], %[[VAL_7]] : i64 +// CHECK-NEXT: %[[VAL_9:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 1, 0, 0, 1] : (!llvm.ptr<[[ITEM3]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_10:.*]] = llvm.load %[[VAL_9]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_11:.*]] = llvm.mul %[[VAL_10]], %[[VAL_7]] : i64 +// CHECK-NEXT: %[[VAL_12:.*]] = llvm.add %[[VAL_8]], %[[VAL_11]] : i64 +// CHECK-NEXT: %[[VAL_13:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 1, 0, 0, 2] : (!llvm.ptr<[[ITEM3]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_14:.*]] = llvm.load %[[VAL_13]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_15:.*]] = llvm.add %[[VAL_12]], %[[VAL_14]] : i64 +// CHECK-NEXT: llvm.return %[[VAL_15]] : i64 +// CHECK-NEXT: } +func.func @test_3(%item: memref) -> i64 { + %0 = sycl.item.get_linear_id(%item) { ArgumentTypes = [memref], FunctionName = @"get_linear_id", MangledFunctionName = @"get_linear_id", TypeName = @"item" } : (memref) -> i64 + return %0 : i64 +} + +// ----- + +!sycl_id_1_ = !sycl.id<[1], (!sycl.array<[1], (memref<1xi64>)>)> +!sycl_range_1_ = !sycl.range<[1], (!sycl.array<[1], (memref<1xi64>)>)> +!sycl_item_base_1_ = !sycl.item_base<[1, true], (!sycl_range_1_, !sycl_id_1_, !sycl_id_1_)> +!sycl_item_1_ = !sycl.item<[1, true], (!sycl_item_base_1_)> +!sycl_id_2_ = !sycl.id<[2], (!sycl.array<[2], (memref<2xi64>)>)> +!sycl_range_2_ = !sycl.range<[2], (!sycl.array<[2], (memref<2xi64>)>)> +!sycl_item_base_2_ = !sycl.item_base<[2, true], (!sycl_range_2_, !sycl_id_2_, !sycl_id_2_)> +!sycl_item_2_ = !sycl.item<[2, true], (!sycl_item_base_2_)> +!sycl_id_3_ = !sycl.id<[3], (!sycl.array<[3], (memref<3xi64>)>)> +!sycl_range_3_ = !sycl.range<[3], (!sycl.array<[3], (memref<3xi64>)>)> +!sycl_item_base_3_ = !sycl.item_base<[3, true], (!sycl_range_3_, !sycl_id_3_, !sycl_id_3_)> +!sycl_item_3_ = !sycl.item<[3, true], (!sycl_item_base_3_)> + +// CHECK-LABEL: llvm.func @test_1( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[ITEM1:.*]]>) -> i64 { +// CHECK-NEXT: %[[VAL_1:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 1, 0, 0, 0] : (!llvm.ptr<[[ITEM1]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 2, 0, 0, 0] : (!llvm.ptr<[[ITEM1]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_4:.*]] = llvm.load %[[VAL_3]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_5:.*]] = llvm.sub %[[VAL_2]], %[[VAL_4]] : i64 +// CHECK-NEXT: llvm.return %[[VAL_5]] : i64 +// CHECK-NEXT: } +func.func @test_1(%item: memref) -> i64 { + %0 = sycl.item.get_linear_id(%item) { ArgumentTypes = [memref], FunctionName = @"get_linear_id", MangledFunctionName = @"get_linear_id", TypeName = @"item" } : (memref) -> i64 + return %0 : i64 +} + +// CHECK-LABEL: llvm.func @test_2( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[ITEM2:.*]]>) -> i64 { +// CHECK-NEXT: %[[VAL_1:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 1, 0, 0, 0] : (!llvm.ptr<[[ITEM2]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 2, 0, 0, 0] : (!llvm.ptr<[[ITEM2]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_4:.*]] = llvm.load %[[VAL_3]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_5:.*]] = llvm.sub %[[VAL_2]], %[[VAL_4]] : i64 +// CHECK-NEXT: %[[VAL_6:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 0, 0, 1] : (!llvm.ptr<[[ITEM2]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_7:.*]] = llvm.load %[[VAL_6]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_8:.*]] = llvm.mul %[[VAL_5]], %[[VAL_7]] : i64 +// CHECK-NEXT: %[[VAL_9:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 1, 0, 0, 1] : (!llvm.ptr<[[ITEM2]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_10:.*]] = llvm.load %[[VAL_9]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_11:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 2, 0, 0, 1] : (!llvm.ptr<[[ITEM2]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_12:.*]] = llvm.load %[[VAL_11]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_13:.*]] = llvm.sub %[[VAL_10]], %[[VAL_12]] : i64 +// CHECK-NEXT: %[[VAL_14:.*]] = llvm.add %[[VAL_8]], %[[VAL_13]] : i64 +// CHECK-NEXT: llvm.return %[[VAL_14]] : i64 +// CHECK-NEXT: } +func.func @test_2(%item: memref) -> i64 { + %0 = sycl.item.get_linear_id(%item) { ArgumentTypes = [memref], FunctionName = @"get_linear_id", MangledFunctionName = @"get_linear_id", TypeName = @"item" } : (memref) -> i64 + return %0 : i64 +} + +// CHECK-LABEL: llvm.func @test_3( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[ITEM3:.*]]>) -> i64 { +// CHECK-NEXT: %[[VAL_1:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 1, 0, 0, 0] : (!llvm.ptr<[[ITEM3]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 2, 0, 0, 0] : (!llvm.ptr<[[ITEM3]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_4:.*]] = llvm.load %[[VAL_3]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_5:.*]] = llvm.sub %[[VAL_2]], %[[VAL_4]] : i64 +// CHECK-NEXT: %[[VAL_6:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 0, 0, 1] : (!llvm.ptr<[[ITEM3]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_7:.*]] = llvm.load %[[VAL_6]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_8:.*]] = llvm.mul %[[VAL_5]], %[[VAL_7]] : i64 +// CHECK-NEXT: %[[VAL_9:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 0, 0, 2] : (!llvm.ptr<[[ITEM3]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_10:.*]] = llvm.load %[[VAL_9]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_11:.*]] = llvm.mul %[[VAL_8]], %[[VAL_10]] : i64 +// CHECK-NEXT: %[[VAL_12:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 1, 0, 0, 1] : (!llvm.ptr<[[ITEM3]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_13:.*]] = llvm.load %[[VAL_12]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_14:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 2, 0, 0, 1] : (!llvm.ptr<[[ITEM3]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_15:.*]] = llvm.load %[[VAL_14]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_16:.*]] = llvm.sub %[[VAL_13]], %[[VAL_15]] : i64 +// CHECK-NEXT: %[[VAL_17:.*]] = llvm.mul %[[VAL_16]], %[[VAL_10]] : i64 +// CHECK-NEXT: %[[VAL_18:.*]] = llvm.add %[[VAL_11]], %[[VAL_17]] : i64 +// CHECK-NEXT: %[[VAL_19:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 1, 0, 0, 2] : (!llvm.ptr<[[ITEM3]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_20:.*]] = llvm.load %[[VAL_19]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_21:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 2, 0, 0, 2] : (!llvm.ptr<[[ITEM3]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_22:.*]] = llvm.load %[[VAL_21]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_23:.*]] = llvm.sub %[[VAL_20]], %[[VAL_22]] : i64 +// CHECK-NEXT: %[[VAL_24:.*]] = llvm.add %[[VAL_18]], %[[VAL_23]] : i64 +// CHECK-NEXT: llvm.return %[[VAL_24]] : i64 +// CHECK-NEXT: } +func.func @test_3(%item: memref) -> i64 { + %0 = sycl.item.get_linear_id(%item) { ArgumentTypes = [memref], FunctionName = @"get_linear_id", MangledFunctionName = @"get_linear_id", TypeName = @"item" } : (memref) -> i64 + return %0 : i64 +} + +// ----- + +!sycl_id_1_ = !sycl.id<[1], (!sycl.array<[1], (memref<1xi64>)>)> +!sycl_range_1_ = !sycl.range<[1], (!sycl.array<[1], (memref<1xi64>)>)> +!sycl_item_base_1_ = !sycl.item_base<[1, true], (!sycl_range_1_, !sycl_id_1_, !sycl_id_1_)> +!sycl_item_base_1_1 = !sycl.item_base<[1, false], (!sycl_range_1_, !sycl_id_1_)> +!sycl_item_1_ = !sycl.item<[1, true], (!sycl_item_base_1_)> +!sycl_item_1_1_ = !sycl.item<[1, false], (!sycl_item_base_1_1)> +!sycl_group_1_ = !sycl.group<[1], (!sycl_range_1_, !sycl_range_1_, !sycl_range_1_, !sycl_id_1_)> +!sycl_nd_item_1_ = !sycl.nd_item<[1], (!sycl_item_1_, !sycl_item_1_1_, !sycl_group_1_)> + +// CHECK-LABEL: llvm.func @test( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[NDITEM1:.*]]>) -> !llvm.[[ID1]] { +// CHECK-NEXT: %[[VAL_1:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 1] : (!llvm.ptr<[[NDITEM1]]>) -> !llvm.ptr<[[ID1]]> +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] : !llvm.ptr<[[ID1]]> +// CHECK-NEXT: llvm.return %[[VAL_2]] : !llvm.[[ID1]] +// CHECK-NEXT: } +func.func @test(%nd: memref) -> !sycl_id_1_ { + %0 = sycl.nd_item.get_global_id(%nd) { ArgumentTypes = [memref], FunctionName = @"get_global_id", MangledFunctionName = @"get_global_id", TypeName = @"nd_item" } : (memref) -> !sycl_id_1_ + return %0 : !sycl_id_1_ +} + +// ----- + +!sycl_id_1_ = !sycl.id<[1], (!sycl.array<[1], (memref<1xi64>)>)> +!sycl_range_1_ = !sycl.range<[1], (!sycl.array<[1], (memref<1xi64>)>)> +!sycl_item_base_1_ = !sycl.item_base<[1, true], (!sycl_range_1_, !sycl_id_1_, !sycl_id_1_)> +!sycl_item_base_1_1 = !sycl.item_base<[1, false], (!sycl_range_1_, !sycl_id_1_)> +!sycl_item_1_ = !sycl.item<[1, true], (!sycl_item_base_1_)> +!sycl_item_1_1_ = !sycl.item<[1, false], (!sycl_item_base_1_1)> +!sycl_group_1_ = !sycl.group<[1], (!sycl_range_1_, !sycl_range_1_, !sycl_range_1_, !sycl_id_1_)> +!sycl_nd_item_1_ = !sycl.nd_item<[1], (!sycl_item_1_, !sycl_item_1_1_, !sycl_group_1_)> + +// CHECK-LABEL: llvm.func @test( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[NDITEM1]]>, +// CHECK-SAME: %[[VAL_1:.*]]: i32) -> i64 { +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 1, 0, 0, %[[VAL_1]]] : (!llvm.ptr<[[NDITEM1]]>, i32) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.load %[[VAL_2]] : !llvm.ptr +// CHECK-NEXT: llvm.return %[[VAL_3]] : i64 +// CHECK-NEXT: } +func.func @test(%nd: memref, %i: i32) -> i64 { + %0 = sycl.nd_item.get_global_id(%nd, %i) { ArgumentTypes = [memref, i32], FunctionName = @"get_global_id", MangledFunctionName = @"get_global_id", TypeName = @"nd_item" } : (memref, i32) -> i64 + return %0 : i64 +} + +// ----- + +!sycl_id_1_ = !sycl.id<[1], (!sycl.array<[1], (memref<1xi64>)>)> +!sycl_range_1_ = !sycl.range<[1], (!sycl.array<[1], (memref<1xi64>)>)> +!sycl_item_base_1_ = !sycl.item_base<[1, true], (!sycl_range_1_, !sycl_id_1_, !sycl_id_1_)> +!sycl_item_base_1_1_ = !sycl.item_base<[1, false], (!sycl_range_1_, !sycl_id_1_)> +!sycl_item_1_1_ = !sycl.item<[1, false], (!sycl_item_base_1_1_)> +!sycl_item_1_ = !sycl.item<[1, true], (!sycl_item_base_1_)> +!sycl_group_1_ = !sycl.group<[1], (!sycl_range_1_, !sycl_range_1_, !sycl_range_1_, !sycl_id_1_)> +!sycl_nd_item_1_ = !sycl.nd_item<[1], (!sycl_item_1_, !sycl_item_1_1_, !sycl_group_1_)> +!sycl_id_2_ = !sycl.id<[2], (!sycl.array<[2], (memref<2xi64>)>)> +!sycl_range_2_ = !sycl.range<[2], (!sycl.array<[2], (memref<2xi64>)>)> +!sycl_item_base_2_ = !sycl.item_base<[2, true], (!sycl_range_2_, !sycl_id_2_, !sycl_id_2_)> +!sycl_item_2_ = !sycl.item<[2, true], (!sycl_item_base_2_)> +!sycl_item_base_2_1_ = !sycl.item_base<[1, false], (!sycl_range_1_, !sycl_id_1_)> +!sycl_item_2_1_ = !sycl.item<[1, false], (!sycl_item_base_2_1_)> +!sycl_group_2_ = !sycl.group<[2], (!sycl_range_2_, !sycl_range_2_, !sycl_range_2_, !sycl_id_2_)> +!sycl_nd_item_2_ = !sycl.nd_item<[2], (!sycl_item_2_, !sycl_item_2_1_, !sycl_group_2_)> +!sycl_id_3_ = !sycl.id<[3], (!sycl.array<[3], (memref<3xi64>)>)> +!sycl_range_3_ = !sycl.range<[3], (!sycl.array<[3], (memref<3xi64>)>)> +!sycl_item_base_3_ = !sycl.item_base<[3, true], (!sycl_range_3_, !sycl_id_3_, !sycl_id_3_)> +!sycl_item_3_ = !sycl.item<[3, true], (!sycl_item_base_3_)> +!sycl_item_base_3_1_ = !sycl.item_base<[1, false], (!sycl_range_1_, !sycl_id_1_)> +!sycl_item_3_1_ = !sycl.item<[1, false], (!sycl_item_base_3_1_)> +!sycl_group_3_ = !sycl.group<[3], (!sycl_range_3_, !sycl_range_3_, !sycl_range_3_, !sycl_id_3_)> +!sycl_nd_item_3_ = !sycl.nd_item<[3], (!sycl_item_3_, !sycl_item_3_1_, !sycl_group_3_)> + +// CHECK-LABEL: llvm.func @test_1( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[NDITEM1]]>) -> i64 { +// CHECK-NEXT: %[[VAL_1:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 1, 0, 0, 0] : (!llvm.ptr<[[NDITEM1]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] : !llvm.ptr +// CHECK-NEXT: llvm.return %[[VAL_2]] : i64 +// CHECK-NEXT: } +func.func @test_1(%nd: memref) -> i64 { + %0 = sycl.nd_item.get_global_linear_id(%nd) { ArgumentTypes = [memref], FunctionName = @"get_global_linear_id", MangledFunctionName = @"get_global_linear_id", TypeName = @"nd_item" } : (memref) -> i64 + return %0 : i64 +} + +// CHECK-LABEL: llvm.func @test_2( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[NDITEM2:.*]]>) -> i64 { +// CHECK-NEXT: %[[VAL_1:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 1, 0, 0, 0] : (!llvm.ptr<[[NDITEM2]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 0, 0, 0, 1] : (!llvm.ptr<[[NDITEM2]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_4:.*]] = llvm.load %[[VAL_3]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_5:.*]] = llvm.mul %[[VAL_2]], %[[VAL_4]] : i64 +// CHECK-NEXT: %[[VAL_6:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 1, 0, 0, 1] : (!llvm.ptr<[[NDITEM2]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_7:.*]] = llvm.load %[[VAL_6]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_8:.*]] = llvm.add %[[VAL_5]], %[[VAL_7]] : i64 +// CHECK-NEXT: llvm.return %[[VAL_8]] : i64 +// CHECK-NEXT: } +func.func @test_2(%nd: memref) -> i64 { + %0 = sycl.nd_item.get_global_linear_id(%nd) { ArgumentTypes = [memref], FunctionName = @"get_global_linear_id", MangledFunctionName = @"get_global_linear_id", TypeName = @"nd_item" } : (memref) -> i64 + return %0 : i64 +} + +// CHECK-LABEL: llvm.func @test_3( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[NDITEM3:.*]]>) -> i64 { +// CHECK-NEXT: %[[VAL_1:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 1, 0, 0, 0] : (!llvm.ptr<[[NDITEM3]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 0, 0, 0, 1] : (!llvm.ptr<[[NDITEM3]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_4:.*]] = llvm.load %[[VAL_3]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_5:.*]] = llvm.mul %[[VAL_2]], %[[VAL_4]] : i64 +// CHECK-NEXT: %[[VAL_6:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 0, 0, 0, 2] : (!llvm.ptr<[[NDITEM3]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_7:.*]] = llvm.load %[[VAL_6]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_8:.*]] = llvm.mul %[[VAL_5]], %[[VAL_7]] : i64 +// CHECK-NEXT: %[[VAL_9:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 1, 0, 0, 1] : (!llvm.ptr<[[NDITEM3]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_10:.*]] = llvm.load %[[VAL_9]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_11:.*]] = llvm.mul %[[VAL_10]], %[[VAL_7]] : i64 +// CHECK-NEXT: %[[VAL_12:.*]] = llvm.add %[[VAL_8]], %[[VAL_11]] : i64 +// CHECK-NEXT: %[[VAL_13:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 1, 0, 0, 2] : (!llvm.ptr<[[NDITEM3]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_14:.*]] = llvm.load %[[VAL_13]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_15:.*]] = llvm.add %[[VAL_12]], %[[VAL_14]] : i64 +// CHECK-NEXT: llvm.return %[[VAL_15]] : i64 +// CHECK-NEXT: } +func.func @test_3(%nd: memref) -> i64 { + %0 = sycl.nd_item.get_global_linear_id(%nd) { ArgumentTypes = [memref], FunctionName = @"get_global_linear_id", MangledFunctionName = @"get_global_linear_id", TypeName = @"nd_item" } : (memref) -> i64 + return %0 : i64 +} + +// ----- + +!sycl_id_1_ = !sycl.id<[1], (!sycl.array<[1], (memref<1xi64>)>)> +!sycl_range_1_ = !sycl.range<[1], (!sycl.array<[1], (memref<1xi64>)>)> +!sycl_item_base_1_ = !sycl.item_base<[1, true], (!sycl_range_1_, !sycl_id_1_, !sycl_id_1_)> +!sycl_item_base_1_1 = !sycl.item_base<[1, false], (!sycl_range_1_, !sycl_id_1_)> +!sycl_item_1_ = !sycl.item<[1, true], (!sycl_item_base_1_)> +!sycl_item_1_1_ = !sycl.item<[1, false], (!sycl_item_base_1_1)> +!sycl_group_1_ = !sycl.group<[1], (!sycl_range_1_, !sycl_range_1_, !sycl_range_1_, !sycl_id_1_)> +!sycl_nd_item_1_ = !sycl.nd_item<[1], (!sycl_item_1_, !sycl_item_1_1_, !sycl_group_1_)> + +// CHECK-LABEL: llvm.func @test( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[NDITEM1]]>) -> !llvm.[[ID1]] { +// CHECK-NEXT: %[[VAL_1:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0, 1] : (!llvm.ptr<[[NDITEM1]]>) -> !llvm.ptr<[[ID1]]> +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] : !llvm.ptr<[[ID1]]> +// CHECK-NEXT: llvm.return %[[VAL_2]] : !llvm.[[ID1]] +// CHECK-NEXT: } +func.func @test(%nd: memref) -> !sycl_id_1_ { + %0 = sycl.nd_item.get_local_id(%nd) { ArgumentTypes = [memref], FunctionName = @"get_local_id", MangledFunctionName = @"get_local_id", TypeName = @"nd_item" } : (memref) -> !sycl_id_1_ + return %0 : !sycl_id_1_ +} + +// ----- + +!sycl_id_1_ = !sycl.id<[1], (!sycl.array<[1], (memref<1xi64>)>)> +!sycl_range_1_ = !sycl.range<[1], (!sycl.array<[1], (memref<1xi64>)>)> +!sycl_item_base_1_ = !sycl.item_base<[1, true], (!sycl_range_1_, !sycl_id_1_, !sycl_id_1_)> +!sycl_item_base_1_1 = !sycl.item_base<[1, false], (!sycl_range_1_, !sycl_id_1_)> +!sycl_item_1_ = !sycl.item<[1, true], (!sycl_item_base_1_)> +!sycl_item_1_1_ = !sycl.item<[1, false], (!sycl_item_base_1_1)> +!sycl_group_1_ = !sycl.group<[1], (!sycl_range_1_, !sycl_range_1_, !sycl_range_1_, !sycl_id_1_)> +!sycl_nd_item_1_ = !sycl.nd_item<[1], (!sycl_item_1_, !sycl_item_1_1_, !sycl_group_1_)> + +// CHECK-LABEL: llvm.func @test( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[NDITEM1]]>, +// CHECK-SAME: %[[VAL_1:.*]]: i32) -> i64 { +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0, 1, 0, 0, %[[VAL_1]]] : (!llvm.ptr<[[NDITEM1]]>, i32) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.load %[[VAL_2]] : !llvm.ptr +// CHECK-NEXT: llvm.return %[[VAL_3]] : i64 +// CHECK-NEXT: } +func.func @test(%nd: memref, %i: i32) -> i64 { + %0 = sycl.nd_item.get_local_id(%nd, %i) { ArgumentTypes = [memref, i32], FunctionName = @"get_local_id", MangledFunctionName = @"get_local_id", TypeName = @"nd_item" } : (memref, i32) -> i64 + return %0 : i64 +} + +// ----- + +!sycl_id_1_ = !sycl.id<[1], (!sycl.array<[1], (memref<1xi64>)>)> +!sycl_range_1_ = !sycl.range<[1], (!sycl.array<[1], (memref<1xi64>)>)> +!sycl_item_base_1_ = !sycl.item_base<[1, true], (!sycl_range_1_, !sycl_id_1_, !sycl_id_1_)> +!sycl_item_base_1_1_ = !sycl.item_base<[1, false], (!sycl_range_1_, !sycl_id_1_)> +!sycl_item_1_1_ = !sycl.item<[1, false], (!sycl_item_base_1_1_)> +!sycl_item_1_ = !sycl.item<[1, true], (!sycl_item_base_1_)> +!sycl_group_1_ = !sycl.group<[1], (!sycl_range_1_, !sycl_range_1_, !sycl_range_1_, !sycl_id_1_)> +!sycl_nd_item_1_ = !sycl.nd_item<[1], (!sycl_item_1_, !sycl_item_1_1_, !sycl_group_1_)> +!sycl_id_2_ = !sycl.id<[2], (!sycl.array<[2], (memref<2xi64>)>)> +!sycl_range_2_ = !sycl.range<[2], (!sycl.array<[2], (memref<2xi64>)>)> +!sycl_item_base_2_ = !sycl.item_base<[2, true], (!sycl_range_2_, !sycl_id_2_, !sycl_id_2_)> +!sycl_item_2_ = !sycl.item<[2, true], (!sycl_item_base_2_)> +!sycl_item_base_2_1_ = !sycl.item_base<[1, false], (!sycl_range_1_, !sycl_id_1_)> +!sycl_item_2_1_ = !sycl.item<[1, false], (!sycl_item_base_2_1_)> +!sycl_group_2_ = !sycl.group<[2], (!sycl_range_2_, !sycl_range_2_, !sycl_range_2_, !sycl_id_2_)> +!sycl_nd_item_2_ = !sycl.nd_item<[2], (!sycl_item_2_, !sycl_item_2_1_, !sycl_group_2_)> +!sycl_id_3_ = !sycl.id<[3], (!sycl.array<[3], (memref<3xi64>)>)> +!sycl_range_3_ = !sycl.range<[3], (!sycl.array<[3], (memref<3xi64>)>)> +!sycl_item_base_3_ = !sycl.item_base<[3, true], (!sycl_range_3_, !sycl_id_3_, !sycl_id_3_)> +!sycl_item_3_ = !sycl.item<[3, true], (!sycl_item_base_3_)> +!sycl_item_base_3_1_ = !sycl.item_base<[1, false], (!sycl_range_1_, !sycl_id_1_)> +!sycl_item_3_1_ = !sycl.item<[1, false], (!sycl_item_base_3_1_)> +!sycl_group_3_ = !sycl.group<[3], (!sycl_range_3_, !sycl_range_3_, !sycl_range_3_, !sycl_id_3_)> +!sycl_nd_item_3_ = !sycl.nd_item<[3], (!sycl_item_3_, !sycl_item_3_1_, !sycl_group_3_)> + +// CHECK-LABEL: llvm.func @test_1( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[NDITEM1]]>) -> i64 { +// CHECK-NEXT: %[[VAL_1:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0, 1, 0, 0, 0] : (!llvm.ptr<[[NDITEM1]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] : !llvm.ptr +// CHECK-NEXT: llvm.return %[[VAL_2]] : i64 +// CHECK-NEXT: } +func.func @test_1(%nd: memref) -> i64 { + %0 = sycl.nd_item.get_local_linear_id(%nd) { ArgumentTypes = [memref], FunctionName = @"get_local_linear_id", MangledFunctionName = @"get_local_linear_id", TypeName = @"nd_item" } : (memref) -> i64 + return %0 : i64 +} + +// CHECK-LABEL: llvm.func @test_2( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[NDITEM2]]>) -> i64 { +// CHECK-NEXT: %[[VAL_1:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0, 1, 0, 0, 0] : (!llvm.ptr<[[NDITEM2]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0, 0, 0, 0, 1] : (!llvm.ptr<[[NDITEM2]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_4:.*]] = llvm.load %[[VAL_3]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_5:.*]] = llvm.mul %[[VAL_2]], %[[VAL_4]] : i64 +// CHECK-NEXT: %[[VAL_6:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0, 1, 0, 0, 1] : (!llvm.ptr<[[NDITEM2]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_7:.*]] = llvm.load %[[VAL_6]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_8:.*]] = llvm.add %[[VAL_5]], %[[VAL_7]] : i64 +// CHECK-NEXT: llvm.return %[[VAL_8]] : i64 +// CHECK-NEXT: } +func.func @test_2(%nd: memref) -> i64 { + %0 = sycl.nd_item.get_local_linear_id(%nd) { ArgumentTypes = [memref], FunctionName = @"get_local_linear_id", MangledFunctionName = @"get_local_linear_id", TypeName = @"nd_item" } : (memref) -> i64 + return %0 : i64 +} + +// CHECK-LABEL: llvm.func @test_3( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[NDITEM3]]>) -> i64 { +// CHECK-NEXT: %[[VAL_1:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0, 1, 0, 0, 0] : (!llvm.ptr<[[NDITEM3]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0, 0, 0, 0, 1] : (!llvm.ptr<[[NDITEM3]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_4:.*]] = llvm.load %[[VAL_3]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_5:.*]] = llvm.mul %[[VAL_2]], %[[VAL_4]] : i64 +// CHECK-NEXT: %[[VAL_6:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0, 0, 0, 0, 2] : (!llvm.ptr<[[NDITEM3]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_7:.*]] = llvm.load %[[VAL_6]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_8:.*]] = llvm.mul %[[VAL_5]], %[[VAL_7]] : i64 +// CHECK-NEXT: %[[VAL_9:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0, 1, 0, 0, 1] : (!llvm.ptr<[[NDITEM3]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_10:.*]] = llvm.load %[[VAL_9]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_11:.*]] = llvm.mul %[[VAL_10]], %[[VAL_7]] : i64 +// CHECK-NEXT: %[[VAL_12:.*]] = llvm.add %[[VAL_8]], %[[VAL_11]] : i64 +// CHECK-NEXT: %[[VAL_13:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0, 1, 0, 0, 2] : (!llvm.ptr<[[NDITEM3]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_14:.*]] = llvm.load %[[VAL_13]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_15:.*]] = llvm.add %[[VAL_12]], %[[VAL_14]] : i64 +// CHECK-NEXT: llvm.return %[[VAL_15]] : i64 +// CHECK-NEXT: } +func.func @test_3(%nd: memref) -> i64 { + %0 = sycl.nd_item.get_local_linear_id(%nd) { ArgumentTypes = [memref], FunctionName = @"get_local_linear_id", MangledFunctionName = @"get_local_linear_id", TypeName = @"nd_item" } : (memref) -> i64 + return %0 : i64 +} + +// ----- + +!sycl_id_1_ = !sycl.id<[1], (!sycl.array<[1], (memref<1xi64>)>)> +!sycl_range_1_ = !sycl.range<[1], (!sycl.array<[1], (memref<1xi64>)>)> +!sycl_item_base_1_ = !sycl.item_base<[1, true], (!sycl_range_1_, !sycl_id_1_, !sycl_id_1_)> +!sycl_item_base_1_1 = !sycl.item_base<[1, false], (!sycl_range_1_, !sycl_id_1_)> +!sycl_item_1_ = !sycl.item<[1, true], (!sycl_item_base_1_)> +!sycl_item_1_1_ = !sycl.item<[1, false], (!sycl_item_base_1_1)> +!sycl_group_1_ = !sycl.group<[1], (!sycl_range_1_, !sycl_range_1_, !sycl_range_1_, !sycl_id_1_)> +!sycl_nd_item_1_ = !sycl.nd_item<[1], (!sycl_item_1_, !sycl_item_1_1_, !sycl_group_1_)> + +// CHECK-LABEL: llvm.func @test( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[NDITEM1]]>) -> !llvm.[[GROUP1:.*]] { +// CHECK-NEXT: %[[VAL_1:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 2] : (!llvm.ptr<[[NDITEM1]]>) -> !llvm.ptr<[[GROUP1]]> +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] : !llvm.ptr<[[GROUP1]]> +// CHECK-NEXT: llvm.return %[[VAL_2]] : !llvm.[[GROUP1]] +// CHECK-NEXT: } +func.func @test(%nd: memref) -> !sycl_group_1_ { + %0 = sycl.nd_item.get_group(%nd) { ArgumentTypes = [memref], FunctionName = @"get_group", MangledFunctionName = @"get_group", TypeName = @"nd_item" } : (memref) -> !sycl_group_1_ + return %0 : !sycl_group_1_ +} + +// ----- + +!sycl_id_1_ = !sycl.id<[1], (!sycl.array<[1], (memref<1xi64>)>)> +!sycl_range_1_ = !sycl.range<[1], (!sycl.array<[1], (memref<1xi64>)>)> +!sycl_item_base_1_ = !sycl.item_base<[1, true], (!sycl_range_1_, !sycl_id_1_, !sycl_id_1_)> +!sycl_item_base_1_1 = !sycl.item_base<[1, false], (!sycl_range_1_, !sycl_id_1_)> +!sycl_item_1_ = !sycl.item<[1, true], (!sycl_item_base_1_)> +!sycl_item_1_1_ = !sycl.item<[1, false], (!sycl_item_base_1_1)> +!sycl_group_1_ = !sycl.group<[1], (!sycl_range_1_, !sycl_range_1_, !sycl_range_1_, !sycl_id_1_)> +!sycl_nd_item_1_ = !sycl.nd_item<[1], (!sycl_item_1_, !sycl_item_1_1_, !sycl_group_1_)> + +// CHECK-LABEL: llvm.func @test( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[NDITEM1]]>, +// CHECK-SAME: %[[VAL_1:.*]]: i32) -> i64 { +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 2, 3, 0, 0, %[[VAL_1]]] : (!llvm.ptr<[[NDITEM1]]>, i32) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.load %[[VAL_2]] : !llvm.ptr +// CHECK-NEXT: llvm.return %[[VAL_3]] : i64 +// CHECK-NEXT: } +func.func @test(%nd: memref, %i: i32) -> i64 { + %0 = sycl.nd_item.get_group(%nd, %i) { ArgumentTypes = [memref, i32], FunctionName = @"get_group", MangledFunctionName = @"get_group", TypeName = @"nd_item" } : (memref, i32) -> i64 + return %0 : i64 +} + +// ----- + +!sycl_id_1_ = !sycl.id<[1], (!sycl.array<[1], (memref<1xi64>)>)> +!sycl_range_1_ = !sycl.range<[1], (!sycl.array<[1], (memref<1xi64>)>)> +!sycl_item_base_1_ = !sycl.item_base<[1, true], (!sycl_range_1_, !sycl_id_1_, !sycl_id_1_)> +!sycl_item_base_1_1 = !sycl.item_base<[1, false], (!sycl_range_1_, !sycl_id_1_)> +!sycl_item_1_ = !sycl.item<[1, true], (!sycl_item_base_1_)> +!sycl_item_1_1_ = !sycl.item<[1, false], (!sycl_item_base_1_1)> +!sycl_group_1_ = !sycl.group<[1], (!sycl_range_1_, !sycl_range_1_, !sycl_range_1_, !sycl_id_1_)> +!sycl_nd_item_1_ = !sycl.nd_item<[1], (!sycl_item_1_, !sycl_item_1_1_, !sycl_group_1_)> + +// CHECK-LABEL: llvm.func @test( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[NDITEM1]]>) -> !llvm.[[RANGE1]] { +// CHECK-NEXT: %[[VAL_1:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 2, 2] : (!llvm.ptr<[[NDITEM1]]>) -> !llvm.ptr<[[RANGE1]]> +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] : !llvm.ptr<[[RANGE1]]> +// CHECK-NEXT: llvm.return %[[VAL_2]] : !llvm.[[RANGE1]] +// CHECK-NEXT: } +func.func @test(%nd: memref) -> !sycl_range_1_ { + %0 = sycl.nd_item.get_group_range(%nd) { ArgumentTypes = [memref], FunctionName = @"get_group_range", MangledFunctionName = @"get_group_range", TypeName = @"nd_item" } : (memref) -> !sycl_range_1_ + return %0 : !sycl_range_1_ +} + +// ----- + +!sycl_id_1_ = !sycl.id<[1], (!sycl.array<[1], (memref<1xi64>)>)> +!sycl_range_1_ = !sycl.range<[1], (!sycl.array<[1], (memref<1xi64>)>)> +!sycl_item_base_1_ = !sycl.item_base<[1, true], (!sycl_range_1_, !sycl_id_1_, !sycl_id_1_)> +!sycl_item_base_1_1 = !sycl.item_base<[1, false], (!sycl_range_1_, !sycl_id_1_)> +!sycl_item_1_ = !sycl.item<[1, true], (!sycl_item_base_1_)> +!sycl_item_1_1_ = !sycl.item<[1, false], (!sycl_item_base_1_1)> +!sycl_group_1_ = !sycl.group<[1], (!sycl_range_1_, !sycl_range_1_, !sycl_range_1_, !sycl_id_1_)> +!sycl_nd_item_1_ = !sycl.nd_item<[1], (!sycl_item_1_, !sycl_item_1_1_, !sycl_group_1_)> + +// CHECK-LABEL: llvm.func @test( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[NDITEM1]]>, +// CHECK-SAME: %[[VAL_1:.*]]: i32) -> i64 { +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 2, 2, 0, 0, %[[VAL_1]]] : (!llvm.ptr<[[NDITEM1]]>, i32) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.load %[[VAL_2]] : !llvm.ptr +// CHECK-NEXT: llvm.return %[[VAL_3]] : i64 +// CHECK-NEXT: } +func.func @test(%nd: memref, %i: i32) -> i64 { + %0 = sycl.nd_item.get_group_range(%nd, %i) { ArgumentTypes = [memref, i32], FunctionName = @"get_group_range", MangledFunctionName = @"get_group_range", TypeName = @"nd_item" } : (memref, i32) -> i64 + return %0 : i64 +} + +// ----- + +!sycl_id_1_ = !sycl.id<[1], (!sycl.array<[1], (memref<1xi64>)>)> +!sycl_range_1_ = !sycl.range<[1], (!sycl.array<[1], (memref<1xi64>)>)> +!sycl_item_base_1_ = !sycl.item_base<[1, true], (!sycl_range_1_, !sycl_id_1_, !sycl_id_1_)> +!sycl_item_base_1_1 = !sycl.item_base<[1, false], (!sycl_range_1_, !sycl_id_1_)> +!sycl_item_1_ = !sycl.item<[1, true], (!sycl_item_base_1_)> +!sycl_item_1_1_ = !sycl.item<[1, false], (!sycl_item_base_1_1)> +!sycl_group_1_ = !sycl.group<[1], (!sycl_range_1_, !sycl_range_1_, !sycl_range_1_, !sycl_id_1_)> +!sycl_nd_item_1_ = !sycl.nd_item<[1], (!sycl_item_1_, !sycl_item_1_1_, !sycl_group_1_)> + +// CHECK-LABEL: llvm.func @test( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[NDITEM1]]>) -> !llvm.[[RANGE1]] { +// CHECK-NEXT: %[[VAL_1:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0, 0] : (!llvm.ptr<[[NDITEM1]]>) -> !llvm.ptr<[[RANGE1]]> +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] : !llvm.ptr<[[RANGE1]]> +// CHECK-NEXT: llvm.return %[[VAL_2]] : !llvm.[[RANGE1]] +// CHECK-NEXT: } +func.func @test(%nd: memref) -> !sycl_range_1_ { + %0 = sycl.nd_item.get_local_range(%nd) { ArgumentTypes = [memref], FunctionName = @"get_local_range", MangledFunctionName = @"get_local_range", TypeName = @"nd_item" } : (memref) -> !sycl_range_1_ + return %0 : !sycl_range_1_ +} + +// ----- + +!sycl_id_1_ = !sycl.id<[1], (!sycl.array<[1], (memref<1xi64>)>)> +!sycl_range_1_ = !sycl.range<[1], (!sycl.array<[1], (memref<1xi64>)>)> +!sycl_item_base_1_ = !sycl.item_base<[1, true], (!sycl_range_1_, !sycl_id_1_, !sycl_id_1_)> +!sycl_item_base_1_1 = !sycl.item_base<[1, false], (!sycl_range_1_, !sycl_id_1_)> +!sycl_item_1_ = !sycl.item<[1, true], (!sycl_item_base_1_)> +!sycl_item_1_1_ = !sycl.item<[1, false], (!sycl_item_base_1_1)> +!sycl_group_1_ = !sycl.group<[1], (!sycl_range_1_, !sycl_range_1_, !sycl_range_1_, !sycl_id_1_)> +!sycl_nd_item_1_ = !sycl.nd_item<[1], (!sycl_item_1_, !sycl_item_1_1_, !sycl_group_1_)> + +// CHECK-LABEL: llvm.func @test( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[NDITEM1]]>, +// CHECK-SAME: %[[VAL_1:.*]]: i32) -> i64 { +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0, 0, 0, 0, %[[VAL_1]]] : (!llvm.ptr<[[NDITEM1]]>, i32) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.load %[[VAL_2]] : !llvm.ptr +// CHECK-NEXT: llvm.return %[[VAL_3]] : i64 +// CHECK-NEXT: } +func.func @test(%nd: memref, %i: i32) -> i64 { + %0 = sycl.nd_item.get_local_range(%nd, %i) { ArgumentTypes = [memref, i32], FunctionName = @"get_local_range", MangledFunctionName = @"get_local_range", TypeName = @"nd_item" } : (memref, i32) -> i64 + return %0 : i64 +} + +// ----- + +!sycl_id_1_ = !sycl.id<[1], (!sycl.array<[1], (memref<1xi64>)>)> +!sycl_range_1_ = !sycl.range<[1], (!sycl.array<[1], (memref<1xi64>)>)> +!sycl_item_base_1_ = !sycl.item_base<[1, true], (!sycl_range_1_, !sycl_id_1_, !sycl_id_1_)> +!sycl_item_base_1_1 = !sycl.item_base<[1, false], (!sycl_range_1_, !sycl_id_1_)> +!sycl_item_1_ = !sycl.item<[1, true], (!sycl_item_base_1_)> +!sycl_item_1_1_ = !sycl.item<[1, false], (!sycl_item_base_1_1)> +!sycl_group_1_ = !sycl.group<[1], (!sycl_range_1_, !sycl_range_1_, !sycl_range_1_, !sycl_id_1_)> +!sycl_nd_item_1_ = !sycl.nd_item<[1], (!sycl_item_1_, !sycl_item_1_1_, !sycl_group_1_)> +!sycl_nd_range_1_ = !sycl.nd_range<[1], (!sycl_range_1_, !sycl_range_1_, !sycl_id_1_)> + +// CHECK-LABEL: llvm.func @test( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[NDITEM1]]>) -> !llvm.[[NDRANGE1]] { +// CHECK-NEXT: %[[VAL_1:.*]] = llvm.mlir.constant(1 : i32) : i32 +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.alloca %[[VAL_1]] x !llvm.[[NDRANGE1]] : (i32) -> !llvm.ptr<[[NDRANGE1]]> +// CHECK-DAG: %[[VAL_3:.*]] = llvm.getelementptr inbounds %[[VAL_2]][0, 0] : (!llvm.ptr<[[NDRANGE1]]>) -> !llvm.ptr<[[RANGE1]]> +// CHECK-DAG: %[[VAL_4:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 0] : (!llvm.ptr<[[NDITEM1]]>) -> !llvm.ptr<[[RANGE1]]> +// CHECK-DAG: %[[VAL_5:.*]] = llvm.load %[[VAL_4]] : !llvm.ptr<[[RANGE1]]> +// CHECK-NEXT: llvm.store %[[VAL_5]], %[[VAL_3]] : !llvm.ptr<[[RANGE1]]> +// CHECK-DAG: %[[VAL_6:.*]] = llvm.getelementptr inbounds %[[VAL_2]][0, 1] : (!llvm.ptr<[[NDRANGE1]]>) -> !llvm.ptr<[[RANGE1]]> +// CHECK-DAG: %[[VAL_7:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0, 0] : (!llvm.ptr<[[NDITEM1]]>) -> !llvm.ptr<[[RANGE1]]> +// CHECK-DAG: %[[VAL_8:.*]] = llvm.load %[[VAL_7]] : !llvm.ptr<[[RANGE1]]> +// CHECK-NEXT: llvm.store %[[VAL_8]], %[[VAL_6]] : !llvm.ptr<[[RANGE1]]> +// CHECK-DAG: %[[VAL_9:.*]] = llvm.getelementptr inbounds %[[VAL_2]][0, 2] : (!llvm.ptr<[[NDRANGE1]]>) -> !llvm.ptr<[[ID1]]> +// CHECK-DAG: %[[VAL_10:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 2] : (!llvm.ptr<[[NDITEM1]]>) -> !llvm.ptr<[[ID1]]> +// CHECK-DAG: %[[VAL_11:.*]] = llvm.load %[[VAL_10]] : !llvm.ptr<[[ID1]]> +// CHECK-NEXT: llvm.store %[[VAL_11]], %[[VAL_9]] : !llvm.ptr<[[ID1]]> +// CHECK-NEXT: %[[VAL_12:.*]] = llvm.load %[[VAL_2]] : !llvm.ptr<[[NDRANGE1]]> +// CHECK-NEXT: llvm.return %[[VAL_12]] : !llvm.[[NDRANGE1]] +// CHECK-NEXT: } +func.func @test(%nd: memref) -> !sycl_nd_range_1_ { + %0 = sycl.nd_item.get_nd_range(%nd) { ArgumentTypes = [memref], FunctionName = @"get_nd_range", MangledFunctionName = @"get_nd_range", TypeName = @"nd_item" } : (memref) -> !sycl_nd_range_1_ + return %0 : !sycl_nd_range_1_ +} + +// ----- + +!sycl_id_1_ = !sycl.id<[1], (!sycl.array<[1], (memref<1xi64>)>)> +!sycl_range_1_ = !sycl.range<[1], (!sycl.array<[1], (memref<1xi64>)>)> +!sycl_group_1_ = !sycl.group<[1], (!sycl_range_1_, !sycl_range_1_, !sycl_range_1_, !sycl_id_1_)> + +// CHECK-LABEL: llvm.func @test( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[GROUP1]]>) -> !llvm.[[ID1]] { +// CHECK-NEXT: %[[VAL_1:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 3] : (!llvm.ptr<[[GROUP1]]>) -> !llvm.ptr<[[ID1]]> +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] : !llvm.ptr<[[ID1]]> +// CHECK-NEXT: llvm.return %[[VAL_2]] : !llvm.[[ID1]] +// CHECK-NEXT: } +func.func @test(%group: memref) -> !sycl_id_1_ { + %0 = sycl.group.get_group_id(%group) { ArgumentTypes = [memref], FunctionName = @"get_group_id", MangledFunctionName = @"get_group_id", TypeName = @"group" } : (memref) -> !sycl_id_1_ + return %0 : !sycl_id_1_ +} + +// ----- + +!sycl_id_1_ = !sycl.id<[1], (!sycl.array<[1], (memref<1xi64>)>)> +!sycl_range_1_ = !sycl.range<[1], (!sycl.array<[1], (memref<1xi64>)>)> +!sycl_group_1_ = !sycl.group<[1], (!sycl_range_1_, !sycl_range_1_, !sycl_range_1_, !sycl_id_1_)> + +// CHECK-LABEL: llvm.func @test( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[GROUP1]]>, +// CHECK-SAME: %[[VAL_1:.*]]: i32) -> i64 { +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 3, 0, 0, %[[VAL_1]]] : (!llvm.ptr<[[GROUP1]]>, i32) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.load %[[VAL_2]] : !llvm.ptr +// CHECK-NEXT: llvm.return %[[VAL_3]] : i64 +// CHECK-NEXT: } +func.func @test(%group: memref, %i: i32) -> i64 { + %0 = sycl.group.get_group_id(%group, %i) { ArgumentTypes = [memref, i32], FunctionName = @"get_group_id", MangledFunctionName = @"get_group_id", TypeName = @"group" } : (memref, i32) -> i64 + return %0 : i64 +} + +// ----- + +!sycl_id_3_ = !sycl.id<[3], (!sycl.array<[3], (memref<3xi64>)>)> +!sycl_range_3_ = !sycl.range<[3], (!sycl.array<[3], (memref<3xi64>)>)> +!sycl_group_3_ = !sycl.group<[3], (!sycl_range_3_, !sycl_range_3_, !sycl_range_3_, !sycl_id_3_)> + +module attributes {gpu.container} { + gpu.module @kernels { +// CHECK-LABEL: llvm.func @test( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[GROUP3:.*]]>) -> !llvm.[[ID3:.*]] { +// CHECK: %[[VAL_1:.*]] = llvm.mlir.addressof @__spirv_BuiltInLocalInvocationId : !llvm.ptr> +// CHECK: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] : !llvm.ptr> +// CHECK: %[[VAL_3:.*]] = llvm.mlir.null : !llvm.ptr<[[ID3]]> +// CHECK: %[[VAL_4:.*]] = llvm.mlir.constant(1 : index) : i64 +// CHECK: %[[VAL_5:.*]] = llvm.getelementptr %[[VAL_3]]{{\[}}%[[VAL_4]]] : (!llvm.ptr<[[ID3]]>, i64) -> !llvm.ptr<[[ID3]]> +// CHECK: %[[VAL_6:.*]] = llvm.ptrtoint %[[VAL_5]] : !llvm.ptr<[[ID3]]> to i64 +// CHECK: %[[VAL_7:.*]] = llvm.alloca %[[VAL_6]] x !llvm.[[ID3]] : (i64) -> !llvm.ptr<[[ID3]]> +// CHECK-DAG: %[[VAL_8:.*]] = llvm.mlir.constant(0 : index) : i64 +// CHECK-DAG: %[[VAL_9:.*]] = llvm.mlir.constant(0 : i32) : i32 +// CHECK-DAG: %[[VAL_10:.*]] = llvm.mlir.constant(0 : i32) : i32 +// CHECK: %[[VAL_11:.*]] = llvm.extractelement %[[VAL_2]]{{\[}}%[[VAL_10]] : i32] : vector<3xi64> +// CHECK: %[[VAL_12:.*]] = llvm.getelementptr inbounds %[[VAL_7]][0, 0, 0, %[[VAL_9]]] : (!llvm.ptr<[[ID3]]>, i32) -> !llvm.ptr +// CHECK: %[[VAL_13:.*]] = llvm.getelementptr %[[VAL_12]]{{\[}}%[[VAL_8]]] : (!llvm.ptr, i64) -> !llvm.ptr +// CHECK: llvm.store %[[VAL_11]], %[[VAL_13]] : !llvm.ptr +// CHECK-DAG: %[[VAL_14:.*]] = llvm.mlir.constant(1 : i32) : i32 +// CHECK-DAG: %[[VAL_15:.*]] = llvm.mlir.constant(1 : i32) : i32 +// CHECK: %[[VAL_16:.*]] = llvm.extractelement %[[VAL_2]]{{\[}}%[[VAL_15]] : i32] : vector<3xi64> +// CHECK: %[[VAL_17:.*]] = llvm.getelementptr inbounds %[[VAL_7]][0, 0, 0, %[[VAL_14]]] : (!llvm.ptr<[[ID3]]>, i32) -> !llvm.ptr +// CHECK: %[[VAL_18:.*]] = llvm.getelementptr %[[VAL_17]]{{\[}}%[[VAL_8]]] : (!llvm.ptr, i64) -> !llvm.ptr +// CHECK: llvm.store %[[VAL_16]], %[[VAL_18]] : !llvm.ptr +// CHECK-DAG: %[[VAL_19:.*]] = llvm.mlir.constant(2 : i32) : i32 +// CHECK-DAG: %[[VAL_20:.*]] = llvm.mlir.constant(2 : i32) : i32 +// CHECK: %[[VAL_21:.*]] = llvm.extractelement %[[VAL_2]]{{\[}}%[[VAL_20]] : i32] : vector<3xi64> +// CHECK: %[[VAL_22:.*]] = llvm.getelementptr inbounds %[[VAL_7]][0, 0, 0, %[[VAL_19]]] : (!llvm.ptr<[[ID3]]>, i32) -> !llvm.ptr +// CHECK: %[[VAL_23:.*]] = llvm.getelementptr %[[VAL_22]]{{\[}}%[[VAL_8]]] : (!llvm.ptr, i64) -> !llvm.ptr +// CHECK: llvm.store %[[VAL_21]], %[[VAL_23]] : !llvm.ptr +// CHECK: %[[VAL_24:.*]] = llvm.getelementptr %[[VAL_7]]{{\[}}%[[VAL_8]]] : (!llvm.ptr<[[ID3]]>, i64) -> !llvm.ptr<[[ID3]]> +// CHECK: %[[VAL_25:.*]] = llvm.load %[[VAL_24]] : !llvm.ptr<[[ID3]]> +// CHECK: llvm.return %[[VAL_25]] : !llvm.[[ID3]] +// CHECK-NEXT: } + func.func @test(%group: memref) -> !sycl_id_3_ { + %0 = sycl.group.get_local_id(%group) { ArgumentTypes = [memref], FunctionName = @"get_local_id", MangledFunctionName = @"get_local_id", TypeName = @"group" } : (memref) -> !sycl_id_3_ + return %0 : !sycl_id_3_ + } + } +} + +// ----- + +!sycl_id_1_ = !sycl.id<[1], (!sycl.array<[1], (memref<1xi64>)>)> +!sycl_range_1_ = !sycl.range<[1], (!sycl.array<[1], (memref<1xi64>)>)> +!sycl_group_1_ = !sycl.group<[1], (!sycl_range_1_, !sycl_range_1_, !sycl_range_1_, !sycl_id_1_)> + + +module attributes {gpu.container} { + gpu.module @kernels { +// CHECK-LABEL: llvm.func @test( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[GROUP1]]>, +// CHECK-SAME: %[[VAL_1:.*]]: i32) -> i64 { +// CHECK: %[[VAL_2:.*]] = llvm.mlir.addressof @__spirv_BuiltInLocalInvocationId : !llvm.ptr> +// CHECK: %[[VAL_3:.*]] = llvm.load %[[VAL_2]] : !llvm.ptr> +// CHECK-DAG: %[[VAL_4:.*]] = llvm.mlir.constant(dense<0> : vector<3xindex>) : vector<3xi64> +// CHECK-DAG: %[[VAL_5:.*]] = llvm.mlir.constant(0 : i32) : i32 +// CHECK: %[[VAL_6:.*]] = llvm.extractelement %[[VAL_3]]{{\[}}%[[VAL_5]] : i32] : vector<3xi64> +// CHECK: %[[VAL_7:.*]] = llvm.mlir.constant(0 : i64) : i64 +// CHECK: %[[VAL_8:.*]] = llvm.insertelement %[[VAL_6]], %[[VAL_4]]{{\[}}%[[VAL_7]] : i64] : vector<3xi64> +// CHECK: %[[VAL_9:.*]] = llvm.mlir.constant(1 : i32) : i32 +// CHECK: %[[VAL_10:.*]] = llvm.extractelement %[[VAL_3]]{{\[}}%[[VAL_9]] : i32] : vector<3xi64> +// CHECK: %[[VAL_11:.*]] = llvm.mlir.constant(1 : i64) : i64 +// CHECK: %[[VAL_12:.*]] = llvm.insertelement %[[VAL_10]], %[[VAL_8]]{{\[}}%[[VAL_11]] : i64] : vector<3xi64> +// CHECK: %[[VAL_13:.*]] = llvm.mlir.constant(2 : i32) : i32 +// CHECK: %[[VAL_14:.*]] = llvm.extractelement %[[VAL_3]]{{\[}}%[[VAL_13]] : i32] : vector<3xi64> +// CHECK: %[[VAL_15:.*]] = llvm.mlir.constant(2 : i64) : i64 +// CHECK: %[[VAL_16:.*]] = llvm.insertelement %[[VAL_14]], %[[VAL_12]]{{\[}}%[[VAL_15]] : i64] : vector<3xi64> +// CHECK: %[[VAL_17:.*]] = llvm.extractelement %[[VAL_16]]{{\[}}%[[VAL_1]] : i32] : vector<3xi64> +// CHECK: llvm.return %[[VAL_17]] : i64 +// CHECK-NEXT: } + func.func @test(%group: memref, %i: i32) -> i64 { + %0 = sycl.group.get_local_id(%group, %i) { ArgumentTypes = [memref, i32], FunctionName = @"get_local_id", MangledFunctionName = @"get_local_id", TypeName = @"group" } : (memref, i32) -> i64 + return %0 : i64 + } + } +} + +// ----- + +!sycl_id_3_ = !sycl.id<[3], (!sycl.array<[3], (memref<3xi64>)>)> +!sycl_range_3_ = !sycl.range<[3], (!sycl.array<[3], (memref<3xi64>)>)> +!sycl_group_3_ = !sycl.group<[3], (!sycl_range_3_, !sycl_range_3_, !sycl_range_3_, !sycl_id_3_)> + +// CHECK-LABEL: llvm.func @test( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[GROUP3]]>) -> !llvm.[[RANGE3]] { +// CHECK-NEXT: %[[VAL_1:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1] : (!llvm.ptr<[[GROUP3]]>) -> !llvm.ptr<[[RANGE3]]> +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] : !llvm.ptr<[[RANGE3]]> +// CHECK-NEXT: llvm.return %[[VAL_2]] : !llvm.[[RANGE3]] +// CHECK-NEXT: } +func.func @test(%group: memref) -> !sycl_range_3_ { + %0 = sycl.group.get_local_range(%group) { ArgumentTypes = [memref], FunctionName = @"get_local_range", MangledFunctionName = @"get_local_range", TypeName = @"group" } : (memref) -> !sycl_range_3_ + return %0 : !sycl_range_3_ +} + +// ----- + +!sycl_id_1_ = !sycl.id<[1], (!sycl.array<[1], (memref<1xi64>)>)> +!sycl_range_1_ = !sycl.range<[1], (!sycl.array<[1], (memref<1xi64>)>)> +!sycl_group_1_ = !sycl.group<[1], (!sycl_range_1_, !sycl_range_1_, !sycl_range_1_, !sycl_id_1_)> + +// CHECK-LABEL: llvm.func @test( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[GROUP1]]>, +// CHECK-SAME: %[[VAL_1:.*]]: i32) -> i64 { +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0, 0, %[[VAL_1]]] : (!llvm.ptr<[[GROUP1]]>, i32) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.load %[[VAL_2]] : !llvm.ptr +// CHECK-NEXT: llvm.return %[[VAL_3]] : i64 +// CHECK-NEXT: } +func.func @test(%group: memref, %i: i32) -> i64 { + %0 = sycl.group.get_local_range(%group, %i) { ArgumentTypes = [memref, i32], FunctionName = @"get_local_range", MangledFunctionName = @"get_local_range", TypeName = @"group" } : (memref, i32) -> i64 + return %0 : i64 +} + +// ----- + +!sycl_id_3_ = !sycl.id<[3], (!sycl.array<[3], (memref<3xi64>)>)> +!sycl_range_3_ = !sycl.range<[3], (!sycl.array<[3], (memref<3xi64>)>)> +!sycl_group_3_ = !sycl.group<[3], (!sycl_range_3_, !sycl_range_3_, !sycl_range_3_, !sycl_id_3_)> + +// CHECK-LABEL: llvm.func @test( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[GROUP3]]>) -> !llvm.[[RANGE3]] { +// CHECK-NEXT: %[[VAL_1:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1] : (!llvm.ptr<[[GROUP3]]>) -> !llvm.ptr<[[RANGE3]]> +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] : !llvm.ptr<[[RANGE3]]> +// CHECK-NEXT: llvm.return %[[VAL_2]] : !llvm.[[RANGE3]] +// CHECK-NEXT: } +func.func @test(%group: memref) -> !sycl_range_3_ { + %0 = sycl.group.get_max_local_range(%group) { ArgumentTypes = [memref], FunctionName = @"get_max_local_range", MangledFunctionName = @"get_max_local_range", TypeName = @"group" } : (memref) -> !sycl_range_3_ + return %0 : !sycl_range_3_ +} + +// ----- + +!sycl_id_1_ = !sycl.id<[1], (!sycl.array<[1], (memref<1xi64>)>)> +!sycl_range_1_ = !sycl.range<[1], (!sycl.array<[1], (memref<1xi64>)>)> +!sycl_group_1_ = !sycl.group<[1], (!sycl_range_1_, !sycl_range_1_, !sycl_range_1_, !sycl_id_1_)> +!sycl_id_2_ = !sycl.id<[2], (!sycl.array<[2], (memref<2xi64>)>)> +!sycl_range_2_ = !sycl.range<[2], (!sycl.array<[2], (memref<2xi64>)>)> +!sycl_group_2_ = !sycl.group<[2], (!sycl_range_2_, !sycl_range_2_, !sycl_range_2_, !sycl_id_2_)> +!sycl_id_3_ = !sycl.id<[3], (!sycl.array<[3], (memref<3xi64>)>)> +!sycl_range_3_ = !sycl.range<[3], (!sycl.array<[3], (memref<3xi64>)>)> +!sycl_group_3_ = !sycl.group<[3], (!sycl_range_3_, !sycl_range_3_, !sycl_range_3_, !sycl_id_3_)> + +// CHECK-LABEL: llvm.func @test_1( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[GROUP1]]>) -> i64 { +// CHECK-NEXT: %[[VAL_1:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 3, 0, 0, 0] : (!llvm.ptr<[[GROUP1]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] : !llvm.ptr +// CHECK-NEXT: llvm.return %[[VAL_2]] : i64 +// CHECK-NEXT: } +func.func @test_1(%group: memref) -> i64 { + %0 = sycl.group.get_group_linear_id(%group) { ArgumentTypes = [memref], FunctionName = @"get_group_linear_id", MangledFunctionName = @"get_group_linear_id", TypeName = @"group" } : (memref) -> i64 + return %0 : i64 +} + +// CHECK-LABEL: llvm.func @test_2( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[GROUP2:.*]]>) -> i64 { +// CHECK-NEXT: %[[VAL_1:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 3, 0, 0, 0] : (!llvm.ptr<[[GROUP2]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 2, 0, 0, 1] : (!llvm.ptr<[[GROUP2]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_4:.*]] = llvm.load %[[VAL_3]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_5:.*]] = llvm.mul %[[VAL_2]], %[[VAL_4]] : i64 +// CHECK-NEXT: %[[VAL_6:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 3, 0, 0, 1] : (!llvm.ptr<[[GROUP2]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_7:.*]] = llvm.load %[[VAL_6]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_8:.*]] = llvm.add %[[VAL_5]], %[[VAL_7]] : i64 +// CHECK-NEXT: llvm.return %[[VAL_8]] : i64 +// CHECK-NEXT: } +func.func @test_2(%group: memref) -> i64 { + %0 = sycl.group.get_group_linear_id(%group) { ArgumentTypes = [memref], FunctionName = @"get_group_linear_id", MangledFunctionName = @"get_group_linear_id", TypeName = @"group" } : (memref) -> i64 + return %0 : i64 +} + +// CHECK-LABEL: llvm.func @test_3( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[GROUP3]]>) -> i64 { +// CHECK-NEXT: %[[VAL_1:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 3, 0, 0, 0] : (!llvm.ptr<[[GROUP3]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 2, 0, 0, 1] : (!llvm.ptr<[[GROUP3]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_4:.*]] = llvm.load %[[VAL_3]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_5:.*]] = llvm.mul %[[VAL_2]], %[[VAL_4]] : i64 +// CHECK-NEXT: %[[VAL_6:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 2, 0, 0, 2] : (!llvm.ptr<[[GROUP3]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_7:.*]] = llvm.load %[[VAL_6]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_8:.*]] = llvm.mul %[[VAL_5]], %[[VAL_7]] : i64 +// CHECK-NEXT: %[[VAL_9:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 3, 0, 0, 1] : (!llvm.ptr<[[GROUP3]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_10:.*]] = llvm.load %[[VAL_9]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_11:.*]] = llvm.mul %[[VAL_10]], %[[VAL_7]] : i64 +// CHECK-NEXT: %[[VAL_12:.*]] = llvm.add %[[VAL_8]], %[[VAL_11]] : i64 +// CHECK-NEXT: %[[VAL_13:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 3, 0, 0, 2] : (!llvm.ptr<[[GROUP3]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_14:.*]] = llvm.load %[[VAL_13]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_15:.*]] = llvm.add %[[VAL_12]], %[[VAL_14]] : i64 +// CHECK-NEXT: llvm.return %[[VAL_15]] : i64 +// CHECK-NEXT: } +func.func @test_3(%group: memref) -> i64 { + %0 = sycl.group.get_group_linear_id(%group) { ArgumentTypes = [memref], FunctionName = @"get_group_linear_id", MangledFunctionName = @"get_group_linear_id", TypeName = @"group" } : (memref) -> i64 + return %0 : i64 +} + +// ----- + +!sycl_id_1_ = !sycl.id<[1], (!sycl.array<[1], (memref<1xi64>)>)> +!sycl_range_1_ = !sycl.range<[1], (!sycl.array<[1], (memref<1xi64>)>)> +!sycl_group_1_ = !sycl.group<[1], (!sycl_range_1_, !sycl_range_1_, !sycl_range_1_, !sycl_id_1_)> +!sycl_id_2_ = !sycl.id<[2], (!sycl.array<[2], (memref<2xi64>)>)> +!sycl_range_2_ = !sycl.range<[2], (!sycl.array<[2], (memref<2xi64>)>)> +!sycl_group_2_ = !sycl.group<[2], (!sycl_range_2_, !sycl_range_2_, !sycl_range_2_, !sycl_id_2_)> +!sycl_id_3_ = !sycl.id<[3], (!sycl.array<[3], (memref<3xi64>)>)> +!sycl_range_3_ = !sycl.range<[3], (!sycl.array<[3], (memref<3xi64>)>)> +!sycl_group_3_ = !sycl.group<[3], (!sycl_range_3_, !sycl_range_3_, !sycl_range_3_, !sycl_id_3_)> + +module attributes {gpu.container} { + gpu.module @kernels { +// CHECK-LABEL: llvm.func @test_1( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[GROUP1]]>) -> i64 { +// CHECK: %[[VAL_1:.*]] = llvm.mlir.constant(0 : i32) : i32 +// CHECK: %[[VAL_2:.*]] = llvm.mlir.addressof @__spirv_BuiltInLocalInvocationId : !llvm.ptr> +// CHECK: %[[VAL_3:.*]] = llvm.load %[[VAL_2]] : !llvm.ptr> +// CHECK-DAG: %[[VAL_4:.*]] = llvm.mlir.constant(dense<0> : vector<3xindex>) : vector<3xi64> +// CHECK-DAG: %[[VAL_5:.*]] = llvm.mlir.constant(0 : i32) : i32 +// CHECK: %[[VAL_6:.*]] = llvm.extractelement %[[VAL_3]]{{\[}}%[[VAL_5]] : i32] : vector<3xi64> +// CHECK: %[[VAL_7:.*]] = llvm.mlir.constant(0 : i64) : i64 +// CHECK: %[[VAL_8:.*]] = llvm.insertelement %[[VAL_6]], %[[VAL_4]]{{\[}}%[[VAL_7]] : i64] : vector<3xi64> +// CHECK: %[[VAL_9:.*]] = llvm.mlir.constant(1 : i32) : i32 +// CHECK: %[[VAL_10:.*]] = llvm.extractelement %[[VAL_3]]{{\[}}%[[VAL_9]] : i32] : vector<3xi64> +// CHECK: %[[VAL_11:.*]] = llvm.mlir.constant(1 : i64) : i64 +// CHECK: %[[VAL_12:.*]] = llvm.insertelement %[[VAL_10]], %[[VAL_8]]{{\[}}%[[VAL_11]] : i64] : vector<3xi64> +// CHECK: %[[VAL_13:.*]] = llvm.mlir.constant(2 : i32) : i32 +// CHECK: %[[VAL_14:.*]] = llvm.extractelement %[[VAL_3]]{{\[}}%[[VAL_13]] : i32] : vector<3xi64> +// CHECK: %[[VAL_15:.*]] = llvm.mlir.constant(2 : i64) : i64 +// CHECK: %[[VAL_16:.*]] = llvm.insertelement %[[VAL_14]], %[[VAL_12]]{{\[}}%[[VAL_15]] : i64] : vector<3xi64> +// CHECK: %[[VAL_17:.*]] = llvm.extractelement %[[VAL_16]]{{\[}}%[[VAL_1]] : i32] : vector<3xi64> +// CHECK: llvm.return %[[VAL_17]] : i64 +// CHECK-NEXT: } + func.func @test_1(%group: memref) -> i64 { + %0 = sycl.group.get_local_linear_id(%group) { ArgumentTypes = [memref], FunctionName = @"get_local_linear_id", MangledFunctionName = @"get_local_linear_id", TypeName = @"group" } : (memref) -> i64 + return %0 : i64 + } + +// CHECK-LABEL: llvm.func @test_2( +// CHECK-SAME: %[[VAL_18:.*]]: !llvm.ptr<[[GROUP2]]>) -> i64 { +// CHECK: %[[VAL_19:.*]] = llvm.mlir.constant(0 : i32) : i32 +// CHECK: %[[VAL_20:.*]] = llvm.mlir.addressof @__spirv_BuiltInLocalInvocationId : !llvm.ptr> +// CHECK: %[[VAL_21:.*]] = llvm.load %[[VAL_20]] : !llvm.ptr> +// CHECK-DAG: %[[VAL_22:.*]] = llvm.mlir.constant(dense<0> : vector<3xindex>) : vector<3xi64> +// CHECK-DAG: %[[VAL_23:.*]] = llvm.mlir.constant(0 : i32) : i32 +// CHECK: %[[VAL_24:.*]] = llvm.extractelement %[[VAL_21]]{{\[}}%[[VAL_23]] : i32] : vector<3xi64> +// CHECK: %[[VAL_25:.*]] = llvm.mlir.constant(0 : i64) : i64 +// CHECK: %[[VAL_26:.*]] = llvm.insertelement %[[VAL_24]], %[[VAL_22]]{{\[}}%[[VAL_25]] : i64] : vector<3xi64> +// CHECK: %[[VAL_27:.*]] = llvm.mlir.constant(1 : i32) : i32 +// CHECK: %[[VAL_28:.*]] = llvm.extractelement %[[VAL_21]]{{\[}}%[[VAL_27]] : i32] : vector<3xi64> +// CHECK: %[[VAL_29:.*]] = llvm.mlir.constant(1 : i64) : i64 +// CHECK: %[[VAL_30:.*]] = llvm.insertelement %[[VAL_28]], %[[VAL_26]]{{\[}}%[[VAL_29]] : i64] : vector<3xi64> +// CHECK: %[[VAL_31:.*]] = llvm.mlir.constant(2 : i32) : i32 +// CHECK: %[[VAL_32:.*]] = llvm.extractelement %[[VAL_21]]{{\[}}%[[VAL_31]] : i32] : vector<3xi64> +// CHECK: %[[VAL_33:.*]] = llvm.mlir.constant(2 : i64) : i64 +// CHECK: %[[VAL_34:.*]] = llvm.insertelement %[[VAL_32]], %[[VAL_30]]{{\[}}%[[VAL_33]] : i64] : vector<3xi64> +// CHECK: %[[VAL_35:.*]] = llvm.extractelement %[[VAL_34]]{{\[}}%[[VAL_19]] : i32] : vector<3xi64> +// CHECK: %[[VAL_36:.*]] = llvm.getelementptr inbounds %[[VAL_18]][0, 2, 0, 0, 1] : (!llvm.ptr<[[GROUP2]]>) -> !llvm.ptr +// CHECK: %[[VAL_37:.*]] = llvm.load %[[VAL_36]] : !llvm.ptr +// CHECK: %[[VAL_38:.*]] = llvm.mul %[[VAL_35]], %[[VAL_37]] : i64 +// CHECK: %[[VAL_39:.*]] = llvm.mlir.constant(1 : i32) : i32 +// CHECK: %[[VAL_40:.*]] = llvm.mlir.addressof @__spirv_BuiltInLocalInvocationId : !llvm.ptr> +// CHECK: %[[VAL_41:.*]] = llvm.load %[[VAL_40]] : !llvm.ptr> +// CHECK-DAG: %[[VAL_42:.*]] = llvm.mlir.constant(dense<0> : vector<3xindex>) : vector<3xi64> +// CHECK-DAG: %[[VAL_43:.*]] = llvm.mlir.constant(0 : i32) : i32 +// CHECK: %[[VAL_44:.*]] = llvm.extractelement %[[VAL_41]]{{\[}}%[[VAL_43]] : i32] : vector<3xi64> +// CHECK: %[[VAL_45:.*]] = llvm.mlir.constant(0 : i64) : i64 +// CHECK: %[[VAL_46:.*]] = llvm.insertelement %[[VAL_44]], %[[VAL_42]]{{\[}}%[[VAL_45]] : i64] : vector<3xi64> +// CHECK: %[[VAL_47:.*]] = llvm.mlir.constant(1 : i32) : i32 +// CHECK: %[[VAL_48:.*]] = llvm.extractelement %[[VAL_41]]{{\[}}%[[VAL_47]] : i32] : vector<3xi64> +// CHECK: %[[VAL_49:.*]] = llvm.mlir.constant(1 : i64) : i64 +// CHECK: %[[VAL_50:.*]] = llvm.insertelement %[[VAL_48]], %[[VAL_46]]{{\[}}%[[VAL_49]] : i64] : vector<3xi64> +// CHECK: %[[VAL_51:.*]] = llvm.mlir.constant(2 : i32) : i32 +// CHECK: %[[VAL_52:.*]] = llvm.extractelement %[[VAL_41]]{{\[}}%[[VAL_51]] : i32] : vector<3xi64> +// CHECK: %[[VAL_53:.*]] = llvm.mlir.constant(2 : i64) : i64 +// CHECK: %[[VAL_54:.*]] = llvm.insertelement %[[VAL_52]], %[[VAL_50]]{{\[}}%[[VAL_53]] : i64] : vector<3xi64> +// CHECK: %[[VAL_55:.*]] = llvm.extractelement %[[VAL_54]]{{\[}}%[[VAL_39]] : i32] : vector<3xi64> +// CHECK: %[[VAL_56:.*]] = llvm.add %[[VAL_38]], %[[VAL_55]] : i64 +// CHECK: llvm.return %[[VAL_56]] : i64 +// CHECK-NEXT: } + func.func @test_2(%group: memref) -> i64 { + %0 = sycl.group.get_local_linear_id(%group) { ArgumentTypes = [memref], FunctionName = @"get_local_linear_id", MangledFunctionName = @"get_local_linear_id", TypeName = @"group" } : (memref) -> i64 + return %0 : i64 + } + +// CHECK-LABEL: llvm.func @test_3( +// CHECK-SAME: %[[VAL_57:.*]]: !llvm.ptr<[[GROUP3]]>) -> i64 { +// CHECK: %[[VAL_58:.*]] = llvm.mlir.constant(0 : i32) : i32 +// CHECK: %[[VAL_59:.*]] = llvm.mlir.addressof @__spirv_BuiltInLocalInvocationId : !llvm.ptr> +// CHECK: %[[VAL_60:.*]] = llvm.load %[[VAL_59]] : !llvm.ptr> +// CHECK-DAG: %[[VAL_61:.*]] = llvm.mlir.constant(dense<0> : vector<3xindex>) : vector<3xi64> +// CHECK-DAG: %[[VAL_62:.*]] = llvm.mlir.constant(0 : i32) : i32 +// CHECK: %[[VAL_63:.*]] = llvm.extractelement %[[VAL_60]]{{\[}}%[[VAL_62]] : i32] : vector<3xi64> +// CHECK: %[[VAL_64:.*]] = llvm.mlir.constant(0 : i64) : i64 +// CHECK: %[[VAL_65:.*]] = llvm.insertelement %[[VAL_63]], %[[VAL_61]]{{\[}}%[[VAL_64]] : i64] : vector<3xi64> +// CHECK: %[[VAL_66:.*]] = llvm.mlir.constant(1 : i32) : i32 +// CHECK: %[[VAL_67:.*]] = llvm.extractelement %[[VAL_60]]{{\[}}%[[VAL_66]] : i32] : vector<3xi64> +// CHECK: %[[VAL_68:.*]] = llvm.mlir.constant(1 : i64) : i64 +// CHECK: %[[VAL_69:.*]] = llvm.insertelement %[[VAL_67]], %[[VAL_65]]{{\[}}%[[VAL_68]] : i64] : vector<3xi64> +// CHECK: %[[VAL_70:.*]] = llvm.mlir.constant(2 : i32) : i32 +// CHECK: %[[VAL_71:.*]] = llvm.extractelement %[[VAL_60]]{{\[}}%[[VAL_70]] : i32] : vector<3xi64> +// CHECK: %[[VAL_72:.*]] = llvm.mlir.constant(2 : i64) : i64 +// CHECK: %[[VAL_73:.*]] = llvm.insertelement %[[VAL_71]], %[[VAL_69]]{{\[}}%[[VAL_72]] : i64] : vector<3xi64> +// CHECK: %[[VAL_74:.*]] = llvm.extractelement %[[VAL_73]]{{\[}}%[[VAL_58]] : i32] : vector<3xi64> +// CHECK: %[[VAL_75:.*]] = llvm.getelementptr inbounds %[[VAL_57]][0, 2, 0, 0, 1] : (!llvm.ptr<[[GROUP3]]>) -> !llvm.ptr +// CHECK: %[[VAL_76:.*]] = llvm.load %[[VAL_75]] : !llvm.ptr +// CHECK: %[[VAL_77:.*]] = llvm.mul %[[VAL_74]], %[[VAL_76]] : i64 +// CHECK: %[[VAL_78:.*]] = llvm.getelementptr inbounds %[[VAL_57]][0, 2, 0, 0, 2] : (!llvm.ptr<[[GROUP3]]>) -> !llvm.ptr +// CHECK: %[[VAL_79:.*]] = llvm.load %[[VAL_78]] : !llvm.ptr +// CHECK: %[[VAL_80:.*]] = llvm.mul %[[VAL_77]], %[[VAL_79]] : i64 +// CHECK: %[[VAL_81:.*]] = llvm.mlir.constant(1 : i32) : i32 +// CHECK: %[[VAL_82:.*]] = llvm.mlir.addressof @__spirv_BuiltInLocalInvocationId : !llvm.ptr> +// CHECK: %[[VAL_83:.*]] = llvm.load %[[VAL_82]] : !llvm.ptr> +// CHECK-DAG: %[[VAL_84:.*]] = llvm.mlir.constant(dense<0> : vector<3xindex>) : vector<3xi64> +// CHECK-DAG: %[[VAL_85:.*]] = llvm.mlir.constant(0 : i32) : i32 +// CHECK: %[[VAL_86:.*]] = llvm.extractelement %[[VAL_83]]{{\[}}%[[VAL_85]] : i32] : vector<3xi64> +// CHECK: %[[VAL_87:.*]] = llvm.mlir.constant(0 : i64) : i64 +// CHECK: %[[VAL_88:.*]] = llvm.insertelement %[[VAL_86]], %[[VAL_84]]{{\[}}%[[VAL_87]] : i64] : vector<3xi64> +// CHECK: %[[VAL_89:.*]] = llvm.mlir.constant(1 : i32) : i32 +// CHECK: %[[VAL_90:.*]] = llvm.extractelement %[[VAL_83]]{{\[}}%[[VAL_89]] : i32] : vector<3xi64> +// CHECK: %[[VAL_91:.*]] = llvm.mlir.constant(1 : i64) : i64 +// CHECK: %[[VAL_92:.*]] = llvm.insertelement %[[VAL_90]], %[[VAL_88]]{{\[}}%[[VAL_91]] : i64] : vector<3xi64> +// CHECK: %[[VAL_93:.*]] = llvm.mlir.constant(2 : i32) : i32 +// CHECK: %[[VAL_94:.*]] = llvm.extractelement %[[VAL_83]]{{\[}}%[[VAL_93]] : i32] : vector<3xi64> +// CHECK: %[[VAL_95:.*]] = llvm.mlir.constant(2 : i64) : i64 +// CHECK: %[[VAL_96:.*]] = llvm.insertelement %[[VAL_94]], %[[VAL_92]]{{\[}}%[[VAL_95]] : i64] : vector<3xi64> +// CHECK: %[[VAL_97:.*]] = llvm.extractelement %[[VAL_96]]{{\[}}%[[VAL_81]] : i32] : vector<3xi64> +// CHECK: %[[VAL_98:.*]] = llvm.mul %[[VAL_97]], %[[VAL_79]] : i64 +// CHECK: %[[VAL_99:.*]] = llvm.add %[[VAL_80]], %[[VAL_98]] : i64 +// CHECK: %[[VAL_100:.*]] = llvm.mlir.constant(2 : i32) : i32 +// CHECK: %[[VAL_101:.*]] = llvm.mlir.addressof @__spirv_BuiltInLocalInvocationId : !llvm.ptr> +// CHECK: %[[VAL_102:.*]] = llvm.load %[[VAL_101]] : !llvm.ptr> +// CHECK-DAG: %[[VAL_103:.*]] = llvm.mlir.constant(dense<0> : vector<3xindex>) : vector<3xi64> +// CHECK-DAG: %[[VAL_104:.*]] = llvm.mlir.constant(0 : i32) : i32 +// CHECK: %[[VAL_105:.*]] = llvm.extractelement %[[VAL_102]]{{\[}}%[[VAL_104]] : i32] : vector<3xi64> +// CHECK: %[[VAL_106:.*]] = llvm.mlir.constant(0 : i64) : i64 +// CHECK: %[[VAL_107:.*]] = llvm.insertelement %[[VAL_105]], %[[VAL_103]]{{\[}}%[[VAL_106]] : i64] : vector<3xi64> +// CHECK: %[[VAL_108:.*]] = llvm.mlir.constant(1 : i32) : i32 +// CHECK: %[[VAL_109:.*]] = llvm.extractelement %[[VAL_102]]{{\[}}%[[VAL_108]] : i32] : vector<3xi64> +// CHECK: %[[VAL_110:.*]] = llvm.mlir.constant(1 : i64) : i64 +// CHECK: %[[VAL_111:.*]] = llvm.insertelement %[[VAL_109]], %[[VAL_107]]{{\[}}%[[VAL_110]] : i64] : vector<3xi64> +// CHECK: %[[VAL_112:.*]] = llvm.mlir.constant(2 : i32) : i32 +// CHECK: %[[VAL_113:.*]] = llvm.extractelement %[[VAL_102]]{{\[}}%[[VAL_112]] : i32] : vector<3xi64> +// CHECK: %[[VAL_114:.*]] = llvm.mlir.constant(2 : i64) : i64 +// CHECK: %[[VAL_115:.*]] = llvm.insertelement %[[VAL_113]], %[[VAL_111]]{{\[}}%[[VAL_114]] : i64] : vector<3xi64> +// CHECK: %[[VAL_116:.*]] = llvm.extractelement %[[VAL_115]]{{\[}}%[[VAL_100]] : i32] : vector<3xi64> +// CHECK: %[[VAL_117:.*]] = llvm.add %[[VAL_99]], %[[VAL_116]] : i64 +// CHECK: llvm.return %[[VAL_117]] : i64 +// CHECK-NEXT: } + func.func @test_3(%group: memref) -> i64 { + %0 = sycl.group.get_local_linear_id(%group) { ArgumentTypes = [memref], FunctionName = @"get_local_linear_id", MangledFunctionName = @"get_local_linear_id", TypeName = @"group" } : (memref) -> i64 + return %0 : i64 + } + } +} + +// ----- + +!sycl_id_1_ = !sycl.id<[1], (!sycl.array<[1], (memref<1xi64>)>)> +!sycl_range_1_ = !sycl.range<[1], (!sycl.array<[1], (memref<1xi64>)>)> +!sycl_group_1_ = !sycl.group<[1], (!sycl_range_1_, !sycl_range_1_, !sycl_range_1_, !sycl_id_1_)> +!sycl_id_2_ = !sycl.id<[2], (!sycl.array<[2], (memref<2xi64>)>)> +!sycl_range_2_ = !sycl.range<[2], (!sycl.array<[2], (memref<2xi64>)>)> +!sycl_group_2_ = !sycl.group<[2], (!sycl_range_2_, !sycl_range_2_, !sycl_range_2_, !sycl_id_2_)> +!sycl_id_3_ = !sycl.id<[3], (!sycl.array<[3], (memref<3xi64>)>)> +!sycl_range_3_ = !sycl.range<[3], (!sycl.array<[3], (memref<3xi64>)>)> +!sycl_group_3_ = !sycl.group<[3], (!sycl_range_3_, !sycl_range_3_, !sycl_range_3_, !sycl_id_3_)> + +// CHECK-LABEL: llvm.func @test_1( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[GROUP1]]>) -> i64 { +// CHECK-NEXT: %[[VAL_1:.*]] = llvm.mlir.constant(1 : i64) : i64 +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 2, 0, 0, 0] : (!llvm.ptr<[[GROUP1]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.load %[[VAL_2]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_4:.*]] = llvm.mul %[[VAL_1]], %[[VAL_3]] : i64 +// CHECK-NEXT: llvm.return %[[VAL_4]] : i64 +// CHECK-NEXT: } +func.func @test_1(%group: memref) -> i64 { + %0 = sycl.group.get_group_linear_range(%group) { ArgumentTypes = [memref], FunctionName = @"get_group_linear_range", MangledFunctionName = @"get_group_linear_range", TypeName = @"group" } : (memref) -> i64 + return %0 : i64 +} + +// CHECK-LABEL: llvm.func @test_2( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[GROUP2]]>) -> i64 { +// CHECK-NEXT: %[[VAL_1:.*]] = llvm.mlir.constant(1 : i64) : i64 +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 2, 0, 0, 0] : (!llvm.ptr<[[GROUP2]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.load %[[VAL_2]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_4:.*]] = llvm.mul %[[VAL_1]], %[[VAL_3]] : i64 +// CHECK-NEXT: %[[VAL_5:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 2, 0, 0, 1] : (!llvm.ptr<[[GROUP2]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_6:.*]] = llvm.load %[[VAL_5]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_7:.*]] = llvm.mul %[[VAL_4]], %[[VAL_6]] : i64 +// CHECK-NEXT: llvm.return %[[VAL_7]] : i64 +// CHECK-NEXT: } +func.func @test_2(%group: memref) -> i64 { + %0 = sycl.group.get_group_linear_range(%group) { ArgumentTypes = [memref], FunctionName = @"get_group_linear_range", MangledFunctionName = @"get_group_linear_range", TypeName = @"group" } : (memref) -> i64 + return %0 : i64 +} + +// CHECK-LABEL: llvm.func @test_3( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[GROUP3]]>) -> i64 { +// CHECK-NEXT: %[[VAL_1:.*]] = llvm.mlir.constant(1 : i64) : i64 +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 2, 0, 0, 0] : (!llvm.ptr<[[GROUP3]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.load %[[VAL_2]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_4:.*]] = llvm.mul %[[VAL_1]], %[[VAL_3]] : i64 +// CHECK-NEXT: %[[VAL_5:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 2, 0, 0, 1] : (!llvm.ptr<[[GROUP3]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_6:.*]] = llvm.load %[[VAL_5]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_7:.*]] = llvm.mul %[[VAL_4]], %[[VAL_6]] : i64 +// CHECK-NEXT: %[[VAL_8:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 2, 0, 0, 2] : (!llvm.ptr<[[GROUP3]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_9:.*]] = llvm.load %[[VAL_8]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_10:.*]] = llvm.mul %[[VAL_7]], %[[VAL_9]] : i64 +// CHECK-NEXT: llvm.return %[[VAL_10]] : i64 +// CHECK-NEXT: } +func.func @test_3(%group: memref) -> i64 { + %0 = sycl.group.get_group_linear_range(%group) { ArgumentTypes = [memref], FunctionName = @"get_group_linear_range", MangledFunctionName = @"get_group_linear_range", TypeName = @"group" } : (memref) -> i64 + return %0 : i64 +} + +// ----- + +!sycl_id_1_ = !sycl.id<[1], (!sycl.array<[1], (memref<1xi64>)>)> +!sycl_range_1_ = !sycl.range<[1], (!sycl.array<[1], (memref<1xi64>)>)> +!sycl_group_1_ = !sycl.group<[1], (!sycl_range_1_, !sycl_range_1_, !sycl_range_1_, !sycl_id_1_)> +!sycl_id_2_ = !sycl.id<[2], (!sycl.array<[2], (memref<2xi64>)>)> +!sycl_range_2_ = !sycl.range<[2], (!sycl.array<[2], (memref<2xi64>)>)> +!sycl_group_2_ = !sycl.group<[2], (!sycl_range_2_, !sycl_range_2_, !sycl_range_2_, !sycl_id_2_)> +!sycl_id_3_ = !sycl.id<[3], (!sycl.array<[3], (memref<3xi64>)>)> +!sycl_range_3_ = !sycl.range<[3], (!sycl.array<[3], (memref<3xi64>)>)> +!sycl_group_3_ = !sycl.group<[3], (!sycl_range_3_, !sycl_range_3_, !sycl_range_3_, !sycl_id_3_)> + +// CHECK-LABEL: llvm.func @test_1( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[GROUP1]]>) -> i64 { +// CHECK-NEXT: %[[VAL_1:.*]] = llvm.mlir.constant(1 : i64) : i64 +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0, 0, 0] : (!llvm.ptr<[[GROUP1]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.load %[[VAL_2]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_4:.*]] = llvm.mul %[[VAL_1]], %[[VAL_3]] : i64 +// CHECK-NEXT: llvm.return %[[VAL_4]] : i64 +// CHECK-NEXT: } +func.func @test_1(%group: memref) -> i64 { + %0 = sycl.group.get_local_linear_range(%group) { ArgumentTypes = [memref], FunctionName = @"get_local_linear_range", MangledFunctionName = @"get_local_linear_range", TypeName = @"group" } : (memref) -> i64 + return %0 : i64 +} + +// CHECK-LABEL: llvm.func @test_2( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[GROUP2]]>) -> i64 { +// CHECK-NEXT: %[[VAL_1:.*]] = llvm.mlir.constant(1 : i64) : i64 +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0, 0, 0] : (!llvm.ptr<[[GROUP2]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.load %[[VAL_2]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_4:.*]] = llvm.mul %[[VAL_1]], %[[VAL_3]] : i64 +// CHECK-NEXT: %[[VAL_5:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0, 0, 1] : (!llvm.ptr<[[GROUP2]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_6:.*]] = llvm.load %[[VAL_5]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_7:.*]] = llvm.mul %[[VAL_4]], %[[VAL_6]] : i64 +// CHECK-NEXT: llvm.return %[[VAL_7]] : i64 +// CHECK-NEXT: } +func.func @test_2(%group: memref) -> i64 { + %0 = sycl.group.get_local_linear_range(%group) { ArgumentTypes = [memref], FunctionName = @"get_local_linear_range", MangledFunctionName = @"get_local_linear_range", TypeName = @"group" } : (memref) -> i64 + return %0 : i64 +} + +// CHECK-LABEL: llvm.func @test_3( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[GROUP3]]>) -> i64 { +// CHECK-NEXT: %[[VAL_1:.*]] = llvm.mlir.constant(1 : i64) : i64 +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0, 0, 0] : (!llvm.ptr<[[GROUP3]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.load %[[VAL_2]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_4:.*]] = llvm.mul %[[VAL_1]], %[[VAL_3]] : i64 +// CHECK-NEXT: %[[VAL_5:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0, 0, 1] : (!llvm.ptr<[[GROUP3]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_6:.*]] = llvm.load %[[VAL_5]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_7:.*]] = llvm.mul %[[VAL_4]], %[[VAL_6]] : i64 +// CHECK-NEXT: %[[VAL_8:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0, 0, 2] : (!llvm.ptr<[[GROUP3]]>) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_9:.*]] = llvm.load %[[VAL_8]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_10:.*]] = llvm.mul %[[VAL_7]], %[[VAL_9]] : i64 +// CHECK-NEXT: llvm.return %[[VAL_10]] : i64 +// CHECK-NEXT: } +func.func @test_3(%group: memref) -> i64 { + %0 = sycl.group.get_local_linear_range(%group) { ArgumentTypes = [memref], FunctionName = @"get_local_linear_range", MangledFunctionName = @"get_local_linear_range", TypeName = @"group" } : (memref) -> i64 + return %0 : i64 +} diff --git a/mlir-sycl/test/Conversion/SYCLToLLVM/sycl-methods-to-llvm.mlir b/mlir-sycl/test/Conversion/SYCLToLLVM/sycl-methods-to-llvm.mlir index cb3346d81d46b..1bb59044c87ab 100644 --- a/mlir-sycl/test/Conversion/SYCLToLLVM/sycl-methods-to-llvm.mlir +++ b/mlir-sycl/test/Conversion/SYCLToLLVM/sycl-methods-to-llvm.mlir @@ -1,18 +1,17 @@ -// RUN: sycl-mlir-opt -split-input-file -convert-sycl-to-llvm %s | FileCheck %s +// RUN: sycl-mlir-opt -split-input-file -convert-sycl-to-llvm='use-opaque-pointers=1' %s | FileCheck %s -//===-------------------------------------------------------------------------------------------------===// +//===----------------------------------------------------------------------===// // sycl.range.get with scalar result type -//===-------------------------------------------------------------------------------------------------===// +//===----------------------------------------------------------------------===// !sycl_range_3_ = !sycl.range<[3], (!sycl.array<[3], (memref<3xi64>)>)> // CHECK-LABEL: llvm.func @test( -// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[RANGE3:.*]]>, +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr, // CHECK-SAME: %[[VAL_1:.*]]: i32) -> i64 { -// CHECK-NEXT: %[[VAL_2:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, %[[VAL_1]]] : (!llvm.ptr<[[RANGE3]]>, i32) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_3:.*]] = llvm.load %[[VAL_2]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, %[[VAL_1]]] : (!llvm.ptr, i32) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::range.3", {{.*}}> +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.load %[[VAL_2]] : !llvm.ptr -> i64 // CHECK-NEXT: llvm.return %[[VAL_3]] : i64 -// CHECK-NEXT: } func.func @test(%range: memref, %idx: i32) -> i64 { %0 = sycl.range.get %range[%idx] { ArgumentTypes = [memref, i32], FunctionName = @"get", MangledFunctionName = @"get", TypeName = @"range" } : (memref, i32) -> i64 return %0 : i64 @@ -20,18 +19,17 @@ func.func @test(%range: memref, %idx: i32) -> i64 { // ----- -//===-------------------------------------------------------------------------------------------------===// +//===----------------------------------------------------------------------===// // sycl.range.get with reference result type -//===-------------------------------------------------------------------------------------------------===// +//===----------------------------------------------------------------------===// !sycl_range_3_ = !sycl.range<[3], (!sycl.array<[3], (memref<3xi64>)>)> // CHECK-LABEL: llvm.func @test( -// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[RANGE3]]>, -// CHECK-SAME: %[[VAL_1:.*]]: i32) -> !llvm.ptr { -// CHECK-NEXT: %[[VAL_2:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, %[[VAL_1]]] : (!llvm.ptr<[[RANGE3]]>, i32) -> !llvm.ptr -// CHECK-NEXT: llvm.return %[[VAL_2]] : !llvm.ptr -// CHECK-NEXT: } +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr, +// CHECK-SAME: %[[VAL_1:.*]]: i32) -> !llvm.ptr { +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, %[[VAL_1]]] : (!llvm.ptr, i32) -> !llvm.ptr, i64 +// CHECK-NEXT: llvm.return %[[VAL_2]] : !llvm.ptr func.func @test(%range: memref, %idx: i32) -> memref { %0 = sycl.range.get %range[%idx] { ArgumentTypes = [memref, i32], FunctionName = @"operator[]", MangledFunctionName = @"operator[]", TypeName = @"range" } : (memref, i32) -> memref return %0 : memref @@ -39,57 +37,54 @@ func.func @test(%range: memref, %idx: i32) -> memref { // ----- -//===-------------------------------------------------------------------------------------------------===// +//===----------------------------------------------------------------------===// // sycl.range.size -//===-------------------------------------------------------------------------------------------------===// +//===----------------------------------------------------------------------===// !sycl_range_1_ = !sycl.range<[1], (!sycl.array<[1], (memref<1xi64>)>)> !sycl_range_2_ = !sycl.range<[2], (!sycl.array<[2], (memref<2xi64>)>)> !sycl_range_3_ = !sycl.range<[3], (!sycl.array<[3], (memref<3xi64>)>)> // CHECK-LABEL: llvm.func @test_1( -// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[RANGE1:.*]]>) -> i64 { +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr) -> i64 { // CHECK-NEXT: %[[VAL_1:.*]] = llvm.mlir.constant(1 : i64) : i64 -// CHECK-NEXT: %[[VAL_2:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 0] : (!llvm.ptr<[[RANGE1]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_3:.*]] = llvm.load %[[VAL_2]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_4:.*]] = llvm.mul %[[VAL_1]], %[[VAL_3]] : i64 +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::range.1", {{.*}}> +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.load %[[VAL_2]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_4:.*]] = llvm.mul %[[VAL_1]], %[[VAL_3]] : i64 // CHECK-NEXT: llvm.return %[[VAL_4]] : i64 -// CHECK-NEXT: } func.func @test_1(%range: memref) -> i64 { %0 = sycl.range.size(%range) { ArgumentTypes = [memref], FunctionName = @"size", MangledFunctionName = @"size", TypeName = @"range" } : (memref) -> i64 return %0 : i64 } // CHECK-LABEL: llvm.func @test_2( -// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[RANGE2:.*]]>) -> i64 { +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr) -> i64 { // CHECK-NEXT: %[[VAL_1:.*]] = llvm.mlir.constant(1 : i64) : i64 -// CHECK-NEXT: %[[VAL_2:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 0] : (!llvm.ptr<[[RANGE2]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_3:.*]] = llvm.load %[[VAL_2]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_4:.*]] = llvm.mul %[[VAL_1]], %[[VAL_3]] : i64 -// CHECK-NEXT: %[[VAL_5:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 1] : (!llvm.ptr<[[RANGE2]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_6:.*]] = llvm.load %[[VAL_5]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_7:.*]] = llvm.mul %[[VAL_4]], %[[VAL_6]] : i64 +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::range.2", {{.*}}> +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.load %[[VAL_2]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_4:.*]] = llvm.mul %[[VAL_1]], %[[VAL_3]] : i64 +// CHECK-NEXT: %[[VAL_5:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::range.2", {{.*}}> +// CHECK-NEXT: %[[VAL_6:.*]] = llvm.load %[[VAL_5]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_7:.*]] = llvm.mul %[[VAL_4]], %[[VAL_6]] : i64 // CHECK-NEXT: llvm.return %[[VAL_7]] : i64 -// CHECK-NEXT: } func.func @test_2(%range: memref) -> i64 { %0 = sycl.range.size(%range) { ArgumentTypes = [memref], FunctionName = @"size", MangledFunctionName = @"size", TypeName = @"range" } : (memref) -> i64 return %0 : i64 } // CHECK-LABEL: llvm.func @test_3( -// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[RANGE3]]>) -> i64 { +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr) -> i64 { // CHECK-NEXT: %[[VAL_1:.*]] = llvm.mlir.constant(1 : i64) : i64 -// CHECK-NEXT: %[[VAL_2:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 0] : (!llvm.ptr<[[RANGE3]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_3:.*]] = llvm.load %[[VAL_2]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_4:.*]] = llvm.mul %[[VAL_1]], %[[VAL_3]] : i64 -// CHECK-NEXT: %[[VAL_5:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 1] : (!llvm.ptr<[[RANGE3]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_6:.*]] = llvm.load %[[VAL_5]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_7:.*]] = llvm.mul %[[VAL_4]], %[[VAL_6]] : i64 -// CHECK-NEXT: %[[VAL_8:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 2] : (!llvm.ptr<[[RANGE3]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_9:.*]] = llvm.load %[[VAL_8]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_10:.*]] = llvm.mul %[[VAL_7]], %[[VAL_9]] : i64 +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::range.3", {{.*}}> +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.load %[[VAL_2]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_4:.*]] = llvm.mul %[[VAL_1]], %[[VAL_3]] : i64 +// CHECK-NEXT: %[[VAL_5:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::range.3", {{.*}}> +// CHECK-NEXT: %[[VAL_6:.*]] = llvm.load %[[VAL_5]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_7:.*]] = llvm.mul %[[VAL_4]], %[[VAL_6]] : i64 +// CHECK-NEXT: %[[VAL_8:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::range.3", {{.*}}> +// CHECK-NEXT: %[[VAL_9:.*]] = llvm.load %[[VAL_8]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_10:.*]] = llvm.mul %[[VAL_7]], %[[VAL_9]] : i64 // CHECK-NEXT: llvm.return %[[VAL_10]] : i64 -// CHECK-NEXT: } func.func @test_3(%range: memref) -> i64 { %0 = sycl.range.size(%range) { ArgumentTypes = [memref], FunctionName = @"size", MangledFunctionName = @"size", TypeName = @"range" } : (memref) -> i64 return %0 : i64 @@ -97,19 +92,18 @@ func.func @test_3(%range: memref) -> i64 { // ----- -//===-------------------------------------------------------------------------------------------------===// +//===----------------------------------------------------------------------===// // sycl.id.get with scalar result type -//===-------------------------------------------------------------------------------------------------===// +//===----------------------------------------------------------------------===// !sycl_id_3_ = !sycl.id<[3], (!sycl.array<[3], (memref<3xi64>)>)> // CHECK-LABEL: llvm.func @test( -// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[ID3:.*]]>, +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr, // CHECK-SAME: %[[VAL_1:.*]]: i32) -> i64 { -// CHECK-NEXT: %[[VAL_2:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, %[[VAL_1]]] : (!llvm.ptr<[[ID3]]>, i32) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_3:.*]] = llvm.load %[[VAL_2]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, %[[VAL_1]]] : (!llvm.ptr, i32) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::id.3", {{.*}}> +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.load %[[VAL_2]] : !llvm.ptr -> i64 // CHECK-NEXT: llvm.return %[[VAL_3]] : i64 -// CHECK-NEXT: } func.func @test(%id: memref, %idx: i32) -> i64 { %0 = sycl.id.get %id[%idx] { ArgumentTypes = [memref, i32], FunctionName = @"get", MangledFunctionName = @"get", TypeName = @"id" } : (memref, i32) -> i64 return %0 : i64 @@ -117,19 +111,18 @@ func.func @test(%id: memref, %idx: i32) -> i64 { // ----- -//===-------------------------------------------------------------------------------------------------===// +//===----------------------------------------------------------------------===// // sycl.id.get with scalar result type and no argument -//===-------------------------------------------------------------------------------------------------===// +//===----------------------------------------------------------------------===// !sycl_id_1_ = !sycl.id<[1], (!sycl.array<[1], (memref<1xi64>)>)> // CHECK-LABEL: llvm.func @test( -// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[ID1:.*]]>) -> i64 { -// CHECK: %[[VAL_1:.*]] = llvm.mlir.constant(0 : i32) : i32 -// CHECK: %[[VAL_2:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, %[[VAL_1]]] : (!llvm.ptr<[[ID1]]>, i32) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_3:.*]] = llvm.load %[[VAL_2]] : !llvm.ptr +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr) -> i64 { +// CHECK-NEXT: %[[VAL_1:.*]] = llvm.mlir.constant(0 : i32) : i32 +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, %[[VAL_1]]] : (!llvm.ptr, i32) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::id.1", {{.*}}> +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.load %[[VAL_2]] : !llvm.ptr -> i64 // CHECK-NEXT: llvm.return %[[VAL_3]] : i64 -// CHECK-NEXT: } func.func @test(%id: memref) -> i64 { %0 = sycl.id.get %id[] { ArgumentTypes = [memref], FunctionName = @"operator unsigned long", MangledFunctionName = @"operator unsigned long", TypeName = @"id" } : (memref) -> i64 return %0 : i64 @@ -137,18 +130,17 @@ func.func @test(%id: memref) -> i64 { // ----- -//===-------------------------------------------------------------------------------------------------===// +//===----------------------------------------------------------------------===// // sycl.id.get with reference result type -//===-------------------------------------------------------------------------------------------------===// +//===----------------------------------------------------------------------===// !sycl_id_3_ = !sycl.id<[3], (!sycl.array<[3], (memref<3xi64>)>)> // CHECK-LABEL: llvm.func @test( -// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[ID3]]>, -// CHECK-SAME: %[[VAL_1:.*]]: i32) -> !llvm.ptr { -// CHECK-NEXT: %[[VAL_2:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, %[[VAL_1]]] : (!llvm.ptr<[[ID3]]>, i32) -> !llvm.ptr -// CHECK-NEXT: llvm.return %[[VAL_2]] : !llvm.ptr -// CHECK-NEXT: } +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr, +// CHECK-SAME: %[[VAL_1:.*]]: i32) -> !llvm.ptr { +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, %[[VAL_1]]] : (!llvm.ptr, i32) -> !llvm.ptr, i64 +// CHECK-NEXT: llvm.return %[[VAL_2]] : !llvm.ptr func.func @test(%id: memref, %idx: i32) -> memref { %0 = sycl.id.get %id[%idx] { ArgumentTypes = [memref, i32], FunctionName = @"operator[]", MangledFunctionName = @"operator[]", TypeName = @"id" } : (memref, i32) -> memref return %0 : memref @@ -156,9 +148,9 @@ func.func @test(%id: memref, %idx: i32) -> memref { // ----- -//===-------------------------------------------------------------------------------------------------===// +//===----------------------------------------------------------------------===// // sycl.accessor.get_pointer -//===-------------------------------------------------------------------------------------------------===// +//===----------------------------------------------------------------------===// !sycl_id_1_ = !sycl.id<[1], (!sycl.array<[1], (memref<1xi64>)>)> !sycl_range_1_ = !sycl.range<[1], (!sycl.array<[1], (memref<1xi64>)>)> @@ -166,21 +158,20 @@ func.func @test(%id: memref, %idx: i32) -> memref { !sycl_accessor_1_i32_rw_gb = !sycl.accessor<[1, i32, read_write, global_buffer], (!sycl_accessor_impl_device_1_, !llvm.struct<(ptr)>)> // CHECK-LABEL: llvm.func @test( -// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[ACCESSOR1:.*]]>) -> !llvm.ptr { -// CHECK-NEXT: %[[VAL_1:.*]] = llvm.mlir.constant(0 : i64) : i64 -// CHECK-NEXT: %[[VAL_2:.*]] = llvm.mlir.constant(0 : i64) : i64 -// CHECK-NEXT: %[[VAL_3:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 2, 0, 0, 0] : (!llvm.ptr<[[ACCESSOR1]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_4:.*]] = llvm.load %[[VAL_3]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_5:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 0, 0, 0] : (!llvm.ptr<[[ACCESSOR1]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_6:.*]] = llvm.load %[[VAL_5]] : !llvm.ptr +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr) -> !llvm.ptr<1> { +// CHECK-DAG: %[[VAL_1:.*]] = llvm.mlir.constant(0 : i64) : i64 +// CHECK-DAG: %[[VAL_2:.*]] = llvm.mlir.constant(0 : i64) : i64 +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 2, 0, 0, 0] : (!llvm.ptr) -> !llvm.ptr, !sycl_accessor_1_i32_rw_gb +// CHECK-NEXT: %[[VAL_4:.*]] = llvm.load %[[VAL_3]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_5:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 0, 0, 0] : (!llvm.ptr) -> !llvm.ptr, !sycl_accessor_1_i32_rw_gb +// CHECK-NEXT: %[[VAL_6:.*]] = llvm.load %[[VAL_5]] : !llvm.ptr -> i64 // CHECK-NEXT: %[[VAL_7:.*]] = llvm.mul %[[VAL_2]], %[[VAL_4]] : i64 // CHECK-NEXT: %[[VAL_8:.*]] = llvm.add %[[VAL_7]], %[[VAL_6]] : i64 -// CHECK-NEXT: %[[VAL_9:.*]] = llvm.sub %[[VAL_1]], %[[VAL_8]] : i64 -// CHECK-NEXT: %[[VAL_10:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0] : (!llvm.ptr<[[ACCESSOR1]]>) -> !llvm.ptr> -// CHECK-NEXT: %[[VAL_11:.*]] = llvm.load %[[VAL_10]] : !llvm.ptr> -// CHECK-NEXT: %[[VAL_12:.*]] = llvm.getelementptr inbounds %[[VAL_11]][%[[VAL_9]]] : (!llvm.ptr, i64) -> !llvm.ptr -// CHECK-NEXT: llvm.return %[[VAL_12]] : !llvm.ptr -// CHECK-NEXT: } +// CHECK-NEXT: %[[VAL_9:.*]] = llvm.sub %[[VAL_1]], %[[VAL_8]] : i64 +// CHECK-NEXT: %[[VAL_10:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::accessor.1", {{.*}}> +// CHECK-NEXT: %[[VAL_11:.*]] = llvm.load %[[VAL_10]] : !llvm.ptr -> !llvm.ptr<1> +// CHECK-NEXT: %[[VAL_12:.*]] = llvm.getelementptr inbounds %[[VAL_11]]{{\[}}%[[VAL_9]]] : (!llvm.ptr<1>, i64) -> !llvm.ptr<1>, i32 +// CHECK-NEXT: llvm.return %[[VAL_12]] : !llvm.ptr<1> func.func @test(%acc: memref) -> memref { %0 = sycl.accessor.get_pointer(%acc) { ArgumentTypes = [memref], FunctionName = @"get_pointer", MangledFunctionName = @"get_pointer", TypeName = @"accessor" } : (memref) -> memref return %0 : memref @@ -188,9 +179,9 @@ func.func @test(%acc: memref) -> memref // ----- -//===-------------------------------------------------------------------------------------------------===// +//===----------------------------------------------------------------------===// // sycl.accessor.get_range -//===-------------------------------------------------------------------------------------------------===// +//===----------------------------------------------------------------------===// !sycl_id_1_ = !sycl.id<[1], (!sycl.array<[1], (memref<1xi64>)>)> !sycl_range_1_ = !sycl.range<[1], (!sycl.array<[1], (memref<1xi64>)>)> @@ -198,11 +189,10 @@ func.func @test(%acc: memref) -> memref !sycl_accessor_1_i32_rw_gb = !sycl.accessor<[1, i32, read_write, global_buffer], (!sycl_accessor_impl_device_1_, !llvm.struct<(ptr)>)> // CHECK-LABEL: llvm.func @test( -// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[ACCESSOR1:.*]]>) -> !llvm.[[RANGE1:.*]] { -// CHECK-NEXT: %[[VAL_1:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 1] : (!llvm.ptr<[[ACCESSOR1]]>) -> !llvm.ptr<[[RANGE1]]> -// CHECK-NEXT: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] : !llvm.ptr<[[RANGE1]]> -// CHECK-NEXT: llvm.return %[[VAL_2]] : !llvm.[[RANGE1]] -// CHECK-NEXT: } +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr) -> !llvm.struct<"class.sycl::_V1::range.1", {{.*}}> { +// CHECK-NEXT: %[[VAL_1:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::accessor.1", {{.*}}> +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] : !llvm.ptr -> !llvm.struct<"class.sycl::_V1::range.1", {{.*}}> +// CHECK-NEXT: llvm.return %[[VAL_2]] : !llvm.struct<"class.sycl::_V1::range.1", {{.*}}> func.func @test(%acc: memref) -> !sycl_range_1_ { %0 = sycl.accessor.get_range(%acc) { ArgumentTypes = [memref], FunctionName = @"get_range", MangledFunctionName = @"get_range", TypeName = @"accessor" } : (memref) -> !sycl_range_1_ return %0 : !sycl_range_1_ @@ -210,9 +200,9 @@ func.func @test(%acc: memref) -> !sycl_range_1_ { // ----- -//===-------------------------------------------------------------------------------------------------===// +//===----------------------------------------------------------------------===// // sycl.accessor.size -//===-------------------------------------------------------------------------------------------------===// +//===----------------------------------------------------------------------===// !sycl_id_1_ = !sycl.id<[1], (!sycl.array<[1], (memref<1xi64>)>)> !sycl_range_1_ = !sycl.range<[1], (!sycl.array<[1], (memref<1xi64>)>)> @@ -220,10 +210,10 @@ func.func @test(%acc: memref) -> !sycl_range_1_ { !sycl_accessor_1_i32_rw_gb = !sycl.accessor<[1, i32, read_write, global_buffer], (!sycl_accessor_impl_device_1_, !llvm.struct<(ptr)>)> // CHECK-LABEL: llvm.func @test( -// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[ACCESSOR1:.*]]>) -> i64 { +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr) -> i64 { // CHECK-NEXT: %[[VAL_1:.*]] = llvm.mlir.constant(1 : i64) : i64 -// CHECK-NEXT: %[[VAL_2:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 1, 0, 0, 0] : (!llvm.ptr<[[ACCESSOR1]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_3:.*]] = llvm.load %[[VAL_2]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 1, 0, 0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::accessor.1", {{.*}}> +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.load %[[VAL_2]] : !llvm.ptr -> i64 // CHECK-NEXT: %[[VAL_4:.*]] = llvm.mul %[[VAL_1]], %[[VAL_3]] : i64 // CHECK-NEXT: llvm.return %[[VAL_4]] : i64 // CHECK-NEXT: } @@ -234,9 +224,9 @@ func.func @test(%acc: memref) -> i64 { // ----- -//===-------------------------------------------------------------------------------------------------===// +//===----------------------------------------------------------------------===// // sycl.accessor.subscript with scalar offset and 1D accessor -//===-------------------------------------------------------------------------------------------------===// +//===----------------------------------------------------------------------===// !sycl_id_1_ = !sycl.id<[1], (!sycl.array<[1], (memref<1xi64>)>)> !sycl_range_1_ = !sycl.range<[1], (!sycl.array<[1], (memref<1xi64>)>)> @@ -244,13 +234,12 @@ func.func @test(%acc: memref) -> i64 { !sycl_accessor_1_i32_rw_gb = !sycl.accessor<[1, i32, read_write, global_buffer], (!sycl_accessor_impl_device_1_, !llvm.struct<(ptr)>)> // CHECK-LABEL: llvm.func @test( -// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[ACCESSOR1:.*]]>, -// CHECK-SAME: %[[VAL_1:.*]]: i64) -> !llvm.ptr { -// CHECK-NEXT: %[[VAL_2:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0] : (!llvm.ptr<[[ACCESSOR1]]>) -> !llvm.ptr> -// CHECK-NEXT: %[[VAL_3:.*]] = llvm.load %[[VAL_2]] : !llvm.ptr> -// CHECK-NEXT: %[[VAL_4:.*]] = llvm.getelementptr inbounds %[[VAL_3]][%[[VAL_1]]] : (!llvm.ptr, i64) -> !llvm.ptr -// CHECK-NEXT: llvm.return %[[VAL_4]] : !llvm.ptr -// CHECK-NEXT: } +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr, +// CHECK-SAME: %[[VAL_1:.*]]: i64) -> !llvm.ptr<1> { +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0] : (!llvm.ptr) -> !llvm.ptr, !sycl_accessor_1_i32_rw_gb +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.load %[[VAL_2]] : !llvm.ptr -> !llvm.ptr<1> +// CHECK-NEXT: %[[VAL_4:.*]] = llvm.getelementptr inbounds %[[VAL_3]]{{\[}}%[[VAL_1]]] : (!llvm.ptr<1>, i64) -> !llvm.ptr<1>, i32 +// CHECK-NEXT: llvm.return %[[VAL_4]] : !llvm.ptr<1> func.func @test(%acc: memref, %idx: i64) -> memref { %0 = sycl.accessor.subscript %acc[%idx] { ArgumentTypes = [memref, i64], FunctionName = @"operator[]", MangledFunctionName = @"operator[]", TypeName = @"id" } : (memref, i64) -> memref return %0 : memref @@ -258,9 +247,9 @@ func.func @test(%acc: memref, %idx: i64) -> memref // ----- -//===-------------------------------------------------------------------------------------------------===// +//===----------------------------------------------------------------------===// // sycl.accessor.subscript with scalar offset and ND accessor -//===-------------------------------------------------------------------------------------------------===// +//===----------------------------------------------------------------------===// !sycl_id_1_ = !sycl.id<[1], (!sycl.array<[1], (memref<1xi64>)>)> !sycl_id_2_ = !sycl.id<[2], (!sycl.array<[2], (memref<2xi64>)>)> @@ -275,29 +264,29 @@ func.func @test(%acc: memref, %idx: i64) -> memref !sycl_accessor_subscript_3_ = !sycl.accessor_subscript<[3], (!sycl_id_3_, !sycl_accessor_3_i32_rw_gb)> // CHECK-LABEL: llvm.func @test_2( -// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[ACCESSOR2:.*]]>, %[[VAL_1:.*]]: i64) -> !llvm.[[ACCESSORSUBS2:.*]] { -// CHECK-NEXT: %[[VAL_2:.*]] = llvm.mlir.undef : !llvm.[[ACCESSORSUBS2]] -// CHECK-NEXT: %[[VAL_3:.*]] = llvm.insertvalue %[[VAL_1]], %[[VAL_2]][0, 0, 0, 0] : !llvm.[[ACCESSORSUBS2]] +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr, +// CHECK-SAME: %[[VAL_1:.*]]: i64) -> !llvm.struct<"class.sycl::_V1::detail::accessor_common.AccessorSubscript.2", {{.*}}> { +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.mlir.undef : !llvm.struct<"class.sycl::_V1::detail::accessor_common.AccessorSubscript.2", {{.*}}> +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.insertvalue %[[VAL_1]], %[[VAL_2]][0, 0, 0, 0] : !llvm.struct<"class.sycl::_V1::detail::accessor_common.AccessorSubscript.2", {{.*}}> // CHECK-NEXT: %[[VAL_4:.*]] = llvm.mlir.constant(0 : i64) : i64 -// CHECK-NEXT: %[[VAL_5:.*]] = llvm.load %[[VAL_0]] : !llvm.ptr<[[ACCESSOR2]]> -// CHECK-NEXT: %[[VAL_6:.*]] = llvm.insertvalue %[[VAL_5]], %[[VAL_3]][1] : !llvm.[[ACCESSORSUBS2]] -// CHECK-NEXT: llvm.return %[[VAL_6]] : !llvm.[[ACCESSORSUBS2]] -// CHECK-NEXT: } +// CHECK-NEXT: %[[VAL_5:.*]] = llvm.load %[[VAL_0]] : !llvm.ptr -> !llvm.struct<"class.sycl::_V1::accessor.2", {{.*}}> +// CHECK-NEXT: %[[VAL_6:.*]] = llvm.insertvalue %[[VAL_5]], %[[VAL_3]][1] : !llvm.struct<"class.sycl::_V1::detail::accessor_common.AccessorSubscript.2", {{.*}}> +// CHECK-NEXT: llvm.return %[[VAL_6]] : !llvm.struct<"class.sycl::_V1::detail::accessor_common.AccessorSubscript.2", {{.*}}> func.func @test_2(%acc: memref, %idx: i64) -> !sycl_accessor_subscript_2_ { %0 = sycl.accessor.subscript %acc[%idx] { ArgumentTypes = [memref, i64], FunctionName = @"operator[]", MangledFunctionName = @"operator[]", TypeName = @"id" } : (memref, i64) -> !sycl_accessor_subscript_2_ return %0 : !sycl_accessor_subscript_2_ } // CHECK-LABEL: llvm.func @test_3( -// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[ACCESSOR3:.*]]>, %[[VAL_1:.*]]: i64) -> !llvm.[[ACCESSORSUBS3:.*]] { -// CHECK-NEXT: %[[VAL_2:.*]] = llvm.mlir.undef : !llvm.[[ACCESSORSUBS3]] -// CHECK-NEXT: %[[VAL_3:.*]] = llvm.insertvalue %[[VAL_1]], %[[VAL_2]][0, 0, 0, 0] : !llvm.[[ACCESSORSUBS3]] +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr, +// CHECK-SAME: %[[VAL_1:.*]]: i64) -> !llvm.struct<"class.sycl::_V1::detail::accessor_common.AccessorSubscript.3", {{.*}}> { +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.mlir.undef : !llvm.struct<"class.sycl::_V1::detail::accessor_common.AccessorSubscript.3", {{.*}}> +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.insertvalue %[[VAL_1]], %[[VAL_2]][0, 0, 0, 0] : !llvm.struct<"class.sycl::_V1::detail::accessor_common.AccessorSubscript.3", {{.*}}> // CHECK-NEXT: %[[VAL_4:.*]] = llvm.mlir.constant(0 : i64) : i64 -// CHECK-NEXT: %[[VAL_5:.*]] = llvm.insertvalue %[[VAL_4]], %[[VAL_3]][0, 0, 0, 1] : !llvm.[[ACCESSORSUBS3]] -// CHECK-NEXT: %[[VAL_6:.*]] = llvm.load %[[VAL_0]] : !llvm.ptr<[[ACCESSOR3]]> -// CHECK-NEXT: %[[VAL_7:.*]] = llvm.insertvalue %[[VAL_6]], %[[VAL_5]][1] : !llvm.[[ACCESSORSUBS3]] -// CHECK-NEXT: llvm.return %[[VAL_7]] : !llvm.[[ACCESSORSUBS3]] -// CHECK-NEXT: } +// CHECK-NEXT: %[[VAL_5:.*]] = llvm.insertvalue %[[VAL_4]], %[[VAL_3]][0, 0, 0, 1] : !llvm.struct<"class.sycl::_V1::detail::accessor_common.AccessorSubscript.3", {{.*}}> +// CHECK-NEXT: %[[VAL_6:.*]] = llvm.load %[[VAL_0]] : !llvm.ptr -> !llvm.struct<"class.sycl::_V1::accessor.3", {{.*}}> +// CHECK-NEXT: %[[VAL_7:.*]] = llvm.insertvalue %[[VAL_6]], %[[VAL_5]][1] : !llvm.struct<"class.sycl::_V1::detail::accessor_common.AccessorSubscript.3", {{.*}}> +// CHECK-NEXT: llvm.return %[[VAL_7]] : !llvm.struct<"class.sycl::_V1::detail::accessor_common.AccessorSubscript.3", {{.*}}> func.func @test_3(%acc: memref, %idx: i64) -> !sycl_accessor_subscript_3_ { %0 = sycl.accessor.subscript %acc[%idx] { ArgumentTypes = [memref, i64], FunctionName = @"operator[]", MangledFunctionName = @"operator[]", TypeName = @"id" } : (memref, i64) -> !sycl_accessor_subscript_3_ return %0 : !sycl_accessor_subscript_3_ @@ -305,9 +294,9 @@ func.func @test_3(%acc: memref, %idx: i64) -> !syc // ----- -//===-------------------------------------------------------------------------------------------------===// +//===----------------------------------------------------------------------===// // sycl.accessor.subscript with id offset -//===-------------------------------------------------------------------------------------------------===// +//===----------------------------------------------------------------------===// !sycl_id_1_ = !sycl.id<[1], (!sycl.array<[1], (memref<1xi64>)>)> !sycl_range_1_ = !sycl.range<[1], (!sycl.array<[1], (memref<1xi64>)>)> @@ -325,100 +314,97 @@ func.func @test_3(%acc: memref, %idx: i64) -> !syc !sycl_accessor_1_struct_rw_gb = !sycl.accessor<[1, !my_struct, read_write, global_buffer], (!sycl_accessor_impl_device_1_, !llvm.struct<(ptr)>)> // CHECK-LABEL: llvm.func @test_1( -// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[ACCESSOR1]]>, -// CHECK-SAME: %[[VAL_1:.*]]: !llvm.ptr<[[ID1]]>) -> !llvm.ptr { +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr, +// CHECK-SAME: %[[VAL_1:.*]]: !llvm.ptr) -> !llvm.ptr<1> { // CHECK-NEXT: %[[VAL_2:.*]] = llvm.mlir.constant(0 : i64) : i64 -// CHECK-NEXT: %[[VAL_3:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 2, 0, 0, 0] : (!llvm.ptr<[[ACCESSOR1]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_4:.*]] = llvm.load %[[VAL_3]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_5:.*]] = llvm.getelementptr inbounds %[[VAL_1]][0, 0, 0, 0] : (!llvm.ptr<[[ID1]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_6:.*]] = llvm.load %[[VAL_5]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_7:.*]] = llvm.mul %[[VAL_2]], %[[VAL_4]] : i64 -// CHECK-NEXT: %[[VAL_8:.*]] = llvm.add %[[VAL_7]], %[[VAL_6]] : i64 -// CHECK-NEXT: %[[VAL_9:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0] : (!llvm.ptr<[[ACCESSOR1]]>) -> !llvm.ptr> -// CHECK-NEXT: %[[VAL_10:.*]] = llvm.load %[[VAL_9]] : !llvm.ptr> -// CHECK-NEXT: %[[VAL_11:.*]] = llvm.getelementptr inbounds %[[VAL_10]][%[[VAL_8]]] : (!llvm.ptr, i64) -> !llvm.ptr -// CHECK-NEXT: llvm.return %[[VAL_11]] : !llvm.ptr -// CHECK-NEXT: } +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 2, 0, 0, 0] : (!llvm.ptr) -> !llvm.ptr, !sycl_accessor_1_i32_rw_gb +// CHECK-NEXT: %[[VAL_4:.*]] = llvm.load %[[VAL_3]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_5:.*]] = llvm.getelementptr inbounds %[[VAL_1]][0, 0, 0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::id.1", {{.*}}> +// CHECK-NEXT: %[[VAL_6:.*]] = llvm.load %[[VAL_5]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_7:.*]] = llvm.mul %[[VAL_2]], %[[VAL_4]] : i64 +// CHECK-NEXT: %[[VAL_8:.*]] = llvm.add %[[VAL_7]], %[[VAL_6]] : i64 +// CHECK-NEXT: %[[VAL_9:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0] : (!llvm.ptr) -> !llvm.ptr, !sycl_accessor_1_i32_rw_gb +// CHECK-NEXT: %[[VAL_10:.*]] = llvm.load %[[VAL_9]] : !llvm.ptr -> !llvm.ptr<1> +// CHECK-NEXT: %[[VAL_11:.*]] = llvm.getelementptr inbounds %[[VAL_10]]{{\[}}%[[VAL_8]]] : (!llvm.ptr<1>, i64) -> !llvm.ptr<1>, i32 +// CHECK-NEXT: llvm.return %[[VAL_11]] : !llvm.ptr<1> func.func @test_1(%acc: memref, %idx: memref) -> memref { %0 = sycl.accessor.subscript %acc[%idx] { ArgumentTypes = [memref, memref], FunctionName = @"operator[]", MangledFunctionName = @"operator[]", TypeName = @"id" } : (memref, memref) -> memref return %0 : memref } // CHECK-LABEL: llvm.func @test_2( -// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[ACCESSOR2]]>, -// CHECK-SAME: %[[VAL_1:.*]]: !llvm.ptr<[[ID2:.*]]>) -> !llvm.ptr { +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr, +// CHECK-SAME: %[[VAL_1:.*]]: !llvm.ptr) -> !llvm.ptr<1> { // CHECK-NEXT: %[[VAL_2:.*]] = llvm.mlir.constant(0 : i64) : i64 -// CHECK-NEXT: %[[VAL_3:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 2, 0, 0, 0] : (!llvm.ptr<[[ACCESSOR2]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_4:.*]] = llvm.load %[[VAL_3]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_5:.*]] = llvm.getelementptr inbounds %[[VAL_1]][0, 0, 0, 0] : (!llvm.ptr<[[ID2]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_6:.*]] = llvm.load %[[VAL_5]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_7:.*]] = llvm.mul %[[VAL_2]], %[[VAL_4]] : i64 -// CHECK-NEXT: %[[VAL_8:.*]] = llvm.add %[[VAL_7]], %[[VAL_6]] : i64 -// CHECK-NEXT: %[[VAL_9:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 2, 0, 0, 1] : (!llvm.ptr<[[ACCESSOR2]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_10:.*]] = llvm.load %[[VAL_9]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_11:.*]] = llvm.getelementptr inbounds %[[VAL_1]][0, 0, 0, 1] : (!llvm.ptr<[[ID2]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_12:.*]] = llvm.load %[[VAL_11]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_13:.*]] = llvm.mul %[[VAL_8]], %[[VAL_10]] : i64 -// CHECK-NEXT: %[[VAL_14:.*]] = llvm.add %[[VAL_13]], %[[VAL_12]] : i64 -// CHECK-NEXT: %[[VAL_15:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0] : (!llvm.ptr<[[ACCESSOR2]]>) -> !llvm.ptr> -// CHECK-NEXT: %[[VAL_16:.*]] = llvm.load %[[VAL_15]] : !llvm.ptr> -// CHECK-NEXT: %[[VAL_17:.*]] = llvm.getelementptr inbounds %[[VAL_16]][%[[VAL_14]]] : (!llvm.ptr, i64) -> !llvm.ptr -// CHECK-NEXT: llvm.return %[[VAL_17]] : !llvm.ptr -// CHECK-NEXT: } +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 2, 0, 0, 0] : (!llvm.ptr) -> !llvm.ptr, !sycl_accessor_2_i32_rw_gb +// CHECK-NEXT: %[[VAL_4:.*]] = llvm.load %[[VAL_3]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_5:.*]] = llvm.getelementptr inbounds %[[VAL_1]][0, 0, 0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::id.2", {{.*}}> +// CHECK-NEXT: %[[VAL_6:.*]] = llvm.load %[[VAL_5]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_7:.*]] = llvm.mul %[[VAL_2]], %[[VAL_4]] : i64 +// CHECK-NEXT: %[[VAL_8:.*]] = llvm.add %[[VAL_7]], %[[VAL_6]] : i64 +// CHECK-NEXT: %[[VAL_9:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 2, 0, 0, 1] : (!llvm.ptr) -> !llvm.ptr, !sycl_accessor_2_i32_rw_gb +// CHECK-NEXT: %[[VAL_10:.*]] = llvm.load %[[VAL_9]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_11:.*]] = llvm.getelementptr inbounds %[[VAL_1]][0, 0, 0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::id.2", {{.*}}> +// CHECK-NEXT: %[[VAL_12:.*]] = llvm.load %[[VAL_11]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_13:.*]] = llvm.mul %[[VAL_8]], %[[VAL_10]] : i64 +// CHECK-NEXT: %[[VAL_14:.*]] = llvm.add %[[VAL_13]], %[[VAL_12]] : i64 +// CHECK-NEXT: %[[VAL_15:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0] : (!llvm.ptr) -> !llvm.ptr, !sycl_accessor_2_i32_rw_gb +// CHECK-NEXT: %[[VAL_16:.*]] = llvm.load %[[VAL_15]] : !llvm.ptr -> !llvm.ptr<1> +// CHECK-NEXT: %[[VAL_17:.*]] = llvm.getelementptr inbounds %[[VAL_16]]{{\[}}%[[VAL_14]]] : (!llvm.ptr<1>, i64) -> !llvm.ptr<1>, i32 +// CHECK-NEXT: llvm.return %[[VAL_17]] : !llvm.ptr<1> func.func @test_2(%acc: memref, %idx: memref) -> memref { %0 = sycl.accessor.subscript %acc[%idx] { ArgumentTypes = [memref, memref], FunctionName = @"operator[]", MangledFunctionName = @"operator[]", TypeName = @"id" } : (memref, memref) -> memref return %0 : memref } // CHECK-LABEL: llvm.func @test_3( -// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[ACCESSOR3:.*]]>, -// CHECK-SAME: %[[VAL_1:.*]]: !llvm.ptr<[[ID3]]>) -> !llvm.ptr { +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr, +// CHECK-SAME: %[[VAL_1:.*]]: !llvm.ptr) -> !llvm.ptr<1> { // CHECK-NEXT: %[[VAL_2:.*]] = llvm.mlir.constant(0 : i64) : i64 -// CHECK-NEXT: %[[VAL_3:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 2, 0, 0, 0] : (!llvm.ptr<[[ACCESSOR3]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_4:.*]] = llvm.load %[[VAL_3]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_5:.*]] = llvm.getelementptr inbounds %[[VAL_1]][0, 0, 0, 0] : (!llvm.ptr<[[ID3]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_6:.*]] = llvm.load %[[VAL_5]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_7:.*]] = llvm.mul %[[VAL_2]], %[[VAL_4]] : i64 -// CHECK-NEXT: %[[VAL_8:.*]] = llvm.add %[[VAL_7]], %[[VAL_6]] : i64 -// CHECK-NEXT: %[[VAL_9:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 2, 0, 0, 1] : (!llvm.ptr<[[ACCESSOR3]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_10:.*]] = llvm.load %[[VAL_9]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_11:.*]] = llvm.getelementptr inbounds %[[VAL_1]][0, 0, 0, 1] : (!llvm.ptr<[[ID3]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_12:.*]] = llvm.load %[[VAL_11]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_13:.*]] = llvm.mul %[[VAL_8]], %[[VAL_10]] : i64 -// CHECK-NEXT: %[[VAL_14:.*]] = llvm.add %[[VAL_13]], %[[VAL_12]] : i64 -// CHECK-NEXT: %[[VAL_15:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 2, 0, 0, 2] : (!llvm.ptr<[[ACCESSOR3]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_16:.*]] = llvm.load %[[VAL_15]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_17:.*]] = llvm.getelementptr inbounds %[[VAL_1]][0, 0, 0, 2] : (!llvm.ptr<[[ID3]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_18:.*]] = llvm.load %[[VAL_17]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_19:.*]] = llvm.mul %[[VAL_14]], %[[VAL_16]] : i64 -// CHECK-NEXT: %[[VAL_20:.*]] = llvm.add %[[VAL_19]], %[[VAL_18]] : i64 -// CHECK-NEXT: %[[VAL_21:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0] : (!llvm.ptr<[[ACCESSOR3]]>) -> !llvm.ptr> -// CHECK-NEXT: %[[VAL_22:.*]] = llvm.load %[[VAL_21]] : !llvm.ptr> -// CHECK-NEXT: %[[VAL_23:.*]] = llvm.getelementptr inbounds %[[VAL_22]][%[[VAL_20]]] : (!llvm.ptr, i64) -> !llvm.ptr -// CHECK-NEXT: llvm.return %[[VAL_23]] : !llvm.ptr -// CHECK-NEXT: } +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 2, 0, 0, 0] : (!llvm.ptr) -> !llvm.ptr, !sycl_accessor_3_i32_rw_gb +// CHECK-NEXT: %[[VAL_4:.*]] = llvm.load %[[VAL_3]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_5:.*]] = llvm.getelementptr inbounds %[[VAL_1]][0, 0, 0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::id.3", {{.*}}> +// CHECK-NEXT: %[[VAL_6:.*]] = llvm.load %[[VAL_5]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_7:.*]] = llvm.mul %[[VAL_2]], %[[VAL_4]] : i64 +// CHECK-NEXT: %[[VAL_8:.*]] = llvm.add %[[VAL_7]], %[[VAL_6]] : i64 +// CHECK-NEXT: %[[VAL_9:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 2, 0, 0, 1] : (!llvm.ptr) -> !llvm.ptr, !sycl_accessor_3_i32_rw_gb +// CHECK-NEXT: %[[VAL_10:.*]] = llvm.load %[[VAL_9]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_11:.*]] = llvm.getelementptr inbounds %[[VAL_1]][0, 0, 0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::id.3", {{.*}}> +// CHECK-NEXT: %[[VAL_12:.*]] = llvm.load %[[VAL_11]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_13:.*]] = llvm.mul %[[VAL_8]], %[[VAL_10]] : i64 +// CHECK-NEXT: %[[VAL_14:.*]] = llvm.add %[[VAL_13]], %[[VAL_12]] : i64 +// CHECK-NEXT: %[[VAL_15:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 2, 0, 0, 2] : (!llvm.ptr) -> !llvm.ptr, !sycl_accessor_3_i32_rw_gb +// CHECK-NEXT: %[[VAL_16:.*]] = llvm.load %[[VAL_15]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_17:.*]] = llvm.getelementptr inbounds %[[VAL_1]][0, 0, 0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::id.3", {{.*}}> +// CHECK-NEXT: %[[VAL_18:.*]] = llvm.load %[[VAL_17]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_19:.*]] = llvm.mul %[[VAL_14]], %[[VAL_16]] : i64 +// CHECK-NEXT: %[[VAL_20:.*]] = llvm.add %[[VAL_19]], %[[VAL_18]] : i64 +// CHECK-NEXT: %[[VAL_21:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0] : (!llvm.ptr) -> !llvm.ptr, !sycl_accessor_3_i32_rw_gb +// CHECK-NEXT: %[[VAL_22:.*]] = llvm.load %[[VAL_21]] : !llvm.ptr -> !llvm.ptr<1> +// CHECK-NEXT: %[[VAL_23:.*]] = llvm.getelementptr inbounds %[[VAL_22]]{{\[}}%[[VAL_20]]] : (!llvm.ptr<1>, i64) -> !llvm.ptr<1>, i32 +// CHECK-NEXT: llvm.return %[[VAL_23]] : !llvm.ptr<1> func.func @test_3(%acc: memref, %idx: memref) -> memref { %0 = sycl.accessor.subscript %acc[%idx] { ArgumentTypes = [memref, memref], FunctionName = @"operator[]", MangledFunctionName = @"operator[]", TypeName = @"id" } : (memref, memref) -> memref return %0 : memref } // CHECK-LABEL: llvm.func @test_struct( -// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[ACCESSORSTR:.*]]>, %[[VAL_1:.*]]: !llvm.ptr<[[ID1]]>) -> !llvm.ptr, 1> { +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr, +// CHECK-SAME: %[[VAL_1:.*]]: !llvm.ptr) -> !llvm.ptr<1> { // CHECK-NEXT: %[[VAL_2:.*]] = llvm.mlir.constant(0 : i64) : i64 -// CHECK-NEXT: %[[VAL_3:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 2, 0, 0, 0] : (!llvm.ptr<[[ACCESSORSTR]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_4:.*]] = llvm.load %[[VAL_3]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_5:.*]] = llvm.getelementptr inbounds %[[VAL_1]][0, 0, 0, 0] : (!llvm.ptr<[[ID1]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_6:.*]] = llvm.load %[[VAL_5]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_7:.*]] = llvm.mul %[[VAL_2]], %[[VAL_4]] : i64 -// CHECK-NEXT: %[[VAL_8:.*]] = llvm.add %[[VAL_7]], %[[VAL_6]] : i64 -// CHECK-NEXT: %[[VAL_9:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0] : (!llvm.ptr<[[ACCESSORSTR]]>) -> !llvm.ptr, 1>> -// CHECK-NEXT: %[[VAL_10:.*]] = llvm.load %[[VAL_9]] : !llvm.ptr, 1>> -// CHECK-NEXT: %[[VAL_11:.*]] = llvm.getelementptr inbounds %[[VAL_10]][%[[VAL_8]]] : (!llvm.ptr, 1>, i64) -> !llvm.ptr, 1> -// CHECK-NEXT: llvm.return %[[VAL_11]] : !llvm.ptr, 1> -// CHECK-NEXT: } -func.func @test_struct(%acc: memref, %idx: memref) -> !llvm.ptr, 1> { - %0 = sycl.accessor.subscript %acc[%idx] { ArgumentTypes = [memref, memref], FunctionName = @"operator[]", MangledFunctionName = @"operator[]", TypeName = @"id" } : (memref, memref) -> !llvm.ptr, 1> - return %0 : !llvm.ptr, 1> +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 2, 0, 0, 0] : (!llvm.ptr) -> !llvm.ptr, !sycl_accessor_1_21llvm2Estruct3C28i322C_f32293E_rw_gb +// CHECK-NEXT: %[[VAL_4:.*]] = llvm.load %[[VAL_3]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_5:.*]] = llvm.getelementptr inbounds %[[VAL_1]][0, 0, 0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::id.1", {{.*}}> +// CHECK-NEXT: %[[VAL_6:.*]] = llvm.load %[[VAL_5]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_7:.*]] = llvm.mul %[[VAL_2]], %[[VAL_4]] : i64 +// CHECK-NEXT: %[[VAL_8:.*]] = llvm.add %[[VAL_7]], %[[VAL_6]] : i64 +// CHECK-NEXT: %[[VAL_9:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0] : (!llvm.ptr) -> !llvm.ptr, !sycl_accessor_1_21llvm2Estruct3C28i322C_f32293E_rw_gb +// CHECK-NEXT: %[[VAL_10:.*]] = llvm.load %[[VAL_9]] : !llvm.ptr -> !llvm.ptr<1> +// CHECK-NEXT: %[[VAL_11:.*]] = llvm.getelementptr inbounds %[[VAL_10]]{{\[}}%[[VAL_8]]] : (!llvm.ptr<1>, i64) -> !llvm.ptr<1>, !llvm.struct<(i32, f32)> +// CHECK-NEXT: llvm.return %[[VAL_11]] : !llvm.ptr<1> +func.func @test_struct(%acc: memref, %idx: memref) -> !llvm.ptr<1> { + %0 = sycl.accessor.subscript %acc[%idx] { ArgumentTypes = [memref, memref], FunctionName = @"operator[]", MangledFunctionName = @"operator[]", TypeName = @"id" } : (memref, memref) -> !llvm.ptr<1> + return %0 : !llvm.ptr<1> } // ----- @@ -435,21 +421,21 @@ func.func @test_struct(%acc: memref, %idx: memr !sycl_atomic_i32_glo = !sycl.atomic<[i32, global], (memref)> // CHECK-LABEL: llvm.func @test( -// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[ACCESSOR1:.*]]>, -// CHECK-SAME: %[[VAL_1:.*]]: !llvm.ptr<[[ID1:.*]]>) -> !llvm.[[ATOM1:.*]] { -// CHECK-DAG: %[[VAL_2:.*]] = llvm.mlir.undef : !llvm.[[ATOM1]] -// CHECK-DAG: %[[VAL_3:.*]] = llvm.mlir.constant(0 : i64) : i64 -// CHECK: %[[VAL_4:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 2, 0, 0, 0] : (!llvm.ptr<[[ACCESSOR1]]>) -> !llvm.ptr -// CHECK: %[[VAL_5:.*]] = llvm.load %[[VAL_4]] : !llvm.ptr -// CHECK: %[[VAL_6:.*]] = llvm.getelementptr inbounds %[[VAL_1]][0, 0, 0, 0] : (!llvm.ptr<[[ID1]]>) -> !llvm.ptr -// CHECK: %[[VAL_7:.*]] = llvm.load %[[VAL_6]] : !llvm.ptr -// CHECK: %[[VAL_8:.*]] = llvm.mul %[[VAL_3]], %[[VAL_5]] : i64 -// CHECK: %[[VAL_9:.*]] = llvm.add %[[VAL_8]], %[[VAL_7]] : i64 -// CHECK: %[[VAL_10:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0] : (!llvm.ptr<[[ACCESSOR1]]>) -> !llvm.ptr> -// CHECK: %[[VAL_11:.*]] = llvm.load %[[VAL_10]] : !llvm.ptr> -// CHECK: %[[VAL_12:.*]] = llvm.getelementptr inbounds %[[VAL_11]]{{\[}}%[[VAL_9]]] : (!llvm.ptr, i64) -> !llvm.ptr -// CHECK: %[[VAL_13:.*]] = llvm.insertvalue %[[VAL_12]], %[[VAL_2]][0] : !llvm.[[ATOM1]] -// CHECK: llvm.return %[[VAL_13]] : !llvm.[[ATOM1]] +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr, +// CHECK-SAME: %[[VAL_1:.*]]: !llvm.ptr) -> !llvm.struct<"class.sycl::_V1::atomic", {{.*}}> { +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.mlir.undef : !llvm.struct<"class.sycl::_V1::atomic", {{.*}}> +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.mlir.constant(0 : i64) : i64 +// CHECK-NEXT: %[[VAL_4:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 2, 0, 0, 0] : (!llvm.ptr) -> !llvm.ptr, !sycl_accessor_1_i32_ato_gb +// CHECK-NEXT: %[[VAL_5:.*]] = llvm.load %[[VAL_4]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_6:.*]] = llvm.getelementptr inbounds %[[VAL_1]][0, 0, 0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::id.1", {{.*}}> +// CHECK-NEXT: %[[VAL_7:.*]] = llvm.load %[[VAL_6]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_8:.*]] = llvm.mul %[[VAL_3]], %[[VAL_5]] : i64 +// CHECK-NEXT: %[[VAL_9:.*]] = llvm.add %[[VAL_8]], %[[VAL_7]] : i64 +// CHECK-NEXT: %[[VAL_10:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0] : (!llvm.ptr) -> !llvm.ptr, !sycl_accessor_1_i32_ato_gb +// CHECK-NEXT: %[[VAL_11:.*]] = llvm.load %[[VAL_10]] : !llvm.ptr -> !llvm.ptr<1> +// CHECK-NEXT: %[[VAL_12:.*]] = llvm.getelementptr inbounds %[[VAL_11]]{{\[}}%[[VAL_9]]] : (!llvm.ptr<1>, i64) -> !llvm.ptr<1>, i32 +// CHECK-NEXT: %[[VAL_13:.*]] = llvm.insertvalue %[[VAL_12]], %[[VAL_2]][0] : !llvm.struct<"class.sycl::_V1::atomic", {{.*}}> +// CHECK-NEXT: llvm.return %[[VAL_13]] : !llvm.struct<"class.sycl::_V1::atomic", {{.*}}> func.func @test(%acc: memref, %idx: memref) -> !sycl_atomic_i32_glo { %0 = sycl.accessor.subscript %acc[%idx] { ArgumentTypes = [memref, memref], FunctionName = @"operator[]", MangledFunctionName = @"operator[]", TypeName = @"id" } : (memref, memref) -> !sycl_atomic_i32_glo return %0 : !sycl_atomic_i32_glo @@ -462,11 +448,10 @@ func.func @test(%acc: memref, %idx: memref // CHECK-LABEL: llvm.func @test( -// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[NDRANGE1:.*]]>) -> !llvm.[[RANGE1]] { -// CHECK-NEXT: %[[VAL_1:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0] : (!llvm.ptr<[[NDRANGE1]]>) -> !llvm.ptr<[[RANGE1]]> -// CHECK-NEXT: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] : !llvm.ptr<[[RANGE1]]> -// CHECK-NEXT: llvm.return %[[VAL_2]] : !llvm.[[RANGE1]] -// CHECK-NEXT: } +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr) -> !llvm.struct<"class.sycl::_V1::range.1", {{.*}}> { +// CHECK-NEXT: %[[VAL_1:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::nd_range.1", {{.*}}> +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] : !llvm.ptr -> !llvm.struct<"class.sycl::_V1::range.1", {{.*}}> +// CHECK-NEXT: llvm.return %[[VAL_2]] : !llvm.struct<"class.sycl::_V1::range.1", {{.*}}> func.func @test(%nd: memref) -> !sycl_range_1_ { %0 = sycl.nd_range.get_global_range(%nd) { ArgumentTypes = [memref], FunctionName = @"get_global_range", MangledFunctionName = @"get_global_range", TypeName = @"nd_range" } : (memref) -> !sycl_range_1_ return %0 : !sycl_range_1_ @@ -479,11 +464,10 @@ func.func @test(%nd: memref) -> !sycl_range_1_ { !sycl_nd_range_1_ = !sycl.nd_range<[1], (!sycl_range_1_, !sycl_range_1_, !sycl_id_1_)> // CHECK-LABEL: llvm.func @test( -// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[NDRANGE1]]>) -> !llvm.[[RANGE1]] { -// CHECK-NEXT: %[[VAL_1:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1] : (!llvm.ptr<[[NDRANGE1]]>) -> !llvm.ptr<[[RANGE1]]> -// CHECK-NEXT: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] : !llvm.ptr<[[RANGE1]]> -// CHECK-NEXT: llvm.return %[[VAL_2]] : !llvm.[[RANGE1]] -// CHECK-NEXT: } +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr) -> !llvm.struct<"class.sycl::_V1::range.1", {{.*}}> { +// CHECK-NEXT: %[[VAL_1:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::nd_range.1", {{.*}}> +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] : !llvm.ptr -> !llvm.struct<"class.sycl::_V1::range.1", {{.*}}> +// CHECK-NEXT: llvm.return %[[VAL_2]] : !llvm.struct<"class.sycl::_V1::range.1", {{.*}}> func.func @test(%nd: memref) -> !sycl_range_1_ { %0 = sycl.nd_range.get_local_range(%nd) { ArgumentTypes = [memref], FunctionName = @"get_local_range", MangledFunctionName = @"get_local_range", TypeName = @"nd_range" } : (memref) -> !sycl_range_1_ return %0 : !sycl_range_1_ @@ -496,33 +480,32 @@ func.func @test(%nd: memref) -> !sycl_range_1_ { !sycl_nd_range_3_ = !sycl.nd_range<[3], (!sycl_range_3_, !sycl_range_3_, !sycl_id_3_)> // CHECK-LABEL: llvm.func @test( -// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[NDRANGE3:.*]]>) -> !llvm.[[RANGE3]] { -// CHECK-NEXT: %[[VAL_1:.*]] = llvm.mlir.constant(1 : i64) : i64 -// CHECK-NEXT: %[[VAL_2:.*]] = llvm.alloca %[[VAL_1]] x !llvm.[[RANGE3]] : (i64) -> !llvm.ptr<[[RANGE3]]> -// CHECK-NEXT: %[[VAL_3:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 0, 0] : (!llvm.ptr<[[NDRANGE3]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_4:.*]] = llvm.load %[[VAL_3]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_5:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0, 0, 0] : (!llvm.ptr<[[NDRANGE3]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_6:.*]] = llvm.load %[[VAL_5]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_7:.*]] = llvm.udiv %[[VAL_4]], %[[VAL_6]] : i64 -// CHECK-NEXT: %[[VAL_8:.*]] = llvm.getelementptr inbounds %[[VAL_2]][0, 0, 0, 0] : (!llvm.ptr<[[RANGE3]]>) -> !llvm.ptr -// CHECK-NEXT: llvm.store %[[VAL_7]], %[[VAL_8]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_9:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 0, 1] : (!llvm.ptr<[[NDRANGE3]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_10:.*]] = llvm.load %[[VAL_9]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_11:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0, 0, 1] : (!llvm.ptr<[[NDRANGE3]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_12:.*]] = llvm.load %[[VAL_11]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_13:.*]] = llvm.udiv %[[VAL_10]], %[[VAL_12]] : i64 -// CHECK-NEXT: %[[VAL_14:.*]] = llvm.getelementptr inbounds %[[VAL_2]][0, 0, 0, 1] : (!llvm.ptr<[[RANGE3]]>) -> !llvm.ptr -// CHECK-NEXT: llvm.store %[[VAL_13]], %[[VAL_14]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_15:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 0, 2] : (!llvm.ptr<[[NDRANGE3]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_16:.*]] = llvm.load %[[VAL_15]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_17:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0, 0, 2] : (!llvm.ptr<[[NDRANGE3]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_18:.*]] = llvm.load %[[VAL_17]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_19:.*]] = llvm.udiv %[[VAL_16]], %[[VAL_18]] : i64 -// CHECK-NEXT: %[[VAL_20:.*]] = llvm.getelementptr inbounds %[[VAL_2]][0, 0, 0, 2] : (!llvm.ptr<[[RANGE3]]>) -> !llvm.ptr -// CHECK-NEXT: llvm.store %[[VAL_19]], %[[VAL_20]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_21:.*]] = llvm.load %[[VAL_2]] : !llvm.ptr<[[RANGE3]]> -// CHECK-NEXT: llvm.return %[[VAL_21]] : !llvm.[[RANGE3]] -// CHECK-NEXT: } +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr) -> !llvm.struct<"class.sycl::_V1::range.3", {{.*}}> { +// CHECK-NEXT: %[[VAL_1:.*]] = llvm.mlir.constant(1 : i64) : i64 +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.alloca %[[VAL_1]] x !llvm.struct<"class.sycl::_V1::range.3", {{.*}}> : (i64) -> !llvm.ptr +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::nd_range.3", {{.*}}> +// CHECK-NEXT: %[[VAL_4:.*]] = llvm.load %[[VAL_3]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_5:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0, 0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::nd_range.3", {{.*}}> +// CHECK-NEXT: %[[VAL_6:.*]] = llvm.load %[[VAL_5]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_7:.*]] = llvm.udiv %[[VAL_4]], %[[VAL_6]] : i64 +// CHECK-NEXT: %[[VAL_8:.*]] = llvm.getelementptr inbounds %[[VAL_2]][0, 0, 0, 0] : (!llvm.ptr) -> !llvm.ptr, i64 +// CHECK-NEXT: llvm.store %[[VAL_7]], %[[VAL_8]] : i64, !llvm.ptr +// CHECK-NEXT: %[[VAL_9:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::nd_range.3", {{.*}}> +// CHECK-NEXT: %[[VAL_10:.*]] = llvm.load %[[VAL_9]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_11:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0, 0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::nd_range.3", {{.*}}> +// CHECK-NEXT: %[[VAL_12:.*]] = llvm.load %[[VAL_11]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_13:.*]] = llvm.udiv %[[VAL_10]], %[[VAL_12]] : i64 +// CHECK-NEXT: %[[VAL_14:.*]] = llvm.getelementptr inbounds %[[VAL_2]][0, 0, 0, 1] : (!llvm.ptr) -> !llvm.ptr, i64 +// CHECK-NEXT: llvm.store %[[VAL_13]], %[[VAL_14]] : i64, !llvm.ptr +// CHECK-NEXT: %[[VAL_15:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::nd_range.3", {{.*}}> +// CHECK-NEXT: %[[VAL_16:.*]] = llvm.load %[[VAL_15]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_17:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0, 0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::nd_range.3", {{.*}}> +// CHECK-NEXT: %[[VAL_18:.*]] = llvm.load %[[VAL_17]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_19:.*]] = llvm.udiv %[[VAL_16]], %[[VAL_18]] : i64 +// CHECK-NEXT: %[[VAL_20:.*]] = llvm.getelementptr inbounds %[[VAL_2]][0, 0, 0, 2] : (!llvm.ptr) -> !llvm.ptr, i64 +// CHECK-NEXT: llvm.store %[[VAL_19]], %[[VAL_20]] : i64, !llvm.ptr +// CHECK-NEXT: %[[VAL_21:.*]] = llvm.load %[[VAL_2]] : !llvm.ptr -> !llvm.struct<"class.sycl::_V1::range.3", {{.*}}> +// CHECK-NEXT: llvm.return %[[VAL_21]] : !llvm.struct<"class.sycl::_V1::range.3", {{.*}}> func.func @test(%nd: memref) -> !sycl_range_3_ { %0 = sycl.nd_range.get_group_range(%nd) { ArgumentTypes = [memref], FunctionName = @"get_group_range", MangledFunctionName = @"get_group_range", TypeName = @"nd_range" } : (memref) -> !sycl_range_3_ return %0 : !sycl_range_3_ @@ -536,11 +519,11 @@ func.func @test(%nd: memref) -> !sycl_range_3_ { !sycl_item_1_ = !sycl.item<[1, false], (!sycl_item_base_1_)> // CHECK-LABEL: llvm.func @test( -// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[ITEM1:.*]]>) -> !llvm.[[ID1]] { -// CHECK-NEXT: %[[VAL_1:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 1] : (!llvm.ptr<[[ITEM1]]>) -> !llvm.ptr<[[ID1]]> -// CHECK-NEXT: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] : !llvm.ptr<[[ID1]]> -// CHECK-NEXT: llvm.return %[[VAL_2]] : !llvm.[[ID1]] -// CHECK-NEXT: } +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr) -> !llvm.struct<"class.sycl::_V1::id.1", {{.*}}> { +// CHECK-NEXT: %[[VAL_1:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::item.1.false", {{.*}}> +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] : !llvm.ptr -> !llvm.struct<"class.sycl::_V1::id.1", {{.*}}> +// CHECK-NEXT: llvm.return %[[VAL_2]] : !llvm.struct<"class.sycl::_V1::id.1", {{.*}}> +// CHECK-NEXT: } func.func @test(%item: memref) -> !sycl_id_1_ { %0 = sycl.item.get_id(%item) { ArgumentTypes = [memref], FunctionName = @"get_id", MangledFunctionName = @"get_id", TypeName = @"item" } : (memref) -> !sycl_id_1_ return %0 : !sycl_id_1_ @@ -554,12 +537,12 @@ func.func @test(%item: memref) -> !sycl_id_1_ { !sycl_item_1_ = !sycl.item<[1, false], (!sycl_item_base_1_)> // CHECK-LABEL: llvm.func @test( -// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[ITEM1]]>, +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr, // CHECK-SAME: %[[VAL_1:.*]]: i32) -> i64 { -// CHECK-NEXT: %[[VAL_2:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 1, 0, 0, %[[VAL_1]]] : (!llvm.ptr<[[ITEM1]]>, i32) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_3:.*]] = llvm.load %[[VAL_2]] : !llvm.ptr -// CHECK-NEXT: llvm.return %[[VAL_3]] : i64 -// CHECK-NEXT: } +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 1, 0, 0, %[[VAL_1]]] : (!llvm.ptr, i32) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::item.1.false", {{.*}}> +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.load %[[VAL_2]] : !llvm.ptr -> i64 +// CHECK-NEXT: llvm.return %[[VAL_3]] : i64 +// CHECK-NEXT: } func.func @test(%item: memref, %i: i32) -> i64 { %0 = sycl.item.get_id(%item, %i) { ArgumentTypes = [memref, i32], FunctionName = @"get_id", MangledFunctionName = @"get_id", TypeName = @"item" } : (memref, i32) -> i64 return %0 : i64 @@ -573,12 +556,12 @@ func.func @test(%item: memref, %i: i32) -> i64 { !sycl_item_1_ = !sycl.item<[1, false], (!sycl_item_base_1_)> // CHECK-LABEL: llvm.func @test( -// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[ITEM1]]>) -> i64 { -// CHECK: %[[VAL_1:.*]] = llvm.mlir.constant(0 : i32) : i32 -// CHECK: %[[VAL_2:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 1, 0, 0, %[[VAL_1]]] : (!llvm.ptr<[[ITEM1]]>, i32) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_3:.*]] = llvm.load %[[VAL_2]] : !llvm.ptr -// CHECK-NEXT: llvm.return %[[VAL_3]] : i64 -// CHECK-NEXT: } +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr) -> i64 { +// CHECK-NEXT: %[[VAL_1:.*]] = llvm.mlir.constant(0 : i32) : i32 +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 1, 0, 0, %[[VAL_1]]] : (!llvm.ptr, i32) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::item.1.false", {{.*}}> +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.load %[[VAL_2]] : !llvm.ptr -> i64 +// CHECK-NEXT: llvm.return %[[VAL_3]] : i64 +// CHECK-NEXT: } func.func @test(%item: memref) -> i64 { %0 = sycl.item.get_id(%item) { ArgumentTypes = [memref], FunctionName = @"operator unsigned long", MangledFunctionName = @"operator unsigned long", TypeName = @"item" } : (memref) -> i64 return %0 : i64 @@ -592,11 +575,11 @@ func.func @test(%item: memref) -> i64 { !sycl_item_1_ = !sycl.item<[1, false], (!sycl_item_base_1_)> // CHECK-LABEL: llvm.func @test( -// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[ITEM1]]>) -> !llvm.[[RANGE1]] { -// CHECK-NEXT: %[[VAL_1:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0] : (!llvm.ptr<[[ITEM1]]>) -> !llvm.ptr<[[RANGE1]]> -// CHECK-NEXT: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] : !llvm.ptr<[[RANGE1]]> -// CHECK-NEXT: llvm.return %[[VAL_2]] : !llvm.[[RANGE1]] -// CHECK-NEXT: } +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr) -> !llvm.struct<"class.sycl::_V1::range.1", {{.*}}> { +// CHECK-NEXT: %[[VAL_1:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::item.1.false", {{.*}}> +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] : !llvm.ptr -> !llvm.struct<"class.sycl::_V1::range.1", {{.*}}> +// CHECK-NEXT: llvm.return %[[VAL_2]] : !llvm.struct<"class.sycl::_V1::range.1", {{.*}}> +// CHECK-NEXT: } func.func @test(%item: memref) -> !sycl_range_1_ { %0 = sycl.item.get_range(%item) { ArgumentTypes = [memref], FunctionName = @"get_range", MangledFunctionName = @"get_range", TypeName = @"item" } : (memref) -> !sycl_range_1_ return %0 : !sycl_range_1_ @@ -610,12 +593,12 @@ func.func @test(%item: memref) -> !sycl_range_1_ { !sycl_item_1_ = !sycl.item<[1, false], (!sycl_item_base_1_)> // CHECK-LABEL: llvm.func @test( -// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[ITEM1]]>, +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr, // CHECK-SAME: %[[VAL_1:.*]]: i32) -> i64 { -// CHECK-NEXT: %[[VAL_2:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 0, 0, %[[VAL_1]]] : (!llvm.ptr<[[ITEM1]]>, i32) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_3:.*]] = llvm.load %[[VAL_2]] : !llvm.ptr -// CHECK-NEXT: llvm.return %[[VAL_3]] : i64 -// CHECK-NEXT: } +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 0, 0, %[[VAL_1]]] : (!llvm.ptr, i32) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::item.1.false", {{.*}}> +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.load %[[VAL_2]] : !llvm.ptr -> i64 +// CHECK-NEXT: llvm.return %[[VAL_3]] : i64 +// CHECK-NEXT: } func.func @test(%item: memref, %i: i32) -> i64 { %0 = sycl.item.get_range(%item, %i) { ArgumentTypes = [memref, i32], FunctionName = @"get_range", MangledFunctionName = @"get_range", TypeName = @"item" } : (memref, i32) -> i64 return %0 : i64 @@ -637,52 +620,52 @@ func.func @test(%item: memref, %i: i32) -> i64 { !sycl_item_3_ = !sycl.item<[3, false], (!sycl_item_base_3_)> // CHECK-LABEL: llvm.func @test_1( -// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[ITEM1]]>) -> i64 { -// CHECK-NEXT: %[[VAL_1:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 1, 0, 0, 0] : (!llvm.ptr<[[ITEM1]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] : !llvm.ptr -// CHECK-NEXT: llvm.return %[[VAL_2]] : i64 -// CHECK-NEXT: } +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr) -> i64 { +// CHECK-NEXT: %[[VAL_1:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 1, 0, 0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::item.1.false", {{.*}}> +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] : !llvm.ptr -> i64 +// CHECK-NEXT: llvm.return %[[VAL_2]] : i64 +// CHECK-NEXT: } func.func @test_1(%item: memref) -> i64 { %0 = sycl.item.get_linear_id(%item) { ArgumentTypes = [memref], FunctionName = @"get_linear_id", MangledFunctionName = @"get_linear_id", TypeName = @"item" } : (memref) -> i64 return %0 : i64 } // CHECK-LABEL: llvm.func @test_2( -// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[ITEM2:.*]]>) -> i64 { -// CHECK-NEXT: %[[VAL_1:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 1, 0, 0, 0] : (!llvm.ptr<[[ITEM2]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_3:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 0, 0, 1] : (!llvm.ptr<[[ITEM2]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_4:.*]] = llvm.load %[[VAL_3]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_5:.*]] = llvm.mul %[[VAL_2]], %[[VAL_4]] : i64 -// CHECK-NEXT: %[[VAL_6:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 1, 0, 0, 1] : (!llvm.ptr<[[ITEM2]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_7:.*]] = llvm.load %[[VAL_6]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_8:.*]] = llvm.add %[[VAL_5]], %[[VAL_7]] : i64 -// CHECK-NEXT: llvm.return %[[VAL_8]] : i64 -// CHECK-NEXT: } +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr) -> i64 { +// CHECK-NEXT: %[[VAL_1:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 1, 0, 0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::item.2.false", {{.*}}> +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 0, 0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::item.2.false", {{.*}}> +// CHECK-NEXT: %[[VAL_4:.*]] = llvm.load %[[VAL_3]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_5:.*]] = llvm.mul %[[VAL_2]], %[[VAL_4]] : i64 +// CHECK-NEXT: %[[VAL_6:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 1, 0, 0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::item.2.false", {{.*}}> +// CHECK-NEXT: %[[VAL_7:.*]] = llvm.load %[[VAL_6]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_8:.*]] = llvm.add %[[VAL_5]], %[[VAL_7]] : i64 +// CHECK-NEXT: llvm.return %[[VAL_8]] : i64 +// CHECK-NEXT: } func.func @test_2(%item: memref) -> i64 { %0 = sycl.item.get_linear_id(%item) { ArgumentTypes = [memref], FunctionName = @"get_linear_id", MangledFunctionName = @"get_linear_id", TypeName = @"item" } : (memref) -> i64 return %0 : i64 } // CHECK-LABEL: llvm.func @test_3( -// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[ITEM3:.*]]>) -> i64 { -// CHECK-NEXT: %[[VAL_1:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 1, 0, 0, 0] : (!llvm.ptr<[[ITEM3]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_3:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 0, 0, 1] : (!llvm.ptr<[[ITEM3]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_4:.*]] = llvm.load %[[VAL_3]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_5:.*]] = llvm.mul %[[VAL_2]], %[[VAL_4]] : i64 -// CHECK-NEXT: %[[VAL_6:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 0, 0, 2] : (!llvm.ptr<[[ITEM3]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_7:.*]] = llvm.load %[[VAL_6]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_8:.*]] = llvm.mul %[[VAL_5]], %[[VAL_7]] : i64 -// CHECK-NEXT: %[[VAL_9:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 1, 0, 0, 1] : (!llvm.ptr<[[ITEM3]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_10:.*]] = llvm.load %[[VAL_9]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_11:.*]] = llvm.mul %[[VAL_10]], %[[VAL_7]] : i64 -// CHECK-NEXT: %[[VAL_12:.*]] = llvm.add %[[VAL_8]], %[[VAL_11]] : i64 -// CHECK-NEXT: %[[VAL_13:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 1, 0, 0, 2] : (!llvm.ptr<[[ITEM3]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_14:.*]] = llvm.load %[[VAL_13]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_15:.*]] = llvm.add %[[VAL_12]], %[[VAL_14]] : i64 -// CHECK-NEXT: llvm.return %[[VAL_15]] : i64 -// CHECK-NEXT: } +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr) -> i64 { +// CHECK-NEXT: %[[VAL_1:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 1, 0, 0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::item.3.false", {{.*}}> +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 0, 0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::item.3.false", {{.*}}> +// CHECK-NEXT: %[[VAL_4:.*]] = llvm.load %[[VAL_3]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_5:.*]] = llvm.mul %[[VAL_2]], %[[VAL_4]] : i64 +// CHECK-NEXT: %[[VAL_6:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 0, 0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::item.3.false", {{.*}}> +// CHECK-NEXT: %[[VAL_7:.*]] = llvm.load %[[VAL_6]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_8:.*]] = llvm.mul %[[VAL_5]], %[[VAL_7]] : i64 +// CHECK-NEXT: %[[VAL_9:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 1, 0, 0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::item.3.false", {{.*}}> +// CHECK-NEXT: %[[VAL_10:.*]] = llvm.load %[[VAL_9]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_11:.*]] = llvm.mul %[[VAL_10]], %[[VAL_7]] : i64 +// CHECK-NEXT: %[[VAL_12:.*]] = llvm.add %[[VAL_8]], %[[VAL_11]] : i64 +// CHECK-NEXT: %[[VAL_13:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 1, 0, 0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::item.3.false", {{.*}}> +// CHECK-NEXT: %[[VAL_14:.*]] = llvm.load %[[VAL_13]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_15:.*]] = llvm.add %[[VAL_12]], %[[VAL_14]] : i64 +// CHECK-NEXT: llvm.return %[[VAL_15]] : i64 +// CHECK-NEXT: } func.func @test_3(%item: memref) -> i64 { %0 = sycl.item.get_linear_id(%item) { ArgumentTypes = [memref], FunctionName = @"get_linear_id", MangledFunctionName = @"get_linear_id", TypeName = @"item" } : (memref) -> i64 return %0 : i64 @@ -704,70 +687,70 @@ func.func @test_3(%item: memref) -> i64 { !sycl_item_3_ = !sycl.item<[3, true], (!sycl_item_base_3_)> // CHECK-LABEL: llvm.func @test_1( -// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[ITEM1:.*]]>) -> i64 { -// CHECK-NEXT: %[[VAL_1:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 1, 0, 0, 0] : (!llvm.ptr<[[ITEM1]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_3:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 2, 0, 0, 0] : (!llvm.ptr<[[ITEM1]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_4:.*]] = llvm.load %[[VAL_3]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_5:.*]] = llvm.sub %[[VAL_2]], %[[VAL_4]] : i64 -// CHECK-NEXT: llvm.return %[[VAL_5]] : i64 -// CHECK-NEXT: } +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr) -> i64 { +// CHECK-NEXT: %[[VAL_1:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 1, 0, 0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::item.1.true", {{.*}}> +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 2, 0, 0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::item.1.true", {{.*}}> +// CHECK-NEXT: %[[VAL_4:.*]] = llvm.load %[[VAL_3]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_5:.*]] = llvm.sub %[[VAL_2]], %[[VAL_4]] : i64 +// CHECK-NEXT: llvm.return %[[VAL_5]] : i64 +// CHECK-NEXT: } func.func @test_1(%item: memref) -> i64 { %0 = sycl.item.get_linear_id(%item) { ArgumentTypes = [memref], FunctionName = @"get_linear_id", MangledFunctionName = @"get_linear_id", TypeName = @"item" } : (memref) -> i64 return %0 : i64 } // CHECK-LABEL: llvm.func @test_2( -// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[ITEM2:.*]]>) -> i64 { -// CHECK-NEXT: %[[VAL_1:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 1, 0, 0, 0] : (!llvm.ptr<[[ITEM2]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_3:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 2, 0, 0, 0] : (!llvm.ptr<[[ITEM2]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_4:.*]] = llvm.load %[[VAL_3]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_5:.*]] = llvm.sub %[[VAL_2]], %[[VAL_4]] : i64 -// CHECK-NEXT: %[[VAL_6:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 0, 0, 1] : (!llvm.ptr<[[ITEM2]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_7:.*]] = llvm.load %[[VAL_6]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_8:.*]] = llvm.mul %[[VAL_5]], %[[VAL_7]] : i64 -// CHECK-NEXT: %[[VAL_9:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 1, 0, 0, 1] : (!llvm.ptr<[[ITEM2]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_10:.*]] = llvm.load %[[VAL_9]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_11:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 2, 0, 0, 1] : (!llvm.ptr<[[ITEM2]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_12:.*]] = llvm.load %[[VAL_11]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_13:.*]] = llvm.sub %[[VAL_10]], %[[VAL_12]] : i64 -// CHECK-NEXT: %[[VAL_14:.*]] = llvm.add %[[VAL_8]], %[[VAL_13]] : i64 -// CHECK-NEXT: llvm.return %[[VAL_14]] : i64 -// CHECK-NEXT: } +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr) -> i64 { +// CHECK-NEXT: %[[VAL_1:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 1, 0, 0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::item.2.true", {{.*}}> +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 2, 0, 0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::item.2.true", {{.*}}> +// CHECK-NEXT: %[[VAL_4:.*]] = llvm.load %[[VAL_3]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_5:.*]] = llvm.sub %[[VAL_2]], %[[VAL_4]] : i64 +// CHECK-NEXT: %[[VAL_6:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 0, 0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::item.2.true", {{.*}}> +// CHECK-NEXT: %[[VAL_7:.*]] = llvm.load %[[VAL_6]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_8:.*]] = llvm.mul %[[VAL_5]], %[[VAL_7]] : i64 +// CHECK-NEXT: %[[VAL_9:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 1, 0, 0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::item.2.true", {{.*}}> +// CHECK-NEXT: %[[VAL_10:.*]] = llvm.load %[[VAL_9]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_11:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 2, 0, 0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::item.2.true", {{.*}}> +// CHECK-NEXT: %[[VAL_12:.*]] = llvm.load %[[VAL_11]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_13:.*]] = llvm.sub %[[VAL_10]], %[[VAL_12]] : i64 +// CHECK-NEXT: %[[VAL_14:.*]] = llvm.add %[[VAL_8]], %[[VAL_13]] : i64 +// CHECK-NEXT: llvm.return %[[VAL_14]] : i64 +// CHECK-NEXT: } func.func @test_2(%item: memref) -> i64 { %0 = sycl.item.get_linear_id(%item) { ArgumentTypes = [memref], FunctionName = @"get_linear_id", MangledFunctionName = @"get_linear_id", TypeName = @"item" } : (memref) -> i64 return %0 : i64 } // CHECK-LABEL: llvm.func @test_3( -// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[ITEM3:.*]]>) -> i64 { -// CHECK-NEXT: %[[VAL_1:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 1, 0, 0, 0] : (!llvm.ptr<[[ITEM3]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_3:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 2, 0, 0, 0] : (!llvm.ptr<[[ITEM3]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_4:.*]] = llvm.load %[[VAL_3]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_5:.*]] = llvm.sub %[[VAL_2]], %[[VAL_4]] : i64 -// CHECK-NEXT: %[[VAL_6:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 0, 0, 1] : (!llvm.ptr<[[ITEM3]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_7:.*]] = llvm.load %[[VAL_6]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_8:.*]] = llvm.mul %[[VAL_5]], %[[VAL_7]] : i64 -// CHECK-NEXT: %[[VAL_9:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 0, 0, 2] : (!llvm.ptr<[[ITEM3]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_10:.*]] = llvm.load %[[VAL_9]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_11:.*]] = llvm.mul %[[VAL_8]], %[[VAL_10]] : i64 -// CHECK-NEXT: %[[VAL_12:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 1, 0, 0, 1] : (!llvm.ptr<[[ITEM3]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_13:.*]] = llvm.load %[[VAL_12]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_14:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 2, 0, 0, 1] : (!llvm.ptr<[[ITEM3]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_15:.*]] = llvm.load %[[VAL_14]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_16:.*]] = llvm.sub %[[VAL_13]], %[[VAL_15]] : i64 -// CHECK-NEXT: %[[VAL_17:.*]] = llvm.mul %[[VAL_16]], %[[VAL_10]] : i64 -// CHECK-NEXT: %[[VAL_18:.*]] = llvm.add %[[VAL_11]], %[[VAL_17]] : i64 -// CHECK-NEXT: %[[VAL_19:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 1, 0, 0, 2] : (!llvm.ptr<[[ITEM3]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_20:.*]] = llvm.load %[[VAL_19]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_21:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 2, 0, 0, 2] : (!llvm.ptr<[[ITEM3]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_22:.*]] = llvm.load %[[VAL_21]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_23:.*]] = llvm.sub %[[VAL_20]], %[[VAL_22]] : i64 -// CHECK-NEXT: %[[VAL_24:.*]] = llvm.add %[[VAL_18]], %[[VAL_23]] : i64 -// CHECK-NEXT: llvm.return %[[VAL_24]] : i64 -// CHECK-NEXT: } +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr) -> i64 { +// CHECK-NEXT: %[[VAL_1:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 1, 0, 0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::item.3.true", {{.*}}> +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 2, 0, 0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::item.3.true", {{.*}}> +// CHECK-NEXT: %[[VAL_4:.*]] = llvm.load %[[VAL_3]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_5:.*]] = llvm.sub %[[VAL_2]], %[[VAL_4]] : i64 +// CHECK-NEXT: %[[VAL_6:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 0, 0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::item.3.true", {{.*}}> +// CHECK-NEXT: %[[VAL_7:.*]] = llvm.load %[[VAL_6]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_8:.*]] = llvm.mul %[[VAL_5]], %[[VAL_7]] : i64 +// CHECK-NEXT: %[[VAL_9:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 0, 0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::item.3.true", {{.*}}> +// CHECK-NEXT: %[[VAL_10:.*]] = llvm.load %[[VAL_9]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_11:.*]] = llvm.mul %[[VAL_8]], %[[VAL_10]] : i64 +// CHECK-NEXT: %[[VAL_12:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 1, 0, 0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::item.3.true", {{.*}}> +// CHECK-NEXT: %[[VAL_13:.*]] = llvm.load %[[VAL_12]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_14:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 2, 0, 0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::item.3.true", {{.*}}> +// CHECK-NEXT: %[[VAL_15:.*]] = llvm.load %[[VAL_14]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_16:.*]] = llvm.sub %[[VAL_13]], %[[VAL_15]] : i64 +// CHECK-NEXT: %[[VAL_17:.*]] = llvm.mul %[[VAL_16]], %[[VAL_10]] : i64 +// CHECK-NEXT: %[[VAL_18:.*]] = llvm.add %[[VAL_11]], %[[VAL_17]] : i64 +// CHECK-NEXT: %[[VAL_19:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 1, 0, 0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::item.3.true", {{.*}}> +// CHECK-NEXT: %[[VAL_20:.*]] = llvm.load %[[VAL_19]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_21:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 2, 0, 0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::item.3.true", {{.*}}> +// CHECK-NEXT: %[[VAL_22:.*]] = llvm.load %[[VAL_21]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_23:.*]] = llvm.sub %[[VAL_20]], %[[VAL_22]] : i64 +// CHECK-NEXT: %[[VAL_24:.*]] = llvm.add %[[VAL_18]], %[[VAL_23]] : i64 +// CHECK-NEXT: llvm.return %[[VAL_24]] : i64 +// CHECK-NEXT: } func.func @test_3(%item: memref) -> i64 { %0 = sycl.item.get_linear_id(%item) { ArgumentTypes = [memref], FunctionName = @"get_linear_id", MangledFunctionName = @"get_linear_id", TypeName = @"item" } : (memref) -> i64 return %0 : i64 @@ -785,11 +768,11 @@ func.func @test_3(%item: memref) -> i64 { !sycl_nd_item_1_ = !sycl.nd_item<[1], (!sycl_item_1_, !sycl_item_1_1_, !sycl_group_1_)> // CHECK-LABEL: llvm.func @test( -// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[NDITEM1:.*]]>) -> !llvm.[[ID1]] { -// CHECK-NEXT: %[[VAL_1:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 1] : (!llvm.ptr<[[NDITEM1]]>) -> !llvm.ptr<[[ID1]]> -// CHECK-NEXT: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] : !llvm.ptr<[[ID1]]> -// CHECK-NEXT: llvm.return %[[VAL_2]] : !llvm.[[ID1]] -// CHECK-NEXT: } +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr) -> !llvm.struct<"class.sycl::_V1::id.1", {{.*}}> { +// CHECK-NEXT: %[[VAL_1:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::nd_item.1", {{.*}}> +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] : !llvm.ptr -> !llvm.struct<"class.sycl::_V1::id.1", {{.*}}> +// CHECK-NEXT: llvm.return %[[VAL_2]] : !llvm.struct<"class.sycl::_V1::id.1", {{.*}}> +// CHECK-NEXT: } func.func @test(%nd: memref) -> !sycl_id_1_ { %0 = sycl.nd_item.get_global_id(%nd) { ArgumentTypes = [memref], FunctionName = @"get_global_id", MangledFunctionName = @"get_global_id", TypeName = @"nd_item" } : (memref) -> !sycl_id_1_ return %0 : !sycl_id_1_ @@ -807,12 +790,12 @@ func.func @test(%nd: memref) -> !sycl_id_1_ { !sycl_nd_item_1_ = !sycl.nd_item<[1], (!sycl_item_1_, !sycl_item_1_1_, !sycl_group_1_)> // CHECK-LABEL: llvm.func @test( -// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[NDITEM1]]>, +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr, // CHECK-SAME: %[[VAL_1:.*]]: i32) -> i64 { -// CHECK-NEXT: %[[VAL_2:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 1, 0, 0, %[[VAL_1]]] : (!llvm.ptr<[[NDITEM1]]>, i32) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_3:.*]] = llvm.load %[[VAL_2]] : !llvm.ptr -// CHECK-NEXT: llvm.return %[[VAL_3]] : i64 -// CHECK-NEXT: } +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 1, 0, 0, %[[VAL_1]]] : (!llvm.ptr, i32) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::nd_item.1", {{.*}}> +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.load %[[VAL_2]] : !llvm.ptr -> i64 +// CHECK-NEXT: llvm.return %[[VAL_3]] : i64 +// CHECK-NEXT: } func.func @test(%nd: memref, %i: i32) -> i64 { %0 = sycl.nd_item.get_global_id(%nd, %i) { ArgumentTypes = [memref, i32], FunctionName = @"get_global_id", MangledFunctionName = @"get_global_id", TypeName = @"nd_item" } : (memref, i32) -> i64 return %0 : i64 @@ -846,52 +829,52 @@ func.func @test(%nd: memref, %i: i32) -> i64 { !sycl_nd_item_3_ = !sycl.nd_item<[3], (!sycl_item_3_, !sycl_item_3_1_, !sycl_group_3_)> // CHECK-LABEL: llvm.func @test_1( -// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[NDITEM1]]>) -> i64 { -// CHECK-NEXT: %[[VAL_1:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 1, 0, 0, 0] : (!llvm.ptr<[[NDITEM1]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] : !llvm.ptr -// CHECK-NEXT: llvm.return %[[VAL_2]] : i64 -// CHECK-NEXT: } +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr) -> i64 { +// CHECK-NEXT: %[[VAL_1:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 1, 0, 0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::nd_item.1", {{.*}}> +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] : !llvm.ptr -> i64 +// CHECK-NEXT: llvm.return %[[VAL_2]] : i64 +// CHECK-NEXT: } func.func @test_1(%nd: memref) -> i64 { %0 = sycl.nd_item.get_global_linear_id(%nd) { ArgumentTypes = [memref], FunctionName = @"get_global_linear_id", MangledFunctionName = @"get_global_linear_id", TypeName = @"nd_item" } : (memref) -> i64 return %0 : i64 } // CHECK-LABEL: llvm.func @test_2( -// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[NDITEM2:.*]]>) -> i64 { -// CHECK-NEXT: %[[VAL_1:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 1, 0, 0, 0] : (!llvm.ptr<[[NDITEM2]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_3:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 0, 0, 0, 1] : (!llvm.ptr<[[NDITEM2]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_4:.*]] = llvm.load %[[VAL_3]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_5:.*]] = llvm.mul %[[VAL_2]], %[[VAL_4]] : i64 -// CHECK-NEXT: %[[VAL_6:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 1, 0, 0, 1] : (!llvm.ptr<[[NDITEM2]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_7:.*]] = llvm.load %[[VAL_6]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_8:.*]] = llvm.add %[[VAL_5]], %[[VAL_7]] : i64 -// CHECK-NEXT: llvm.return %[[VAL_8]] : i64 -// CHECK-NEXT: } +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr) -> i64 { +// CHECK-NEXT: %[[VAL_1:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 1, 0, 0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::nd_item.2", {{.*}}> +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 0, 0, 0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::nd_item.2", {{.*}}> +// CHECK-NEXT: %[[VAL_4:.*]] = llvm.load %[[VAL_3]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_5:.*]] = llvm.mul %[[VAL_2]], %[[VAL_4]] : i64 +// CHECK-NEXT: %[[VAL_6:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 1, 0, 0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::nd_item.2", {{.*}}> +// CHECK-NEXT: %[[VAL_7:.*]] = llvm.load %[[VAL_6]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_8:.*]] = llvm.add %[[VAL_5]], %[[VAL_7]] : i64 +// CHECK-NEXT: llvm.return %[[VAL_8]] : i64 +// CHECK-NEXT: } func.func @test_2(%nd: memref) -> i64 { %0 = sycl.nd_item.get_global_linear_id(%nd) { ArgumentTypes = [memref], FunctionName = @"get_global_linear_id", MangledFunctionName = @"get_global_linear_id", TypeName = @"nd_item" } : (memref) -> i64 return %0 : i64 } // CHECK-LABEL: llvm.func @test_3( -// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[NDITEM3:.*]]>) -> i64 { -// CHECK-NEXT: %[[VAL_1:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 1, 0, 0, 0] : (!llvm.ptr<[[NDITEM3]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_3:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 0, 0, 0, 1] : (!llvm.ptr<[[NDITEM3]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_4:.*]] = llvm.load %[[VAL_3]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_5:.*]] = llvm.mul %[[VAL_2]], %[[VAL_4]] : i64 -// CHECK-NEXT: %[[VAL_6:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 0, 0, 0, 2] : (!llvm.ptr<[[NDITEM3]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_7:.*]] = llvm.load %[[VAL_6]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_8:.*]] = llvm.mul %[[VAL_5]], %[[VAL_7]] : i64 -// CHECK-NEXT: %[[VAL_9:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 1, 0, 0, 1] : (!llvm.ptr<[[NDITEM3]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_10:.*]] = llvm.load %[[VAL_9]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_11:.*]] = llvm.mul %[[VAL_10]], %[[VAL_7]] : i64 -// CHECK-NEXT: %[[VAL_12:.*]] = llvm.add %[[VAL_8]], %[[VAL_11]] : i64 -// CHECK-NEXT: %[[VAL_13:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 1, 0, 0, 2] : (!llvm.ptr<[[NDITEM3]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_14:.*]] = llvm.load %[[VAL_13]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_15:.*]] = llvm.add %[[VAL_12]], %[[VAL_14]] : i64 -// CHECK-NEXT: llvm.return %[[VAL_15]] : i64 -// CHECK-NEXT: } +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr) -> i64 { +// CHECK-NEXT: %[[VAL_1:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 1, 0, 0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::nd_item.3", {{.*}}> +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 0, 0, 0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::nd_item.3", {{.*}}> +// CHECK-NEXT: %[[VAL_4:.*]] = llvm.load %[[VAL_3]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_5:.*]] = llvm.mul %[[VAL_2]], %[[VAL_4]] : i64 +// CHECK-NEXT: %[[VAL_6:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 0, 0, 0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::nd_item.3", {{.*}}> +// CHECK-NEXT: %[[VAL_7:.*]] = llvm.load %[[VAL_6]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_8:.*]] = llvm.mul %[[VAL_5]], %[[VAL_7]] : i64 +// CHECK-NEXT: %[[VAL_9:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 1, 0, 0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::nd_item.3", {{.*}}> +// CHECK-NEXT: %[[VAL_10:.*]] = llvm.load %[[VAL_9]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_11:.*]] = llvm.mul %[[VAL_10]], %[[VAL_7]] : i64 +// CHECK-NEXT: %[[VAL_12:.*]] = llvm.add %[[VAL_8]], %[[VAL_11]] : i64 +// CHECK-NEXT: %[[VAL_13:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 1, 0, 0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::nd_item.3", {{.*}}> +// CHECK-NEXT: %[[VAL_14:.*]] = llvm.load %[[VAL_13]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_15:.*]] = llvm.add %[[VAL_12]], %[[VAL_14]] : i64 +// CHECK-NEXT: llvm.return %[[VAL_15]] : i64 +// CHECK-NEXT: } func.func @test_3(%nd: memref) -> i64 { %0 = sycl.nd_item.get_global_linear_id(%nd) { ArgumentTypes = [memref], FunctionName = @"get_global_linear_id", MangledFunctionName = @"get_global_linear_id", TypeName = @"nd_item" } : (memref) -> i64 return %0 : i64 @@ -909,11 +892,11 @@ func.func @test_3(%nd: memref) -> i64 { !sycl_nd_item_1_ = !sycl.nd_item<[1], (!sycl_item_1_, !sycl_item_1_1_, !sycl_group_1_)> // CHECK-LABEL: llvm.func @test( -// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[NDITEM1]]>) -> !llvm.[[ID1]] { -// CHECK-NEXT: %[[VAL_1:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0, 1] : (!llvm.ptr<[[NDITEM1]]>) -> !llvm.ptr<[[ID1]]> -// CHECK-NEXT: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] : !llvm.ptr<[[ID1]]> -// CHECK-NEXT: llvm.return %[[VAL_2]] : !llvm.[[ID1]] -// CHECK-NEXT: } +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr) -> !llvm.struct<"class.sycl::_V1::id.1", {{.*}}> { +// CHECK-NEXT: %[[VAL_1:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::nd_item.1", {{.*}}> +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] : !llvm.ptr -> !llvm.struct<"class.sycl::_V1::id.1", {{.*}}> +// CHECK-NEXT: llvm.return %[[VAL_2]] : !llvm.struct<"class.sycl::_V1::id.1", {{.*}}> +// CHECK-NEXT: } func.func @test(%nd: memref) -> !sycl_id_1_ { %0 = sycl.nd_item.get_local_id(%nd) { ArgumentTypes = [memref], FunctionName = @"get_local_id", MangledFunctionName = @"get_local_id", TypeName = @"nd_item" } : (memref) -> !sycl_id_1_ return %0 : !sycl_id_1_ @@ -931,12 +914,12 @@ func.func @test(%nd: memref) -> !sycl_id_1_ { !sycl_nd_item_1_ = !sycl.nd_item<[1], (!sycl_item_1_, !sycl_item_1_1_, !sycl_group_1_)> // CHECK-LABEL: llvm.func @test( -// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[NDITEM1]]>, +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr, // CHECK-SAME: %[[VAL_1:.*]]: i32) -> i64 { -// CHECK-NEXT: %[[VAL_2:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0, 1, 0, 0, %[[VAL_1]]] : (!llvm.ptr<[[NDITEM1]]>, i32) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_3:.*]] = llvm.load %[[VAL_2]] : !llvm.ptr -// CHECK-NEXT: llvm.return %[[VAL_3]] : i64 -// CHECK-NEXT: } +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0, 1, 0, 0, %[[VAL_1]]] : (!llvm.ptr, i32) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::nd_item.1", {{.*}}> +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.load %[[VAL_2]] : !llvm.ptr -> i64 +// CHECK-NEXT: llvm.return %[[VAL_3]] : i64 +// CHECK-NEXT: } func.func @test(%nd: memref, %i: i32) -> i64 { %0 = sycl.nd_item.get_local_id(%nd, %i) { ArgumentTypes = [memref, i32], FunctionName = @"get_local_id", MangledFunctionName = @"get_local_id", TypeName = @"nd_item" } : (memref, i32) -> i64 return %0 : i64 @@ -970,52 +953,52 @@ func.func @test(%nd: memref, %i: i32) -> i64 { !sycl_nd_item_3_ = !sycl.nd_item<[3], (!sycl_item_3_, !sycl_item_3_1_, !sycl_group_3_)> // CHECK-LABEL: llvm.func @test_1( -// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[NDITEM1]]>) -> i64 { -// CHECK-NEXT: %[[VAL_1:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0, 1, 0, 0, 0] : (!llvm.ptr<[[NDITEM1]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] : !llvm.ptr -// CHECK-NEXT: llvm.return %[[VAL_2]] : i64 -// CHECK-NEXT: } +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr) -> i64 { +// CHECK-NEXT: %[[VAL_1:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0, 1, 0, 0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::nd_item.1", {{.*}}> +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] : !llvm.ptr -> i64 +// CHECK-NEXT: llvm.return %[[VAL_2]] : i64 +// CHECK-NEXT: } func.func @test_1(%nd: memref) -> i64 { %0 = sycl.nd_item.get_local_linear_id(%nd) { ArgumentTypes = [memref], FunctionName = @"get_local_linear_id", MangledFunctionName = @"get_local_linear_id", TypeName = @"nd_item" } : (memref) -> i64 return %0 : i64 } // CHECK-LABEL: llvm.func @test_2( -// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[NDITEM2]]>) -> i64 { -// CHECK-NEXT: %[[VAL_1:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0, 1, 0, 0, 0] : (!llvm.ptr<[[NDITEM2]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_3:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0, 0, 0, 0, 1] : (!llvm.ptr<[[NDITEM2]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_4:.*]] = llvm.load %[[VAL_3]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_5:.*]] = llvm.mul %[[VAL_2]], %[[VAL_4]] : i64 -// CHECK-NEXT: %[[VAL_6:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0, 1, 0, 0, 1] : (!llvm.ptr<[[NDITEM2]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_7:.*]] = llvm.load %[[VAL_6]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_8:.*]] = llvm.add %[[VAL_5]], %[[VAL_7]] : i64 -// CHECK-NEXT: llvm.return %[[VAL_8]] : i64 -// CHECK-NEXT: } +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr) -> i64 { +// CHECK-NEXT: %[[VAL_1:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0, 1, 0, 0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::nd_item.2", {{.*}}> +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0, 0, 0, 0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::nd_item.2", {{.*}}> +// CHECK-NEXT: %[[VAL_4:.*]] = llvm.load %[[VAL_3]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_5:.*]] = llvm.mul %[[VAL_2]], %[[VAL_4]] : i64 +// CHECK-NEXT: %[[VAL_6:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0, 1, 0, 0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::nd_item.2", {{.*}}> +// CHECK-NEXT: %[[VAL_7:.*]] = llvm.load %[[VAL_6]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_8:.*]] = llvm.add %[[VAL_5]], %[[VAL_7]] : i64 +// CHECK-NEXT: llvm.return %[[VAL_8]] : i64 +// CHECK-NEXT: } func.func @test_2(%nd: memref) -> i64 { %0 = sycl.nd_item.get_local_linear_id(%nd) { ArgumentTypes = [memref], FunctionName = @"get_local_linear_id", MangledFunctionName = @"get_local_linear_id", TypeName = @"nd_item" } : (memref) -> i64 return %0 : i64 } // CHECK-LABEL: llvm.func @test_3( -// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[NDITEM3]]>) -> i64 { -// CHECK-NEXT: %[[VAL_1:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0, 1, 0, 0, 0] : (!llvm.ptr<[[NDITEM3]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_3:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0, 0, 0, 0, 1] : (!llvm.ptr<[[NDITEM3]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_4:.*]] = llvm.load %[[VAL_3]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_5:.*]] = llvm.mul %[[VAL_2]], %[[VAL_4]] : i64 -// CHECK-NEXT: %[[VAL_6:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0, 0, 0, 0, 2] : (!llvm.ptr<[[NDITEM3]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_7:.*]] = llvm.load %[[VAL_6]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_8:.*]] = llvm.mul %[[VAL_5]], %[[VAL_7]] : i64 -// CHECK-NEXT: %[[VAL_9:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0, 1, 0, 0, 1] : (!llvm.ptr<[[NDITEM3]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_10:.*]] = llvm.load %[[VAL_9]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_11:.*]] = llvm.mul %[[VAL_10]], %[[VAL_7]] : i64 -// CHECK-NEXT: %[[VAL_12:.*]] = llvm.add %[[VAL_8]], %[[VAL_11]] : i64 -// CHECK-NEXT: %[[VAL_13:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0, 1, 0, 0, 2] : (!llvm.ptr<[[NDITEM3]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_14:.*]] = llvm.load %[[VAL_13]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_15:.*]] = llvm.add %[[VAL_12]], %[[VAL_14]] : i64 -// CHECK-NEXT: llvm.return %[[VAL_15]] : i64 -// CHECK-NEXT: } +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr) -> i64 { +// CHECK-NEXT: %[[VAL_1:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0, 1, 0, 0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::nd_item.3", {{.*}}> +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0, 0, 0, 0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::nd_item.3", {{.*}}> +// CHECK-NEXT: %[[VAL_4:.*]] = llvm.load %[[VAL_3]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_5:.*]] = llvm.mul %[[VAL_2]], %[[VAL_4]] : i64 +// CHECK-NEXT: %[[VAL_6:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0, 0, 0, 0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::nd_item.3", {{.*}}> +// CHECK-NEXT: %[[VAL_7:.*]] = llvm.load %[[VAL_6]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_8:.*]] = llvm.mul %[[VAL_5]], %[[VAL_7]] : i64 +// CHECK-NEXT: %[[VAL_9:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0, 1, 0, 0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::nd_item.3", {{.*}}> +// CHECK-NEXT: %[[VAL_10:.*]] = llvm.load %[[VAL_9]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_11:.*]] = llvm.mul %[[VAL_10]], %[[VAL_7]] : i64 +// CHECK-NEXT: %[[VAL_12:.*]] = llvm.add %[[VAL_8]], %[[VAL_11]] : i64 +// CHECK-NEXT: %[[VAL_13:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0, 1, 0, 0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::nd_item.3", {{.*}}> +// CHECK-NEXT: %[[VAL_14:.*]] = llvm.load %[[VAL_13]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_15:.*]] = llvm.add %[[VAL_12]], %[[VAL_14]] : i64 +// CHECK-NEXT: llvm.return %[[VAL_15]] : i64 +// CHECK-NEXT: } func.func @test_3(%nd: memref) -> i64 { %0 = sycl.nd_item.get_local_linear_id(%nd) { ArgumentTypes = [memref], FunctionName = @"get_local_linear_id", MangledFunctionName = @"get_local_linear_id", TypeName = @"nd_item" } : (memref) -> i64 return %0 : i64 @@ -1033,11 +1016,11 @@ func.func @test_3(%nd: memref) -> i64 { !sycl_nd_item_1_ = !sycl.nd_item<[1], (!sycl_item_1_, !sycl_item_1_1_, !sycl_group_1_)> // CHECK-LABEL: llvm.func @test( -// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[NDITEM1]]>) -> !llvm.[[GROUP1:.*]] { -// CHECK-NEXT: %[[VAL_1:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 2] : (!llvm.ptr<[[NDITEM1]]>) -> !llvm.ptr<[[GROUP1]]> -// CHECK-NEXT: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] : !llvm.ptr<[[GROUP1]]> -// CHECK-NEXT: llvm.return %[[VAL_2]] : !llvm.[[GROUP1]] -// CHECK-NEXT: } +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr) -> !llvm.struct<"class.sycl::_V1::group.1", {{.*}}> { +// CHECK-NEXT: %[[VAL_1:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::nd_item.1", {{.*}}> +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] : !llvm.ptr -> !llvm.struct<"class.sycl::_V1::group.1", {{.*}}> +// CHECK-NEXT: llvm.return %[[VAL_2]] : !llvm.struct<"class.sycl::_V1::group.1", {{.*}}> +// CHECK-NEXT: } func.func @test(%nd: memref) -> !sycl_group_1_ { %0 = sycl.nd_item.get_group(%nd) { ArgumentTypes = [memref], FunctionName = @"get_group", MangledFunctionName = @"get_group", TypeName = @"nd_item" } : (memref) -> !sycl_group_1_ return %0 : !sycl_group_1_ @@ -1055,12 +1038,12 @@ func.func @test(%nd: memref) -> !sycl_group_1_ { !sycl_nd_item_1_ = !sycl.nd_item<[1], (!sycl_item_1_, !sycl_item_1_1_, !sycl_group_1_)> // CHECK-LABEL: llvm.func @test( -// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[NDITEM1]]>, +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr, // CHECK-SAME: %[[VAL_1:.*]]: i32) -> i64 { -// CHECK-NEXT: %[[VAL_2:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 2, 3, 0, 0, %[[VAL_1]]] : (!llvm.ptr<[[NDITEM1]]>, i32) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_3:.*]] = llvm.load %[[VAL_2]] : !llvm.ptr -// CHECK-NEXT: llvm.return %[[VAL_3]] : i64 -// CHECK-NEXT: } +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 2, 3, 0, 0, %[[VAL_1]]] : (!llvm.ptr, i32) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::nd_item.1", {{.*}}> +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.load %[[VAL_2]] : !llvm.ptr -> i64 +// CHECK-NEXT: llvm.return %[[VAL_3]] : i64 +// CHECK-NEXT: } func.func @test(%nd: memref, %i: i32) -> i64 { %0 = sycl.nd_item.get_group(%nd, %i) { ArgumentTypes = [memref, i32], FunctionName = @"get_group", MangledFunctionName = @"get_group", TypeName = @"nd_item" } : (memref, i32) -> i64 return %0 : i64 @@ -1078,11 +1061,11 @@ func.func @test(%nd: memref, %i: i32) -> i64 { !sycl_nd_item_1_ = !sycl.nd_item<[1], (!sycl_item_1_, !sycl_item_1_1_, !sycl_group_1_)> // CHECK-LABEL: llvm.func @test( -// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[NDITEM1]]>) -> !llvm.[[RANGE1]] { -// CHECK-NEXT: %[[VAL_1:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 2, 2] : (!llvm.ptr<[[NDITEM1]]>) -> !llvm.ptr<[[RANGE1]]> -// CHECK-NEXT: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] : !llvm.ptr<[[RANGE1]]> -// CHECK-NEXT: llvm.return %[[VAL_2]] : !llvm.[[RANGE1]] -// CHECK-NEXT: } +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr) -> !llvm.struct<"class.sycl::_V1::range.1", {{.*}}> { +// CHECK-NEXT: %[[VAL_1:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 2, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::nd_item.1", {{.*}}> +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] : !llvm.ptr -> !llvm.struct<"class.sycl::_V1::range.1", {{.*}}> +// CHECK-NEXT: llvm.return %[[VAL_2]] : !llvm.struct<"class.sycl::_V1::range.1", {{.*}}> +// CHECK-NEXT: } func.func @test(%nd: memref) -> !sycl_range_1_ { %0 = sycl.nd_item.get_group_range(%nd) { ArgumentTypes = [memref], FunctionName = @"get_group_range", MangledFunctionName = @"get_group_range", TypeName = @"nd_item" } : (memref) -> !sycl_range_1_ return %0 : !sycl_range_1_ @@ -1100,12 +1083,12 @@ func.func @test(%nd: memref) -> !sycl_range_1_ { !sycl_nd_item_1_ = !sycl.nd_item<[1], (!sycl_item_1_, !sycl_item_1_1_, !sycl_group_1_)> // CHECK-LABEL: llvm.func @test( -// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[NDITEM1]]>, +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr, // CHECK-SAME: %[[VAL_1:.*]]: i32) -> i64 { -// CHECK-NEXT: %[[VAL_2:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 2, 2, 0, 0, %[[VAL_1]]] : (!llvm.ptr<[[NDITEM1]]>, i32) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_3:.*]] = llvm.load %[[VAL_2]] : !llvm.ptr -// CHECK-NEXT: llvm.return %[[VAL_3]] : i64 -// CHECK-NEXT: } +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 2, 2, 0, 0, %[[VAL_1]]] : (!llvm.ptr, i32) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::nd_item.1", {{.*}}> +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.load %[[VAL_2]] : !llvm.ptr -> i64 +// CHECK-NEXT: llvm.return %[[VAL_3]] : i64 +// CHECK-NEXT: } func.func @test(%nd: memref, %i: i32) -> i64 { %0 = sycl.nd_item.get_group_range(%nd, %i) { ArgumentTypes = [memref, i32], FunctionName = @"get_group_range", MangledFunctionName = @"get_group_range", TypeName = @"nd_item" } : (memref, i32) -> i64 return %0 : i64 @@ -1123,11 +1106,11 @@ func.func @test(%nd: memref, %i: i32) -> i64 { !sycl_nd_item_1_ = !sycl.nd_item<[1], (!sycl_item_1_, !sycl_item_1_1_, !sycl_group_1_)> // CHECK-LABEL: llvm.func @test( -// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[NDITEM1]]>) -> !llvm.[[RANGE1]] { -// CHECK-NEXT: %[[VAL_1:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0, 0] : (!llvm.ptr<[[NDITEM1]]>) -> !llvm.ptr<[[RANGE1]]> -// CHECK-NEXT: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] : !llvm.ptr<[[RANGE1]]> -// CHECK-NEXT: llvm.return %[[VAL_2]] : !llvm.[[RANGE1]] -// CHECK-NEXT: } +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr) -> !llvm.struct<"class.sycl::_V1::range.1", {{.*}}> { +// CHECK-NEXT: %[[VAL_1:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::nd_item.1", {{.*}}> +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] : !llvm.ptr -> !llvm.struct<"class.sycl::_V1::range.1", {{.*}}> +// CHECK-NEXT: llvm.return %[[VAL_2]] : !llvm.struct<"class.sycl::_V1::range.1", {{.*}}> +// CHECK-NEXT: } func.func @test(%nd: memref) -> !sycl_range_1_ { %0 = sycl.nd_item.get_local_range(%nd) { ArgumentTypes = [memref], FunctionName = @"get_local_range", MangledFunctionName = @"get_local_range", TypeName = @"nd_item" } : (memref) -> !sycl_range_1_ return %0 : !sycl_range_1_ @@ -1145,12 +1128,12 @@ func.func @test(%nd: memref) -> !sycl_range_1_ { !sycl_nd_item_1_ = !sycl.nd_item<[1], (!sycl_item_1_, !sycl_item_1_1_, !sycl_group_1_)> // CHECK-LABEL: llvm.func @test( -// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[NDITEM1]]>, +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr, // CHECK-SAME: %[[VAL_1:.*]]: i32) -> i64 { -// CHECK-NEXT: %[[VAL_2:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0, 0, 0, 0, %[[VAL_1]]] : (!llvm.ptr<[[NDITEM1]]>, i32) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_3:.*]] = llvm.load %[[VAL_2]] : !llvm.ptr -// CHECK-NEXT: llvm.return %[[VAL_3]] : i64 -// CHECK-NEXT: } +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0, 0, 0, 0, %[[VAL_1]]] : (!llvm.ptr, i32) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::nd_item.1", {{.*}}> +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.load %[[VAL_2]] : !llvm.ptr -> i64 +// CHECK-NEXT: llvm.return %[[VAL_3]] : i64 +// CHECK-NEXT: } func.func @test(%nd: memref, %i: i32) -> i64 { %0 = sycl.nd_item.get_local_range(%nd, %i) { ArgumentTypes = [memref, i32], FunctionName = @"get_local_range", MangledFunctionName = @"get_local_range", TypeName = @"nd_item" } : (memref, i32) -> i64 return %0 : i64 @@ -1169,24 +1152,24 @@ func.func @test(%nd: memref, %i: i32) -> i64 { !sycl_nd_range_1_ = !sycl.nd_range<[1], (!sycl_range_1_, !sycl_range_1_, !sycl_id_1_)> // CHECK-LABEL: llvm.func @test( -// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[NDITEM1]]>) -> !llvm.[[NDRANGE1]] { -// CHECK-NEXT: %[[VAL_1:.*]] = llvm.mlir.constant(1 : i32) : i32 -// CHECK-NEXT: %[[VAL_2:.*]] = llvm.alloca %[[VAL_1]] x !llvm.[[NDRANGE1]] : (i32) -> !llvm.ptr<[[NDRANGE1]]> -// CHECK-DAG: %[[VAL_3:.*]] = llvm.getelementptr inbounds %[[VAL_2]][0, 0] : (!llvm.ptr<[[NDRANGE1]]>) -> !llvm.ptr<[[RANGE1]]> -// CHECK-DAG: %[[VAL_4:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 0] : (!llvm.ptr<[[NDITEM1]]>) -> !llvm.ptr<[[RANGE1]]> -// CHECK-DAG: %[[VAL_5:.*]] = llvm.load %[[VAL_4]] : !llvm.ptr<[[RANGE1]]> -// CHECK-NEXT: llvm.store %[[VAL_5]], %[[VAL_3]] : !llvm.ptr<[[RANGE1]]> -// CHECK-DAG: %[[VAL_6:.*]] = llvm.getelementptr inbounds %[[VAL_2]][0, 1] : (!llvm.ptr<[[NDRANGE1]]>) -> !llvm.ptr<[[RANGE1]]> -// CHECK-DAG: %[[VAL_7:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0, 0] : (!llvm.ptr<[[NDITEM1]]>) -> !llvm.ptr<[[RANGE1]]> -// CHECK-DAG: %[[VAL_8:.*]] = llvm.load %[[VAL_7]] : !llvm.ptr<[[RANGE1]]> -// CHECK-NEXT: llvm.store %[[VAL_8]], %[[VAL_6]] : !llvm.ptr<[[RANGE1]]> -// CHECK-DAG: %[[VAL_9:.*]] = llvm.getelementptr inbounds %[[VAL_2]][0, 2] : (!llvm.ptr<[[NDRANGE1]]>) -> !llvm.ptr<[[ID1]]> -// CHECK-DAG: %[[VAL_10:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 2] : (!llvm.ptr<[[NDITEM1]]>) -> !llvm.ptr<[[ID1]]> -// CHECK-DAG: %[[VAL_11:.*]] = llvm.load %[[VAL_10]] : !llvm.ptr<[[ID1]]> -// CHECK-NEXT: llvm.store %[[VAL_11]], %[[VAL_9]] : !llvm.ptr<[[ID1]]> -// CHECK-NEXT: %[[VAL_12:.*]] = llvm.load %[[VAL_2]] : !llvm.ptr<[[NDRANGE1]]> -// CHECK-NEXT: llvm.return %[[VAL_12]] : !llvm.[[NDRANGE1]] -// CHECK-NEXT: } +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr) -> !llvm.struct<"class.sycl::_V1::nd_range.1", {{.*}}> { +// CHECK-NEXT: %[[VAL_1:.*]] = llvm.mlir.constant(1 : i32) : i32 +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.alloca %[[VAL_1]] x !llvm.struct<"class.sycl::_V1::nd_range.1", {{.*}}> : (i32) -> !llvm.ptr +// CHECK-DAG: %[[VAL_3:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::nd_item.1", {{.*}}> +// CHECK-DAG: %[[VAL_4:.*]] = llvm.load %[[VAL_3]] : !llvm.ptr -> !llvm.struct<"class.sycl::_V1::range.1", {{.*}}> +// CHECK-DAG: %[[VAL_5:.*]] = llvm.getelementptr inbounds %[[VAL_2]][0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::nd_range.1", {{.*}}> +// CHECK: llvm.store %[[VAL_4]], %[[VAL_5]] : !llvm.struct<"class.sycl::_V1::range.1", {{.*}}>, !llvm.ptr +// CHECK-DAG: %[[VAL_6:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::nd_item.1", {{.*}}> +// CHECK-DAG: %[[VAL_7:.*]] = llvm.load %[[VAL_6]] : !llvm.ptr -> !llvm.struct<"class.sycl::_V1::range.1", {{.*}}> +// CHECK-DAG: %[[VAL_8:.*]] = llvm.getelementptr inbounds %[[VAL_2]][0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::nd_range.1", {{.*}}> +// CHECK: llvm.store %[[VAL_7]], %[[VAL_8]] : !llvm.struct<"class.sycl::_V1::range.1", {{.*}}>, !llvm.ptr +// CHECK-DAG: %[[VAL_9:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::nd_item.1", {{.*}}> +// CHECK-DAG: %[[VAL_10:.*]] = llvm.load %[[VAL_9]] : !llvm.ptr -> !llvm.struct<"class.sycl::_V1::id.1", {{.*}}> +// CHECK-DAG: %[[VAL_11:.*]] = llvm.getelementptr inbounds %[[VAL_2]][0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::nd_range.1", {{.*}}> +// CHECK: llvm.store %[[VAL_10]], %[[VAL_11]] : !llvm.struct<"class.sycl::_V1::id.1", {{.*}}>, !llvm.ptr +// CHECK-NEXT: %[[VAL_12:.*]] = llvm.load %[[VAL_2]] : !llvm.ptr -> !llvm.struct<"class.sycl::_V1::nd_range.1", {{.*}}> +// CHECK-NEXT: llvm.return %[[VAL_12]] : !llvm.struct<"class.sycl::_V1::nd_range.1", {{.*}}> +// CHECK-NEXT: } func.func @test(%nd: memref) -> !sycl_nd_range_1_ { %0 = sycl.nd_item.get_nd_range(%nd) { ArgumentTypes = [memref], FunctionName = @"get_nd_range", MangledFunctionName = @"get_nd_range", TypeName = @"nd_item" } : (memref) -> !sycl_nd_range_1_ return %0 : !sycl_nd_range_1_ @@ -1199,11 +1182,11 @@ func.func @test(%nd: memref) -> !sycl_nd_range_1_ { !sycl_group_1_ = !sycl.group<[1], (!sycl_range_1_, !sycl_range_1_, !sycl_range_1_, !sycl_id_1_)> // CHECK-LABEL: llvm.func @test( -// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[GROUP1]]>) -> !llvm.[[ID1]] { -// CHECK-NEXT: %[[VAL_1:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 3] : (!llvm.ptr<[[GROUP1]]>) -> !llvm.ptr<[[ID1]]> -// CHECK-NEXT: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] : !llvm.ptr<[[ID1]]> -// CHECK-NEXT: llvm.return %[[VAL_2]] : !llvm.[[ID1]] -// CHECK-NEXT: } +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr) -> !llvm.struct<"class.sycl::_V1::id.1", {{.*}}> { +// CHECK-NEXT: %[[VAL_1:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 3] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::group.1", {{.*}}> +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] : !llvm.ptr -> !llvm.struct<"class.sycl::_V1::id.1", {{.*}}> +// CHECK-NEXT: llvm.return %[[VAL_2]] : !llvm.struct<"class.sycl::_V1::id.1", {{.*}}> +// CHECK-NEXT: } func.func @test(%group: memref) -> !sycl_id_1_ { %0 = sycl.group.get_group_id(%group) { ArgumentTypes = [memref], FunctionName = @"get_group_id", MangledFunctionName = @"get_group_id", TypeName = @"group" } : (memref) -> !sycl_id_1_ return %0 : !sycl_id_1_ @@ -1216,12 +1199,12 @@ func.func @test(%group: memref) -> !sycl_id_1_ { !sycl_group_1_ = !sycl.group<[1], (!sycl_range_1_, !sycl_range_1_, !sycl_range_1_, !sycl_id_1_)> // CHECK-LABEL: llvm.func @test( -// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[GROUP1]]>, +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr, // CHECK-SAME: %[[VAL_1:.*]]: i32) -> i64 { -// CHECK-NEXT: %[[VAL_2:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 3, 0, 0, %[[VAL_1]]] : (!llvm.ptr<[[GROUP1]]>, i32) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_3:.*]] = llvm.load %[[VAL_2]] : !llvm.ptr -// CHECK-NEXT: llvm.return %[[VAL_3]] : i64 -// CHECK-NEXT: } +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 3, 0, 0, %[[VAL_1]]] : (!llvm.ptr, i32) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::group.1", {{.*}}> +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.load %[[VAL_2]] : !llvm.ptr -> i64 +// CHECK-NEXT: llvm.return %[[VAL_3]] : i64 +// CHECK-NEXT: } func.func @test(%group: memref, %i: i32) -> i64 { %0 = sycl.group.get_group_id(%group, %i) { ArgumentTypes = [memref, i32], FunctionName = @"get_group_id", MangledFunctionName = @"get_group_id", TypeName = @"group" } : (memref, i32) -> i64 return %0 : i64 @@ -1235,38 +1218,39 @@ func.func @test(%group: memref, %i: i32) -> i64 { module attributes {gpu.container} { gpu.module @kernels { -// CHECK-LABEL: llvm.func @test( -// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[GROUP3:.*]]>) -> !llvm.[[ID3:.*]] { -// CHECK: %[[VAL_1:.*]] = llvm.mlir.addressof @__spirv_BuiltInLocalInvocationId : !llvm.ptr> -// CHECK: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] : !llvm.ptr> -// CHECK: %[[VAL_3:.*]] = llvm.mlir.null : !llvm.ptr<[[ID3]]> -// CHECK: %[[VAL_4:.*]] = llvm.mlir.constant(1 : index) : i64 -// CHECK: %[[VAL_5:.*]] = llvm.getelementptr %[[VAL_3]]{{\[}}%[[VAL_4]]] : (!llvm.ptr<[[ID3]]>, i64) -> !llvm.ptr<[[ID3]]> -// CHECK: %[[VAL_6:.*]] = llvm.ptrtoint %[[VAL_5]] : !llvm.ptr<[[ID3]]> to i64 -// CHECK: %[[VAL_7:.*]] = llvm.alloca %[[VAL_6]] x !llvm.[[ID3]] : (i64) -> !llvm.ptr<[[ID3]]> +// CHECK-LABEL: llvm.func @test( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr) -> !llvm.struct<"class.sycl::_V1::id.3", {{.*}}> { +// CHECK-NEXT: %[[VAL_1:.*]] = llvm.mlir.addressof @__spirv_BuiltInLocalInvocationId : !llvm.ptr +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] : !llvm.ptr -> vector<3xi64> +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.mlir.null : !llvm.ptr +// CHECK-NEXT: %[[VAL_4:.*]] = llvm.mlir.constant(1 : index) : i64 +// CHECK-NEXT: %[[VAL_5:.*]] = llvm.getelementptr %[[VAL_3]]{{\[}}%[[VAL_4]]] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::id.3", {{.*}}> +// CHECK-NEXT: %[[VAL_6:.*]] = llvm.ptrtoint %[[VAL_5]] : !llvm.ptr to i64 +// CHECK-NEXT: %[[VAL_7:.*]] = llvm.alloca %[[VAL_6]] x !llvm.struct<"class.sycl::_V1::id.3", {{.*}}> : (i64) -> !llvm.ptr // CHECK-DAG: %[[VAL_8:.*]] = llvm.mlir.constant(0 : index) : i64 // CHECK-DAG: %[[VAL_9:.*]] = llvm.mlir.constant(0 : i32) : i32 // CHECK-DAG: %[[VAL_10:.*]] = llvm.mlir.constant(0 : i32) : i32 // CHECK: %[[VAL_11:.*]] = llvm.extractelement %[[VAL_2]]{{\[}}%[[VAL_10]] : i32] : vector<3xi64> -// CHECK: %[[VAL_12:.*]] = llvm.getelementptr inbounds %[[VAL_7]][0, 0, 0, %[[VAL_9]]] : (!llvm.ptr<[[ID3]]>, i32) -> !llvm.ptr -// CHECK: %[[VAL_13:.*]] = llvm.getelementptr %[[VAL_12]]{{\[}}%[[VAL_8]]] : (!llvm.ptr, i64) -> !llvm.ptr -// CHECK: llvm.store %[[VAL_11]], %[[VAL_13]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_12:.*]] = llvm.getelementptr inbounds %[[VAL_7]][0, 0, 0, %[[VAL_9]]] : (!llvm.ptr, i32) -> !llvm.ptr, i64 +// CHECK-NEXT: %[[VAL_13:.*]] = llvm.getelementptr %[[VAL_12]]{{\[}}%[[VAL_8]]] : (!llvm.ptr, i64) -> !llvm.ptr, i64 +// CHECK-NEXT: llvm.store %[[VAL_11]], %[[VAL_13]] : i64, !llvm.ptr // CHECK-DAG: %[[VAL_14:.*]] = llvm.mlir.constant(1 : i32) : i32 // CHECK-DAG: %[[VAL_15:.*]] = llvm.mlir.constant(1 : i32) : i32 // CHECK: %[[VAL_16:.*]] = llvm.extractelement %[[VAL_2]]{{\[}}%[[VAL_15]] : i32] : vector<3xi64> -// CHECK: %[[VAL_17:.*]] = llvm.getelementptr inbounds %[[VAL_7]][0, 0, 0, %[[VAL_14]]] : (!llvm.ptr<[[ID3]]>, i32) -> !llvm.ptr -// CHECK: %[[VAL_18:.*]] = llvm.getelementptr %[[VAL_17]]{{\[}}%[[VAL_8]]] : (!llvm.ptr, i64) -> !llvm.ptr -// CHECK: llvm.store %[[VAL_16]], %[[VAL_18]] : !llvm.ptr +// CHECK-NEXT: %[[VAL_17:.*]] = llvm.getelementptr inbounds %[[VAL_7]][0, 0, 0, %[[VAL_14]]] : (!llvm.ptr, i32) -> !llvm.ptr, i64 +// CHECK-NEXT: %[[VAL_18:.*]] = llvm.getelementptr %[[VAL_17]]{{\[}}%[[VAL_8]]] : (!llvm.ptr, i64) -> !llvm.ptr, i64 +// CHECK-NEXT: llvm.store %[[VAL_16]], %[[VAL_18]] : i64, !llvm.ptr // CHECK-DAG: %[[VAL_19:.*]] = llvm.mlir.constant(2 : i32) : i32 // CHECK-DAG: %[[VAL_20:.*]] = llvm.mlir.constant(2 : i32) : i32 // CHECK: %[[VAL_21:.*]] = llvm.extractelement %[[VAL_2]]{{\[}}%[[VAL_20]] : i32] : vector<3xi64> -// CHECK: %[[VAL_22:.*]] = llvm.getelementptr inbounds %[[VAL_7]][0, 0, 0, %[[VAL_19]]] : (!llvm.ptr<[[ID3]]>, i32) -> !llvm.ptr -// CHECK: %[[VAL_23:.*]] = llvm.getelementptr %[[VAL_22]]{{\[}}%[[VAL_8]]] : (!llvm.ptr, i64) -> !llvm.ptr -// CHECK: llvm.store %[[VAL_21]], %[[VAL_23]] : !llvm.ptr -// CHECK: %[[VAL_24:.*]] = llvm.getelementptr %[[VAL_7]]{{\[}}%[[VAL_8]]] : (!llvm.ptr<[[ID3]]>, i64) -> !llvm.ptr<[[ID3]]> -// CHECK: %[[VAL_25:.*]] = llvm.load %[[VAL_24]] : !llvm.ptr<[[ID3]]> -// CHECK: llvm.return %[[VAL_25]] : !llvm.[[ID3]] -// CHECK-NEXT: } +// CHECK-NEXT: %[[VAL_22:.*]] = llvm.getelementptr inbounds %[[VAL_7]][0, 0, 0, %[[VAL_19]]] : (!llvm.ptr, i32) -> !llvm.ptr, i64 +// CHECK-NEXT: %[[VAL_23:.*]] = llvm.getelementptr %[[VAL_22]]{{\[}}%[[VAL_8]]] : (!llvm.ptr, i64) -> !llvm.ptr, i64 +// CHECK-NEXT: llvm.store %[[VAL_21]], %[[VAL_23]] : i64, !llvm.ptr +// CHECK-NEXT: %[[VAL_24:.*]] = llvm.getelementptr %[[VAL_7]]{{\[}}%[[VAL_8]]] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::id.3", {{.*}}> +// CHECK-NEXT: %[[VAL_25:.*]] = llvm.load %[[VAL_24]] : !llvm.ptr -> !llvm.struct<"class.sycl::_V1::id.3", {{.*}}> +// CHECK-NEXT: llvm.return %[[VAL_25]] : !llvm.struct<"class.sycl::_V1::id.3", {{.*}}> +// CHECK-NEXT: } +// CHECK-NEXT: } func.func @test(%group: memref) -> !sycl_id_3_ { %0 = sycl.group.get_local_id(%group) { ArgumentTypes = [memref], FunctionName = @"get_local_id", MangledFunctionName = @"get_local_id", TypeName = @"group" } : (memref) -> !sycl_id_3_ return %0 : !sycl_id_3_ @@ -1283,27 +1267,27 @@ module attributes {gpu.container} { module attributes {gpu.container} { gpu.module @kernels { -// CHECK-LABEL: llvm.func @test( -// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[GROUP1]]>, -// CHECK-SAME: %[[VAL_1:.*]]: i32) -> i64 { -// CHECK: %[[VAL_2:.*]] = llvm.mlir.addressof @__spirv_BuiltInLocalInvocationId : !llvm.ptr> -// CHECK: %[[VAL_3:.*]] = llvm.load %[[VAL_2]] : !llvm.ptr> +// CHECK-LABEL: llvm.func @test( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr +// CHECK-SAME: %[[VAL_1:.*]]: i32) -> i64 { +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.mlir.addressof @__spirv_BuiltInLocalInvocationId : !llvm.ptr +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.load %[[VAL_2]] : !llvm.ptr -> vector<3xi64> // CHECK-DAG: %[[VAL_4:.*]] = llvm.mlir.constant(dense<0> : vector<3xindex>) : vector<3xi64> // CHECK-DAG: %[[VAL_5:.*]] = llvm.mlir.constant(0 : i32) : i32 // CHECK: %[[VAL_6:.*]] = llvm.extractelement %[[VAL_3]]{{\[}}%[[VAL_5]] : i32] : vector<3xi64> -// CHECK: %[[VAL_7:.*]] = llvm.mlir.constant(0 : i64) : i64 -// CHECK: %[[VAL_8:.*]] = llvm.insertelement %[[VAL_6]], %[[VAL_4]]{{\[}}%[[VAL_7]] : i64] : vector<3xi64> -// CHECK: %[[VAL_9:.*]] = llvm.mlir.constant(1 : i32) : i32 -// CHECK: %[[VAL_10:.*]] = llvm.extractelement %[[VAL_3]]{{\[}}%[[VAL_9]] : i32] : vector<3xi64> -// CHECK: %[[VAL_11:.*]] = llvm.mlir.constant(1 : i64) : i64 -// CHECK: %[[VAL_12:.*]] = llvm.insertelement %[[VAL_10]], %[[VAL_8]]{{\[}}%[[VAL_11]] : i64] : vector<3xi64> -// CHECK: %[[VAL_13:.*]] = llvm.mlir.constant(2 : i32) : i32 -// CHECK: %[[VAL_14:.*]] = llvm.extractelement %[[VAL_3]]{{\[}}%[[VAL_13]] : i32] : vector<3xi64> -// CHECK: %[[VAL_15:.*]] = llvm.mlir.constant(2 : i64) : i64 -// CHECK: %[[VAL_16:.*]] = llvm.insertelement %[[VAL_14]], %[[VAL_12]]{{\[}}%[[VAL_15]] : i64] : vector<3xi64> -// CHECK: %[[VAL_17:.*]] = llvm.extractelement %[[VAL_16]]{{\[}}%[[VAL_1]] : i32] : vector<3xi64> -// CHECK: llvm.return %[[VAL_17]] : i64 -// CHECK-NEXT: } +// CHECK-NEXT: %[[VAL_7:.*]] = llvm.mlir.constant(0 : i64) : i64 +// CHECK-NEXT: %[[VAL_8:.*]] = llvm.insertelement %[[VAL_6]], %[[VAL_4]]{{\[}}%[[VAL_7]] : i64] : vector<3xi64> +// CHECK-NEXT: %[[VAL_9:.*]] = llvm.mlir.constant(1 : i32) : i32 +// CHECK-NEXT: %[[VAL_10:.*]] = llvm.extractelement %[[VAL_3]]{{\[}}%[[VAL_9]] : i32] : vector<3xi64> +// CHECK-NEXT: %[[VAL_11:.*]] = llvm.mlir.constant(1 : i64) : i64 +// CHECK-NEXT: %[[VAL_12:.*]] = llvm.insertelement %[[VAL_10]], %[[VAL_8]]{{\[}}%[[VAL_11]] : i64] : vector<3xi64> +// CHECK-NEXT: %[[VAL_13:.*]] = llvm.mlir.constant(2 : i32) : i32 +// CHECK-NEXT: %[[VAL_14:.*]] = llvm.extractelement %[[VAL_3]]{{\[}}%[[VAL_13]] : i32] : vector<3xi64> +// CHECK-NEXT: %[[VAL_15:.*]] = llvm.mlir.constant(2 : i64) : i64 +// CHECK-NEXT: %[[VAL_16:.*]] = llvm.insertelement %[[VAL_14]], %[[VAL_12]]{{\[}}%[[VAL_15]] : i64] : vector<3xi64> +// CHECK-NEXT: %[[VAL_17:.*]] = llvm.extractelement %[[VAL_16]]{{\[}}%[[VAL_1]] : i32] : vector<3xi64> +// CHECK-NEXT: llvm.return %[[VAL_17]] : i64 +// CHECK-NEXT: } func.func @test(%group: memref, %i: i32) -> i64 { %0 = sycl.group.get_local_id(%group, %i) { ArgumentTypes = [memref, i32], FunctionName = @"get_local_id", MangledFunctionName = @"get_local_id", TypeName = @"group" } : (memref, i32) -> i64 return %0 : i64 @@ -1318,11 +1302,11 @@ module attributes {gpu.container} { !sycl_group_3_ = !sycl.group<[3], (!sycl_range_3_, !sycl_range_3_, !sycl_range_3_, !sycl_id_3_)> // CHECK-LABEL: llvm.func @test( -// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[GROUP3]]>) -> !llvm.[[RANGE3]] { -// CHECK-NEXT: %[[VAL_1:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1] : (!llvm.ptr<[[GROUP3]]>) -> !llvm.ptr<[[RANGE3]]> -// CHECK-NEXT: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] : !llvm.ptr<[[RANGE3]]> -// CHECK-NEXT: llvm.return %[[VAL_2]] : !llvm.[[RANGE3]] -// CHECK-NEXT: } +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr) -> !llvm.struct<"class.sycl::_V1::range.3", {{.*}}> { +// CHECK-NEXT: %[[VAL_1:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::group.3", {{.*}}> +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] : !llvm.ptr -> !llvm.struct<"class.sycl::_V1::range.3", {{.*}}> +// CHECK-NEXT: llvm.return %[[VAL_2]] : !llvm.struct<"class.sycl::_V1::range.3", {{.*}}> +// CHECK-NEXT: } func.func @test(%group: memref) -> !sycl_range_3_ { %0 = sycl.group.get_local_range(%group) { ArgumentTypes = [memref], FunctionName = @"get_local_range", MangledFunctionName = @"get_local_range", TypeName = @"group" } : (memref) -> !sycl_range_3_ return %0 : !sycl_range_3_ @@ -1335,12 +1319,12 @@ func.func @test(%group: memref) -> !sycl_range_3_ { !sycl_group_1_ = !sycl.group<[1], (!sycl_range_1_, !sycl_range_1_, !sycl_range_1_, !sycl_id_1_)> // CHECK-LABEL: llvm.func @test( -// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[GROUP1]]>, +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr, // CHECK-SAME: %[[VAL_1:.*]]: i32) -> i64 { -// CHECK-NEXT: %[[VAL_2:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0, 0, %[[VAL_1]]] : (!llvm.ptr<[[GROUP1]]>, i32) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_3:.*]] = llvm.load %[[VAL_2]] : !llvm.ptr -// CHECK-NEXT: llvm.return %[[VAL_3]] : i64 -// CHECK-NEXT: } +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0, 0, %[[VAL_1]]] : (!llvm.ptr, i32) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::group.1", {{.*}}> +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.load %[[VAL_2]] : !llvm.ptr -> i64 +// CHECK-NEXT: llvm.return %[[VAL_3]] : i64 +// CHECK-NEXT: } func.func @test(%group: memref, %i: i32) -> i64 { %0 = sycl.group.get_local_range(%group, %i) { ArgumentTypes = [memref, i32], FunctionName = @"get_local_range", MangledFunctionName = @"get_local_range", TypeName = @"group" } : (memref, i32) -> i64 return %0 : i64 @@ -1353,11 +1337,11 @@ func.func @test(%group: memref, %i: i32) -> i64 { !sycl_group_3_ = !sycl.group<[3], (!sycl_range_3_, !sycl_range_3_, !sycl_range_3_, !sycl_id_3_)> // CHECK-LABEL: llvm.func @test( -// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[GROUP3]]>) -> !llvm.[[RANGE3]] { -// CHECK-NEXT: %[[VAL_1:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1] : (!llvm.ptr<[[GROUP3]]>) -> !llvm.ptr<[[RANGE3]]> -// CHECK-NEXT: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] : !llvm.ptr<[[RANGE3]]> -// CHECK-NEXT: llvm.return %[[VAL_2]] : !llvm.[[RANGE3]] -// CHECK-NEXT: } +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr) -> !llvm.struct<"class.sycl::_V1::range.3", {{.*}}> { +// CHECK-NEXT: %[[VAL_1:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::group.3", {{.*}}> +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] : !llvm.ptr -> !llvm.struct<"class.sycl::_V1::range.3", {{.*}}> +// CHECK-NEXT: llvm.return %[[VAL_2]] : !llvm.struct<"class.sycl::_V1::range.3", {{.*}}> +// CHECK-NEXT: } func.func @test(%group: memref) -> !sycl_range_3_ { %0 = sycl.group.get_max_local_range(%group) { ArgumentTypes = [memref], FunctionName = @"get_max_local_range", MangledFunctionName = @"get_max_local_range", TypeName = @"group" } : (memref) -> !sycl_range_3_ return %0 : !sycl_range_3_ @@ -1376,52 +1360,52 @@ func.func @test(%group: memref) -> !sycl_range_3_ { !sycl_group_3_ = !sycl.group<[3], (!sycl_range_3_, !sycl_range_3_, !sycl_range_3_, !sycl_id_3_)> // CHECK-LABEL: llvm.func @test_1( -// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[GROUP1]]>) -> i64 { -// CHECK-NEXT: %[[VAL_1:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 3, 0, 0, 0] : (!llvm.ptr<[[GROUP1]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] : !llvm.ptr -// CHECK-NEXT: llvm.return %[[VAL_2]] : i64 -// CHECK-NEXT: } +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr) -> i64 { +// CHECK-NEXT: %[[VAL_1:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 3, 0, 0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::group.1", {{.*}}> +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] : !llvm.ptr -> i64 +// CHECK-NEXT: llvm.return %[[VAL_2]] : i64 +// CHECK-NEXT: } func.func @test_1(%group: memref) -> i64 { %0 = sycl.group.get_group_linear_id(%group) { ArgumentTypes = [memref], FunctionName = @"get_group_linear_id", MangledFunctionName = @"get_group_linear_id", TypeName = @"group" } : (memref) -> i64 return %0 : i64 } // CHECK-LABEL: llvm.func @test_2( -// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[GROUP2:.*]]>) -> i64 { -// CHECK-NEXT: %[[VAL_1:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 3, 0, 0, 0] : (!llvm.ptr<[[GROUP2]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_3:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 2, 0, 0, 1] : (!llvm.ptr<[[GROUP2]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_4:.*]] = llvm.load %[[VAL_3]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_5:.*]] = llvm.mul %[[VAL_2]], %[[VAL_4]] : i64 -// CHECK-NEXT: %[[VAL_6:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 3, 0, 0, 1] : (!llvm.ptr<[[GROUP2]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_7:.*]] = llvm.load %[[VAL_6]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_8:.*]] = llvm.add %[[VAL_5]], %[[VAL_7]] : i64 -// CHECK-NEXT: llvm.return %[[VAL_8]] : i64 -// CHECK-NEXT: } +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr) -> i64 { +// CHECK-NEXT: %[[VAL_1:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 3, 0, 0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::group.2", {{.*}}> +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 2, 0, 0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::group.2", {{.*}}> +// CHECK-NEXT: %[[VAL_4:.*]] = llvm.load %[[VAL_3]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_5:.*]] = llvm.mul %[[VAL_2]], %[[VAL_4]] : i64 +// CHECK-NEXT: %[[VAL_6:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 3, 0, 0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::group.2", {{.*}}> +// CHECK-NEXT: %[[VAL_7:.*]] = llvm.load %[[VAL_6]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_8:.*]] = llvm.add %[[VAL_5]], %[[VAL_7]] : i64 +// CHECK-NEXT: llvm.return %[[VAL_8]] : i64 +// CHECK-NEXT: } func.func @test_2(%group: memref) -> i64 { %0 = sycl.group.get_group_linear_id(%group) { ArgumentTypes = [memref], FunctionName = @"get_group_linear_id", MangledFunctionName = @"get_group_linear_id", TypeName = @"group" } : (memref) -> i64 return %0 : i64 } // CHECK-LABEL: llvm.func @test_3( -// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[GROUP3]]>) -> i64 { -// CHECK-NEXT: %[[VAL_1:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 3, 0, 0, 0] : (!llvm.ptr<[[GROUP3]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_3:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 2, 0, 0, 1] : (!llvm.ptr<[[GROUP3]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_4:.*]] = llvm.load %[[VAL_3]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_5:.*]] = llvm.mul %[[VAL_2]], %[[VAL_4]] : i64 -// CHECK-NEXT: %[[VAL_6:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 2, 0, 0, 2] : (!llvm.ptr<[[GROUP3]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_7:.*]] = llvm.load %[[VAL_6]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_8:.*]] = llvm.mul %[[VAL_5]], %[[VAL_7]] : i64 -// CHECK-NEXT: %[[VAL_9:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 3, 0, 0, 1] : (!llvm.ptr<[[GROUP3]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_10:.*]] = llvm.load %[[VAL_9]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_11:.*]] = llvm.mul %[[VAL_10]], %[[VAL_7]] : i64 -// CHECK-NEXT: %[[VAL_12:.*]] = llvm.add %[[VAL_8]], %[[VAL_11]] : i64 -// CHECK-NEXT: %[[VAL_13:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 3, 0, 0, 2] : (!llvm.ptr<[[GROUP3]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_14:.*]] = llvm.load %[[VAL_13]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_15:.*]] = llvm.add %[[VAL_12]], %[[VAL_14]] : i64 -// CHECK-NEXT: llvm.return %[[VAL_15]] : i64 -// CHECK-NEXT: } +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr) -> i64 { +// CHECK-NEXT: %[[VAL_1:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 3, 0, 0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::group.3", {{.*}}> +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 2, 0, 0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::group.3", {{.*}}> +// CHECK-NEXT: %[[VAL_4:.*]] = llvm.load %[[VAL_3]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_5:.*]] = llvm.mul %[[VAL_2]], %[[VAL_4]] : i64 +// CHECK-NEXT: %[[VAL_6:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 2, 0, 0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::group.3", {{.*}}> +// CHECK-NEXT: %[[VAL_7:.*]] = llvm.load %[[VAL_6]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_8:.*]] = llvm.mul %[[VAL_5]], %[[VAL_7]] : i64 +// CHECK-NEXT: %[[VAL_9:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 3, 0, 0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::group.3", {{.*}}> +// CHECK-NEXT: %[[VAL_10:.*]] = llvm.load %[[VAL_9]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_11:.*]] = llvm.mul %[[VAL_10]], %[[VAL_7]] : i64 +// CHECK-NEXT: %[[VAL_12:.*]] = llvm.add %[[VAL_8]], %[[VAL_11]] : i64 +// CHECK-NEXT: %[[VAL_13:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 3, 0, 0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::group.3", {{.*}}> +// CHECK-NEXT: %[[VAL_14:.*]] = llvm.load %[[VAL_13]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_15:.*]] = llvm.add %[[VAL_12]], %[[VAL_14]] : i64 +// CHECK-NEXT: llvm.return %[[VAL_15]] : i64 +// CHECK-NEXT: } func.func @test_3(%group: memref) -> i64 { %0 = sycl.group.get_group_linear_id(%group) { ArgumentTypes = [memref], FunctionName = @"get_group_linear_id", MangledFunctionName = @"get_group_linear_id", TypeName = @"group" } : (memref) -> i64 return %0 : i64 @@ -1442,10 +1426,10 @@ func.func @test_3(%group: memref) -> i64 { module attributes {gpu.container} { gpu.module @kernels { // CHECK-LABEL: llvm.func @test_1( -// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[GROUP1]]>) -> i64 { +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr) -> i64 { // CHECK: %[[VAL_1:.*]] = llvm.mlir.constant(0 : i32) : i32 -// CHECK: %[[VAL_2:.*]] = llvm.mlir.addressof @__spirv_BuiltInLocalInvocationId : !llvm.ptr> -// CHECK: %[[VAL_3:.*]] = llvm.load %[[VAL_2]] : !llvm.ptr> +// CHECK: %[[VAL_2:.*]] = llvm.mlir.addressof @__spirv_BuiltInLocalInvocationId : !llvm.ptr +// CHECK: %[[VAL_3:.*]] = llvm.load %[[VAL_2]] : !llvm.ptr -> vector<3xi64> // CHECK-DAG: %[[VAL_4:.*]] = llvm.mlir.constant(dense<0> : vector<3xindex>) : vector<3xi64> // CHECK-DAG: %[[VAL_5:.*]] = llvm.mlir.constant(0 : i32) : i32 // CHECK: %[[VAL_6:.*]] = llvm.extractelement %[[VAL_3]]{{\[}}%[[VAL_5]] : i32] : vector<3xi64> @@ -1467,117 +1451,115 @@ module attributes {gpu.container} { return %0 : i64 } -// CHECK-LABEL: llvm.func @test_2( -// CHECK-SAME: %[[VAL_18:.*]]: !llvm.ptr<[[GROUP2]]>) -> i64 { -// CHECK: %[[VAL_19:.*]] = llvm.mlir.constant(0 : i32) : i32 -// CHECK: %[[VAL_20:.*]] = llvm.mlir.addressof @__spirv_BuiltInLocalInvocationId : !llvm.ptr> -// CHECK: %[[VAL_21:.*]] = llvm.load %[[VAL_20]] : !llvm.ptr> +// CHECK-NEXT: llvm.func @test_2(%[[VAL_18:.*]]: !llvm.ptr) -> i64 { +// CHECK-NEXT: %[[VAL_19:.*]] = llvm.mlir.constant(0 : i32) : i32 +// CHECK-NEXT: %[[VAL_20:.*]] = llvm.mlir.addressof @__spirv_BuiltInLocalInvocationId : !llvm.ptr +// CHECK-NEXT: %[[VAL_21:.*]] = llvm.load %[[VAL_20]] : !llvm.ptr -> vector<3xi64> // CHECK-DAG: %[[VAL_22:.*]] = llvm.mlir.constant(dense<0> : vector<3xindex>) : vector<3xi64> // CHECK-DAG: %[[VAL_23:.*]] = llvm.mlir.constant(0 : i32) : i32 // CHECK: %[[VAL_24:.*]] = llvm.extractelement %[[VAL_21]]{{\[}}%[[VAL_23]] : i32] : vector<3xi64> -// CHECK: %[[VAL_25:.*]] = llvm.mlir.constant(0 : i64) : i64 -// CHECK: %[[VAL_26:.*]] = llvm.insertelement %[[VAL_24]], %[[VAL_22]]{{\[}}%[[VAL_25]] : i64] : vector<3xi64> -// CHECK: %[[VAL_27:.*]] = llvm.mlir.constant(1 : i32) : i32 -// CHECK: %[[VAL_28:.*]] = llvm.extractelement %[[VAL_21]]{{\[}}%[[VAL_27]] : i32] : vector<3xi64> -// CHECK: %[[VAL_29:.*]] = llvm.mlir.constant(1 : i64) : i64 -// CHECK: %[[VAL_30:.*]] = llvm.insertelement %[[VAL_28]], %[[VAL_26]]{{\[}}%[[VAL_29]] : i64] : vector<3xi64> -// CHECK: %[[VAL_31:.*]] = llvm.mlir.constant(2 : i32) : i32 -// CHECK: %[[VAL_32:.*]] = llvm.extractelement %[[VAL_21]]{{\[}}%[[VAL_31]] : i32] : vector<3xi64> -// CHECK: %[[VAL_33:.*]] = llvm.mlir.constant(2 : i64) : i64 -// CHECK: %[[VAL_34:.*]] = llvm.insertelement %[[VAL_32]], %[[VAL_30]]{{\[}}%[[VAL_33]] : i64] : vector<3xi64> -// CHECK: %[[VAL_35:.*]] = llvm.extractelement %[[VAL_34]]{{\[}}%[[VAL_19]] : i32] : vector<3xi64> -// CHECK: %[[VAL_36:.*]] = llvm.getelementptr inbounds %[[VAL_18]][0, 2, 0, 0, 1] : (!llvm.ptr<[[GROUP2]]>) -> !llvm.ptr -// CHECK: %[[VAL_37:.*]] = llvm.load %[[VAL_36]] : !llvm.ptr -// CHECK: %[[VAL_38:.*]] = llvm.mul %[[VAL_35]], %[[VAL_37]] : i64 -// CHECK: %[[VAL_39:.*]] = llvm.mlir.constant(1 : i32) : i32 -// CHECK: %[[VAL_40:.*]] = llvm.mlir.addressof @__spirv_BuiltInLocalInvocationId : !llvm.ptr> -// CHECK: %[[VAL_41:.*]] = llvm.load %[[VAL_40]] : !llvm.ptr> -// CHECK-DAG: %[[VAL_42:.*]] = llvm.mlir.constant(dense<0> : vector<3xindex>) : vector<3xi64> -// CHECK-DAG: %[[VAL_43:.*]] = llvm.mlir.constant(0 : i32) : i32 -// CHECK: %[[VAL_44:.*]] = llvm.extractelement %[[VAL_41]]{{\[}}%[[VAL_43]] : i32] : vector<3xi64> -// CHECK: %[[VAL_45:.*]] = llvm.mlir.constant(0 : i64) : i64 -// CHECK: %[[VAL_46:.*]] = llvm.insertelement %[[VAL_44]], %[[VAL_42]]{{\[}}%[[VAL_45]] : i64] : vector<3xi64> -// CHECK: %[[VAL_47:.*]] = llvm.mlir.constant(1 : i32) : i32 -// CHECK: %[[VAL_48:.*]] = llvm.extractelement %[[VAL_41]]{{\[}}%[[VAL_47]] : i32] : vector<3xi64> -// CHECK: %[[VAL_49:.*]] = llvm.mlir.constant(1 : i64) : i64 -// CHECK: %[[VAL_50:.*]] = llvm.insertelement %[[VAL_48]], %[[VAL_46]]{{\[}}%[[VAL_49]] : i64] : vector<3xi64> -// CHECK: %[[VAL_51:.*]] = llvm.mlir.constant(2 : i32) : i32 -// CHECK: %[[VAL_52:.*]] = llvm.extractelement %[[VAL_41]]{{\[}}%[[VAL_51]] : i32] : vector<3xi64> -// CHECK: %[[VAL_53:.*]] = llvm.mlir.constant(2 : i64) : i64 -// CHECK: %[[VAL_54:.*]] = llvm.insertelement %[[VAL_52]], %[[VAL_50]]{{\[}}%[[VAL_53]] : i64] : vector<3xi64> -// CHECK: %[[VAL_55:.*]] = llvm.extractelement %[[VAL_54]]{{\[}}%[[VAL_39]] : i32] : vector<3xi64> -// CHECK: %[[VAL_56:.*]] = llvm.add %[[VAL_38]], %[[VAL_55]] : i64 -// CHECK: llvm.return %[[VAL_56]] : i64 -// CHECK-NEXT: } +// CHECK-NEXT: %[[VAL_25:.*]] = llvm.mlir.constant(0 : i64) : i64 +// CHECK-NEXT: %[[VAL_26:.*]] = llvm.insertelement %[[VAL_24]], %[[VAL_22]]{{\[}}%[[VAL_25]] : i64] : vector<3xi64> +// CHECK-NEXT: %[[VAL_27:.*]] = llvm.mlir.constant(1 : i32) : i32 +// CHECK-NEXT: %[[VAL_28:.*]] = llvm.extractelement %[[VAL_21]]{{\[}}%[[VAL_27]] : i32] : vector<3xi64> +// CHECK-NEXT: %[[VAL_29:.*]] = llvm.mlir.constant(1 : i64) : i64 +// CHECK-NEXT: %[[VAL_30:.*]] = llvm.insertelement %[[VAL_28]], %[[VAL_26]]{{\[}}%[[VAL_29]] : i64] : vector<3xi64> +// CHECK-NEXT: %[[VAL_31:.*]] = llvm.mlir.constant(2 : i32) : i32 +// CHECK-NEXT: %[[VAL_32:.*]] = llvm.extractelement %[[VAL_21]]{{\[}}%[[VAL_31]] : i32] : vector<3xi64> +// CHECK-NEXT: %[[VAL_33:.*]] = llvm.mlir.constant(2 : i64) : i64 +// CHECK-NEXT: %[[VAL_34:.*]] = llvm.insertelement %[[VAL_32]], %[[VAL_30]]{{\[}}%[[VAL_33]] : i64] : vector<3xi64> +// CHECK-NEXT: %[[VAL_35:.*]] = llvm.extractelement %[[VAL_34]]{{\[}}%[[VAL_19]] : i32] : vector<3xi64> +// CHECK-NEXT: %[[VAL_36:.*]] = llvm.getelementptr inbounds %[[VAL_18]][0, 2, 0, 0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::group.2", {{.*}}> +// CHECK-NEXT: %[[VAL_37:.*]] = llvm.load %[[VAL_36]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_38:.*]] = llvm.mul %[[VAL_35]], %[[VAL_37]] : i64 +// CHECK-NEXT: %[[VAL_39:.*]] = llvm.mlir.constant(1 : i32) : i32 +// CHECK-NEXT: %[[VAL_40:.*]] = llvm.mlir.addressof @__spirv_BuiltInLocalInvocationId : !llvm.ptr +// CHECK-NEXT: %[[VAL_41:.*]] = llvm.load %[[VAL_40]] : !llvm.ptr -> vector<3xi64> +// CHECK-NEXT: %[[VAL_42:.*]] = llvm.mlir.constant(dense<0> : vector<3xindex>) : vector<3xi64> +// CHECK-NEXT: %[[VAL_43:.*]] = llvm.mlir.constant(0 : i32) : i32 +// CHECK-NEXT: %[[VAL_44:.*]] = llvm.extractelement %[[VAL_41]]{{\[}}%[[VAL_43]] : i32] : vector<3xi64> +// CHECK-NEXT: %[[VAL_45:.*]] = llvm.mlir.constant(0 : i64) : i64 +// CHECK-NEXT: %[[VAL_46:.*]] = llvm.insertelement %[[VAL_44]], %[[VAL_42]]{{\[}}%[[VAL_45]] : i64] : vector<3xi64> +// CHECK-NEXT: %[[VAL_47:.*]] = llvm.mlir.constant(1 : i32) : i32 +// CHECK-NEXT: %[[VAL_48:.*]] = llvm.extractelement %[[VAL_41]]{{\[}}%[[VAL_47]] : i32] : vector<3xi64> +// CHECK-NEXT: %[[VAL_49:.*]] = llvm.mlir.constant(1 : i64) : i64 +// CHECK-NEXT: %[[VAL_50:.*]] = llvm.insertelement %[[VAL_48]], %[[VAL_46]]{{\[}}%[[VAL_49]] : i64] : vector<3xi64> +// CHECK-NEXT: %[[VAL_51:.*]] = llvm.mlir.constant(2 : i32) : i32 +// CHECK-NEXT: %[[VAL_52:.*]] = llvm.extractelement %[[VAL_41]]{{\[}}%[[VAL_51]] : i32] : vector<3xi64> +// CHECK-NEXT: %[[VAL_53:.*]] = llvm.mlir.constant(2 : i64) : i64 +// CHECK-NEXT: %[[VAL_54:.*]] = llvm.insertelement %[[VAL_52]], %[[VAL_50]]{{\[}}%[[VAL_53]] : i64] : vector<3xi64> +// CHECK-NEXT: %[[VAL_55:.*]] = llvm.extractelement %[[VAL_54]]{{\[}}%[[VAL_39]] : i32] : vector<3xi64> +// CHECK-NEXT: %[[VAL_56:.*]] = llvm.add %[[VAL_38]], %[[VAL_55]] : i64 +// CHECK-NEXT: llvm.return %[[VAL_56]] : i64 +// CHECK-NEXT: } func.func @test_2(%group: memref) -> i64 { %0 = sycl.group.get_local_linear_id(%group) { ArgumentTypes = [memref], FunctionName = @"get_local_linear_id", MangledFunctionName = @"get_local_linear_id", TypeName = @"group" } : (memref) -> i64 return %0 : i64 } -// CHECK-LABEL: llvm.func @test_3( -// CHECK-SAME: %[[VAL_57:.*]]: !llvm.ptr<[[GROUP3]]>) -> i64 { -// CHECK: %[[VAL_58:.*]] = llvm.mlir.constant(0 : i32) : i32 -// CHECK: %[[VAL_59:.*]] = llvm.mlir.addressof @__spirv_BuiltInLocalInvocationId : !llvm.ptr> -// CHECK: %[[VAL_60:.*]] = llvm.load %[[VAL_59]] : !llvm.ptr> +// CHECK-NEXT: llvm.func @test_3(%[[VAL_57:.*]]: !llvm.ptr) -> i64 { +// CHECK-NEXT: %[[VAL_58:.*]] = llvm.mlir.constant(0 : i32) : i32 +// CHECK-NEXT: %[[VAL_59:.*]] = llvm.mlir.addressof @__spirv_BuiltInLocalInvocationId : !llvm.ptr +// CHECK-NEXT: %[[VAL_60:.*]] = llvm.load %[[VAL_59]] : !llvm.ptr -> vector<3xi64> // CHECK-DAG: %[[VAL_61:.*]] = llvm.mlir.constant(dense<0> : vector<3xindex>) : vector<3xi64> // CHECK-DAG: %[[VAL_62:.*]] = llvm.mlir.constant(0 : i32) : i32 // CHECK: %[[VAL_63:.*]] = llvm.extractelement %[[VAL_60]]{{\[}}%[[VAL_62]] : i32] : vector<3xi64> -// CHECK: %[[VAL_64:.*]] = llvm.mlir.constant(0 : i64) : i64 -// CHECK: %[[VAL_65:.*]] = llvm.insertelement %[[VAL_63]], %[[VAL_61]]{{\[}}%[[VAL_64]] : i64] : vector<3xi64> -// CHECK: %[[VAL_66:.*]] = llvm.mlir.constant(1 : i32) : i32 -// CHECK: %[[VAL_67:.*]] = llvm.extractelement %[[VAL_60]]{{\[}}%[[VAL_66]] : i32] : vector<3xi64> -// CHECK: %[[VAL_68:.*]] = llvm.mlir.constant(1 : i64) : i64 -// CHECK: %[[VAL_69:.*]] = llvm.insertelement %[[VAL_67]], %[[VAL_65]]{{\[}}%[[VAL_68]] : i64] : vector<3xi64> -// CHECK: %[[VAL_70:.*]] = llvm.mlir.constant(2 : i32) : i32 -// CHECK: %[[VAL_71:.*]] = llvm.extractelement %[[VAL_60]]{{\[}}%[[VAL_70]] : i32] : vector<3xi64> -// CHECK: %[[VAL_72:.*]] = llvm.mlir.constant(2 : i64) : i64 -// CHECK: %[[VAL_73:.*]] = llvm.insertelement %[[VAL_71]], %[[VAL_69]]{{\[}}%[[VAL_72]] : i64] : vector<3xi64> -// CHECK: %[[VAL_74:.*]] = llvm.extractelement %[[VAL_73]]{{\[}}%[[VAL_58]] : i32] : vector<3xi64> -// CHECK: %[[VAL_75:.*]] = llvm.getelementptr inbounds %[[VAL_57]][0, 2, 0, 0, 1] : (!llvm.ptr<[[GROUP3]]>) -> !llvm.ptr -// CHECK: %[[VAL_76:.*]] = llvm.load %[[VAL_75]] : !llvm.ptr -// CHECK: %[[VAL_77:.*]] = llvm.mul %[[VAL_74]], %[[VAL_76]] : i64 -// CHECK: %[[VAL_78:.*]] = llvm.getelementptr inbounds %[[VAL_57]][0, 2, 0, 0, 2] : (!llvm.ptr<[[GROUP3]]>) -> !llvm.ptr -// CHECK: %[[VAL_79:.*]] = llvm.load %[[VAL_78]] : !llvm.ptr -// CHECK: %[[VAL_80:.*]] = llvm.mul %[[VAL_77]], %[[VAL_79]] : i64 -// CHECK: %[[VAL_81:.*]] = llvm.mlir.constant(1 : i32) : i32 -// CHECK: %[[VAL_82:.*]] = llvm.mlir.addressof @__spirv_BuiltInLocalInvocationId : !llvm.ptr> -// CHECK: %[[VAL_83:.*]] = llvm.load %[[VAL_82]] : !llvm.ptr> -// CHECK-DAG: %[[VAL_84:.*]] = llvm.mlir.constant(dense<0> : vector<3xindex>) : vector<3xi64> -// CHECK-DAG: %[[VAL_85:.*]] = llvm.mlir.constant(0 : i32) : i32 -// CHECK: %[[VAL_86:.*]] = llvm.extractelement %[[VAL_83]]{{\[}}%[[VAL_85]] : i32] : vector<3xi64> -// CHECK: %[[VAL_87:.*]] = llvm.mlir.constant(0 : i64) : i64 -// CHECK: %[[VAL_88:.*]] = llvm.insertelement %[[VAL_86]], %[[VAL_84]]{{\[}}%[[VAL_87]] : i64] : vector<3xi64> -// CHECK: %[[VAL_89:.*]] = llvm.mlir.constant(1 : i32) : i32 -// CHECK: %[[VAL_90:.*]] = llvm.extractelement %[[VAL_83]]{{\[}}%[[VAL_89]] : i32] : vector<3xi64> -// CHECK: %[[VAL_91:.*]] = llvm.mlir.constant(1 : i64) : i64 -// CHECK: %[[VAL_92:.*]] = llvm.insertelement %[[VAL_90]], %[[VAL_88]]{{\[}}%[[VAL_91]] : i64] : vector<3xi64> -// CHECK: %[[VAL_93:.*]] = llvm.mlir.constant(2 : i32) : i32 -// CHECK: %[[VAL_94:.*]] = llvm.extractelement %[[VAL_83]]{{\[}}%[[VAL_93]] : i32] : vector<3xi64> -// CHECK: %[[VAL_95:.*]] = llvm.mlir.constant(2 : i64) : i64 -// CHECK: %[[VAL_96:.*]] = llvm.insertelement %[[VAL_94]], %[[VAL_92]]{{\[}}%[[VAL_95]] : i64] : vector<3xi64> -// CHECK: %[[VAL_97:.*]] = llvm.extractelement %[[VAL_96]]{{\[}}%[[VAL_81]] : i32] : vector<3xi64> -// CHECK: %[[VAL_98:.*]] = llvm.mul %[[VAL_97]], %[[VAL_79]] : i64 -// CHECK: %[[VAL_99:.*]] = llvm.add %[[VAL_80]], %[[VAL_98]] : i64 -// CHECK: %[[VAL_100:.*]] = llvm.mlir.constant(2 : i32) : i32 -// CHECK: %[[VAL_101:.*]] = llvm.mlir.addressof @__spirv_BuiltInLocalInvocationId : !llvm.ptr> -// CHECK: %[[VAL_102:.*]] = llvm.load %[[VAL_101]] : !llvm.ptr> -// CHECK-DAG: %[[VAL_103:.*]] = llvm.mlir.constant(dense<0> : vector<3xindex>) : vector<3xi64> -// CHECK-DAG: %[[VAL_104:.*]] = llvm.mlir.constant(0 : i32) : i32 -// CHECK: %[[VAL_105:.*]] = llvm.extractelement %[[VAL_102]]{{\[}}%[[VAL_104]] : i32] : vector<3xi64> -// CHECK: %[[VAL_106:.*]] = llvm.mlir.constant(0 : i64) : i64 -// CHECK: %[[VAL_107:.*]] = llvm.insertelement %[[VAL_105]], %[[VAL_103]]{{\[}}%[[VAL_106]] : i64] : vector<3xi64> -// CHECK: %[[VAL_108:.*]] = llvm.mlir.constant(1 : i32) : i32 -// CHECK: %[[VAL_109:.*]] = llvm.extractelement %[[VAL_102]]{{\[}}%[[VAL_108]] : i32] : vector<3xi64> -// CHECK: %[[VAL_110:.*]] = llvm.mlir.constant(1 : i64) : i64 -// CHECK: %[[VAL_111:.*]] = llvm.insertelement %[[VAL_109]], %[[VAL_107]]{{\[}}%[[VAL_110]] : i64] : vector<3xi64> -// CHECK: %[[VAL_112:.*]] = llvm.mlir.constant(2 : i32) : i32 -// CHECK: %[[VAL_113:.*]] = llvm.extractelement %[[VAL_102]]{{\[}}%[[VAL_112]] : i32] : vector<3xi64> -// CHECK: %[[VAL_114:.*]] = llvm.mlir.constant(2 : i64) : i64 -// CHECK: %[[VAL_115:.*]] = llvm.insertelement %[[VAL_113]], %[[VAL_111]]{{\[}}%[[VAL_114]] : i64] : vector<3xi64> -// CHECK: %[[VAL_116:.*]] = llvm.extractelement %[[VAL_115]]{{\[}}%[[VAL_100]] : i32] : vector<3xi64> -// CHECK: %[[VAL_117:.*]] = llvm.add %[[VAL_99]], %[[VAL_116]] : i64 -// CHECK: llvm.return %[[VAL_117]] : i64 -// CHECK-NEXT: } +// CHECK-NEXT: %[[VAL_64:.*]] = llvm.mlir.constant(0 : i64) : i64 +// CHECK-NEXT: %[[VAL_65:.*]] = llvm.insertelement %[[VAL_63]], %[[VAL_61]]{{\[}}%[[VAL_64]] : i64] : vector<3xi64> +// CHECK-NEXT: %[[VAL_66:.*]] = llvm.mlir.constant(1 : i32) : i32 +// CHECK-NEXT: %[[VAL_67:.*]] = llvm.extractelement %[[VAL_60]]{{\[}}%[[VAL_66]] : i32] : vector<3xi64> +// CHECK-NEXT: %[[VAL_68:.*]] = llvm.mlir.constant(1 : i64) : i64 +// CHECK-NEXT: %[[VAL_69:.*]] = llvm.insertelement %[[VAL_67]], %[[VAL_65]]{{\[}}%[[VAL_68]] : i64] : vector<3xi64> +// CHECK-NEXT: %[[VAL_70:.*]] = llvm.mlir.constant(2 : i32) : i32 +// CHECK-NEXT: %[[VAL_71:.*]] = llvm.extractelement %[[VAL_60]]{{\[}}%[[VAL_70]] : i32] : vector<3xi64> +// CHECK-NEXT: %[[VAL_72:.*]] = llvm.mlir.constant(2 : i64) : i64 +// CHECK-NEXT: %[[VAL_73:.*]] = llvm.insertelement %[[VAL_71]], %[[VAL_69]]{{\[}}%[[VAL_72]] : i64] : vector<3xi64> +// CHECK-NEXT: %[[VAL_74:.*]] = llvm.extractelement %[[VAL_73]]{{\[}}%[[VAL_58]] : i32] : vector<3xi64> +// CHECK-NEXT: %[[VAL_75:.*]] = llvm.getelementptr inbounds %[[VAL_57]][0, 2, 0, 0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::group.3", {{.*}}> +// CHECK-NEXT: %[[VAL_76:.*]] = llvm.load %[[VAL_75]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_77:.*]] = llvm.mul %[[VAL_74]], %[[VAL_76]] : i64 +// CHECK-NEXT: %[[VAL_78:.*]] = llvm.getelementptr inbounds %[[VAL_57]][0, 2, 0, 0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::group.3", {{.*}}> +// CHECK-NEXT: %[[VAL_79:.*]] = llvm.load %[[VAL_78]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_80:.*]] = llvm.mul %[[VAL_77]], %[[VAL_79]] : i64 +// CHECK-NEXT: %[[VAL_81:.*]] = llvm.mlir.constant(1 : i32) : i32 +// CHECK-NEXT: %[[VAL_82:.*]] = llvm.mlir.addressof @__spirv_BuiltInLocalInvocationId : !llvm.ptr +// CHECK-NEXT: %[[VAL_83:.*]] = llvm.load %[[VAL_82]] : !llvm.ptr -> vector<3xi64> +// CHECK-NEXT: %[[VAL_84:.*]] = llvm.mlir.constant(dense<0> : vector<3xindex>) : vector<3xi64> +// CHECK-NEXT: %[[VAL_85:.*]] = llvm.mlir.constant(0 : i32) : i32 +// CHECK-NEXT: %[[VAL_86:.*]] = llvm.extractelement %[[VAL_83]]{{\[}}%[[VAL_85]] : i32] : vector<3xi64> +// CHECK-NEXT: %[[VAL_87:.*]] = llvm.mlir.constant(0 : i64) : i64 +// CHECK-NEXT: %[[VAL_88:.*]] = llvm.insertelement %[[VAL_86]], %[[VAL_84]]{{\[}}%[[VAL_87]] : i64] : vector<3xi64> +// CHECK-NEXT: %[[VAL_89:.*]] = llvm.mlir.constant(1 : i32) : i32 +// CHECK-NEXT: %[[VAL_90:.*]] = llvm.extractelement %[[VAL_83]]{{\[}}%[[VAL_89]] : i32] : vector<3xi64> +// CHECK-NEXT: %[[VAL_91:.*]] = llvm.mlir.constant(1 : i64) : i64 +// CHECK-NEXT: %[[VAL_92:.*]] = llvm.insertelement %[[VAL_90]], %[[VAL_88]]{{\[}}%[[VAL_91]] : i64] : vector<3xi64> +// CHECK-NEXT: %[[VAL_93:.*]] = llvm.mlir.constant(2 : i32) : i32 +// CHECK-NEXT: %[[VAL_94:.*]] = llvm.extractelement %[[VAL_83]]{{\[}}%[[VAL_93]] : i32] : vector<3xi64> +// CHECK-NEXT: %[[VAL_95:.*]] = llvm.mlir.constant(2 : i64) : i64 +// CHECK-NEXT: %[[VAL_96:.*]] = llvm.insertelement %[[VAL_94]], %[[VAL_92]]{{\[}}%[[VAL_95]] : i64] : vector<3xi64> +// CHECK-NEXT: %[[VAL_97:.*]] = llvm.extractelement %[[VAL_96]]{{\[}}%[[VAL_81]] : i32] : vector<3xi64> +// CHECK-NEXT: %[[VAL_98:.*]] = llvm.mul %[[VAL_97]], %[[VAL_79]] : i64 +// CHECK-NEXT: %[[VAL_99:.*]] = llvm.add %[[VAL_80]], %[[VAL_98]] : i64 +// CHECK-NEXT: %[[VAL_100:.*]] = llvm.mlir.constant(2 : i32) : i32 +// CHECK-NEXT: %[[VAL_101:.*]] = llvm.mlir.addressof @__spirv_BuiltInLocalInvocationId : !llvm.ptr +// CHECK-NEXT: %[[VAL_102:.*]] = llvm.load %[[VAL_101]] : !llvm.ptr -> vector<3xi64> +// CHECK-NEXT: %[[VAL_103:.*]] = llvm.mlir.constant(dense<0> : vector<3xindex>) : vector<3xi64> +// CHECK-NEXT: %[[VAL_104:.*]] = llvm.mlir.constant(0 : i32) : i32 +// CHECK-NEXT: %[[VAL_105:.*]] = llvm.extractelement %[[VAL_102]]{{\[}}%[[VAL_104]] : i32] : vector<3xi64> +// CHECK-NEXT: %[[VAL_106:.*]] = llvm.mlir.constant(0 : i64) : i64 +// CHECK-NEXT: %[[VAL_107:.*]] = llvm.insertelement %[[VAL_105]], %[[VAL_103]]{{\[}}%[[VAL_106]] : i64] : vector<3xi64> +// CHECK-NEXT: %[[VAL_108:.*]] = llvm.mlir.constant(1 : i32) : i32 +// CHECK-NEXT: %[[VAL_109:.*]] = llvm.extractelement %[[VAL_102]]{{\[}}%[[VAL_108]] : i32] : vector<3xi64> +// CHECK-NEXT: %[[VAL_110:.*]] = llvm.mlir.constant(1 : i64) : i64 +// CHECK-NEXT: %[[VAL_111:.*]] = llvm.insertelement %[[VAL_109]], %[[VAL_107]]{{\[}}%[[VAL_110]] : i64] : vector<3xi64> +// CHECK-NEXT: %[[VAL_112:.*]] = llvm.mlir.constant(2 : i32) : i32 +// CHECK-NEXT: %[[VAL_113:.*]] = llvm.extractelement %[[VAL_102]]{{\[}}%[[VAL_112]] : i32] : vector<3xi64> +// CHECK-NEXT: %[[VAL_114:.*]] = llvm.mlir.constant(2 : i64) : i64 +// CHECK-NEXT: %[[VAL_115:.*]] = llvm.insertelement %[[VAL_113]], %[[VAL_111]]{{\[}}%[[VAL_114]] : i64] : vector<3xi64> +// CHECK-NEXT: %[[VAL_116:.*]] = llvm.extractelement %[[VAL_115]]{{\[}}%[[VAL_100]] : i32] : vector<3xi64> +// CHECK-NEXT: %[[VAL_117:.*]] = llvm.add %[[VAL_99]], %[[VAL_116]] : i64 +// CHECK-NEXT: llvm.return %[[VAL_117]] : i64 +// CHECK-NEXT: } func.func @test_3(%group: memref) -> i64 { %0 = sycl.group.get_local_linear_id(%group) { ArgumentTypes = [memref], FunctionName = @"get_local_linear_id", MangledFunctionName = @"get_local_linear_id", TypeName = @"group" } : (memref) -> i64 return %0 : i64 @@ -1598,48 +1580,48 @@ module attributes {gpu.container} { !sycl_group_3_ = !sycl.group<[3], (!sycl_range_3_, !sycl_range_3_, !sycl_range_3_, !sycl_id_3_)> // CHECK-LABEL: llvm.func @test_1( -// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[GROUP1]]>) -> i64 { -// CHECK-NEXT: %[[VAL_1:.*]] = llvm.mlir.constant(1 : i64) : i64 -// CHECK-NEXT: %[[VAL_2:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 2, 0, 0, 0] : (!llvm.ptr<[[GROUP1]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_3:.*]] = llvm.load %[[VAL_2]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_4:.*]] = llvm.mul %[[VAL_1]], %[[VAL_3]] : i64 -// CHECK-NEXT: llvm.return %[[VAL_4]] : i64 -// CHECK-NEXT: } +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr) -> i64 { +// CHECK-NEXT: %[[VAL_1:.*]] = llvm.mlir.constant(1 : i64) : i64 +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 2, 0, 0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::group.1", {{.*}}> +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.load %[[VAL_2]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_4:.*]] = llvm.mul %[[VAL_1]], %[[VAL_3]] : i64 +// CHECK-NEXT: llvm.return %[[VAL_4]] : i64 +// CHECK-NEXT: } func.func @test_1(%group: memref) -> i64 { %0 = sycl.group.get_group_linear_range(%group) { ArgumentTypes = [memref], FunctionName = @"get_group_linear_range", MangledFunctionName = @"get_group_linear_range", TypeName = @"group" } : (memref) -> i64 return %0 : i64 } // CHECK-LABEL: llvm.func @test_2( -// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[GROUP2]]>) -> i64 { -// CHECK-NEXT: %[[VAL_1:.*]] = llvm.mlir.constant(1 : i64) : i64 -// CHECK-NEXT: %[[VAL_2:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 2, 0, 0, 0] : (!llvm.ptr<[[GROUP2]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_3:.*]] = llvm.load %[[VAL_2]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_4:.*]] = llvm.mul %[[VAL_1]], %[[VAL_3]] : i64 -// CHECK-NEXT: %[[VAL_5:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 2, 0, 0, 1] : (!llvm.ptr<[[GROUP2]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_6:.*]] = llvm.load %[[VAL_5]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_7:.*]] = llvm.mul %[[VAL_4]], %[[VAL_6]] : i64 -// CHECK-NEXT: llvm.return %[[VAL_7]] : i64 -// CHECK-NEXT: } +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr) -> i64 { +// CHECK-NEXT: %[[VAL_1:.*]] = llvm.mlir.constant(1 : i64) : i64 +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 2, 0, 0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::group.2", {{.*}}> +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.load %[[VAL_2]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_4:.*]] = llvm.mul %[[VAL_1]], %[[VAL_3]] : i64 +// CHECK-NEXT: %[[VAL_5:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 2, 0, 0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::group.2", {{.*}}> +// CHECK-NEXT: %[[VAL_6:.*]] = llvm.load %[[VAL_5]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_7:.*]] = llvm.mul %[[VAL_4]], %[[VAL_6]] : i64 +// CHECK-NEXT: llvm.return %[[VAL_7]] : i64 +// CHECK-NEXT: } func.func @test_2(%group: memref) -> i64 { %0 = sycl.group.get_group_linear_range(%group) { ArgumentTypes = [memref], FunctionName = @"get_group_linear_range", MangledFunctionName = @"get_group_linear_range", TypeName = @"group" } : (memref) -> i64 return %0 : i64 } // CHECK-LABEL: llvm.func @test_3( -// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[GROUP3]]>) -> i64 { -// CHECK-NEXT: %[[VAL_1:.*]] = llvm.mlir.constant(1 : i64) : i64 -// CHECK-NEXT: %[[VAL_2:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 2, 0, 0, 0] : (!llvm.ptr<[[GROUP3]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_3:.*]] = llvm.load %[[VAL_2]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_4:.*]] = llvm.mul %[[VAL_1]], %[[VAL_3]] : i64 -// CHECK-NEXT: %[[VAL_5:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 2, 0, 0, 1] : (!llvm.ptr<[[GROUP3]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_6:.*]] = llvm.load %[[VAL_5]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_7:.*]] = llvm.mul %[[VAL_4]], %[[VAL_6]] : i64 -// CHECK-NEXT: %[[VAL_8:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 2, 0, 0, 2] : (!llvm.ptr<[[GROUP3]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_9:.*]] = llvm.load %[[VAL_8]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_10:.*]] = llvm.mul %[[VAL_7]], %[[VAL_9]] : i64 -// CHECK-NEXT: llvm.return %[[VAL_10]] : i64 -// CHECK-NEXT: } +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr) -> i64 { +// CHECK-NEXT: %[[VAL_1:.*]] = llvm.mlir.constant(1 : i64) : i64 +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 2, 0, 0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::group.3", {{.*}}> +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.load %[[VAL_2]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_4:.*]] = llvm.mul %[[VAL_1]], %[[VAL_3]] : i64 +// CHECK-NEXT: %[[VAL_5:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 2, 0, 0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::group.3", {{.*}}> +// CHECK-NEXT: %[[VAL_6:.*]] = llvm.load %[[VAL_5]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_7:.*]] = llvm.mul %[[VAL_4]], %[[VAL_6]] : i64 +// CHECK-NEXT: %[[VAL_8:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 2, 0, 0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::group.3", {{.*}}> +// CHECK-NEXT: %[[VAL_9:.*]] = llvm.load %[[VAL_8]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_10:.*]] = llvm.mul %[[VAL_7]], %[[VAL_9]] : i64 +// CHECK-NEXT: llvm.return %[[VAL_10]] : i64 +// CHECK-NEXT: } func.func @test_3(%group: memref) -> i64 { %0 = sycl.group.get_group_linear_range(%group) { ArgumentTypes = [memref], FunctionName = @"get_group_linear_range", MangledFunctionName = @"get_group_linear_range", TypeName = @"group" } : (memref) -> i64 return %0 : i64 @@ -1658,48 +1640,48 @@ func.func @test_3(%group: memref) -> i64 { !sycl_group_3_ = !sycl.group<[3], (!sycl_range_3_, !sycl_range_3_, !sycl_range_3_, !sycl_id_3_)> // CHECK-LABEL: llvm.func @test_1( -// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[GROUP1]]>) -> i64 { -// CHECK-NEXT: %[[VAL_1:.*]] = llvm.mlir.constant(1 : i64) : i64 -// CHECK-NEXT: %[[VAL_2:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0, 0, 0] : (!llvm.ptr<[[GROUP1]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_3:.*]] = llvm.load %[[VAL_2]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_4:.*]] = llvm.mul %[[VAL_1]], %[[VAL_3]] : i64 -// CHECK-NEXT: llvm.return %[[VAL_4]] : i64 -// CHECK-NEXT: } +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr) -> i64 { +// CHECK-NEXT: %[[VAL_1:.*]] = llvm.mlir.constant(1 : i64) : i64 +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0, 0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::group.1", {{.*}}> +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.load %[[VAL_2]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_4:.*]] = llvm.mul %[[VAL_1]], %[[VAL_3]] : i64 +// CHECK-NEXT: llvm.return %[[VAL_4]] : i64 +// CHECK-NEXT: } func.func @test_1(%group: memref) -> i64 { %0 = sycl.group.get_local_linear_range(%group) { ArgumentTypes = [memref], FunctionName = @"get_local_linear_range", MangledFunctionName = @"get_local_linear_range", TypeName = @"group" } : (memref) -> i64 return %0 : i64 } // CHECK-LABEL: llvm.func @test_2( -// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[GROUP2]]>) -> i64 { -// CHECK-NEXT: %[[VAL_1:.*]] = llvm.mlir.constant(1 : i64) : i64 -// CHECK-NEXT: %[[VAL_2:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0, 0, 0] : (!llvm.ptr<[[GROUP2]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_3:.*]] = llvm.load %[[VAL_2]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_4:.*]] = llvm.mul %[[VAL_1]], %[[VAL_3]] : i64 -// CHECK-NEXT: %[[VAL_5:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0, 0, 1] : (!llvm.ptr<[[GROUP2]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_6:.*]] = llvm.load %[[VAL_5]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_7:.*]] = llvm.mul %[[VAL_4]], %[[VAL_6]] : i64 -// CHECK-NEXT: llvm.return %[[VAL_7]] : i64 -// CHECK-NEXT: } +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr) -> i64 { +// CHECK-NEXT: %[[VAL_1:.*]] = llvm.mlir.constant(1 : i64) : i64 +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0, 0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::group.2", {{.*}}> +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.load %[[VAL_2]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_4:.*]] = llvm.mul %[[VAL_1]], %[[VAL_3]] : i64 +// CHECK-NEXT: %[[VAL_5:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0, 0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::group.2", {{.*}}> +// CHECK-NEXT: %[[VAL_6:.*]] = llvm.load %[[VAL_5]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_7:.*]] = llvm.mul %[[VAL_4]], %[[VAL_6]] : i64 +// CHECK-NEXT: llvm.return %[[VAL_7]] : i64 +// CHECK-NEXT: } func.func @test_2(%group: memref) -> i64 { %0 = sycl.group.get_local_linear_range(%group) { ArgumentTypes = [memref], FunctionName = @"get_local_linear_range", MangledFunctionName = @"get_local_linear_range", TypeName = @"group" } : (memref) -> i64 return %0 : i64 } // CHECK-LABEL: llvm.func @test_3( -// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<[[GROUP3]]>) -> i64 { -// CHECK-NEXT: %[[VAL_1:.*]] = llvm.mlir.constant(1 : i64) : i64 -// CHECK-NEXT: %[[VAL_2:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0, 0, 0] : (!llvm.ptr<[[GROUP3]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_3:.*]] = llvm.load %[[VAL_2]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_4:.*]] = llvm.mul %[[VAL_1]], %[[VAL_3]] : i64 -// CHECK-NEXT: %[[VAL_5:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0, 0, 1] : (!llvm.ptr<[[GROUP3]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_6:.*]] = llvm.load %[[VAL_5]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_7:.*]] = llvm.mul %[[VAL_4]], %[[VAL_6]] : i64 -// CHECK-NEXT: %[[VAL_8:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0, 0, 2] : (!llvm.ptr<[[GROUP3]]>) -> !llvm.ptr -// CHECK-NEXT: %[[VAL_9:.*]] = llvm.load %[[VAL_8]] : !llvm.ptr -// CHECK-NEXT: %[[VAL_10:.*]] = llvm.mul %[[VAL_7]], %[[VAL_9]] : i64 -// CHECK-NEXT: llvm.return %[[VAL_10]] : i64 -// CHECK-NEXT: } +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr) -> i64 { +// CHECK-NEXT: %[[VAL_1:.*]] = llvm.mlir.constant(1 : i64) : i64 +// CHECK-NEXT: %[[VAL_2:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0, 0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::group.3", {{.*}}> +// CHECK-NEXT: %[[VAL_3:.*]] = llvm.load %[[VAL_2]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_4:.*]] = llvm.mul %[[VAL_1]], %[[VAL_3]] : i64 +// CHECK-NEXT: %[[VAL_5:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0, 0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::group.3", {{.*}}> +// CHECK-NEXT: %[[VAL_6:.*]] = llvm.load %[[VAL_5]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_7:.*]] = llvm.mul %[[VAL_4]], %[[VAL_6]] : i64 +// CHECK-NEXT: %[[VAL_8:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0, 0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"class.sycl::_V1::group.3", {{.*}}> +// CHECK-NEXT: %[[VAL_9:.*]] = llvm.load %[[VAL_8]] : !llvm.ptr -> i64 +// CHECK-NEXT: %[[VAL_10:.*]] = llvm.mul %[[VAL_7]], %[[VAL_9]] : i64 +// CHECK-NEXT: llvm.return %[[VAL_10]] : i64 +// CHECK-NEXT: } func.func @test_3(%group: memref) -> i64 { %0 = sycl.group.get_local_linear_range(%group) { ArgumentTypes = [memref], FunctionName = @"get_local_linear_range", MangledFunctionName = @"get_local_linear_range", TypeName = @"group" } : (memref) -> i64 return %0 : i64 From 7d6737db7f1c3f971f9f54b3de28be99ca1cd4ae Mon Sep 17 00:00:00 2001 From: Lukas Sommer Date: Tue, 4 Apr 2023 13:37:59 +0100 Subject: [PATCH 09/11] Fix sycl.cast test for opaque pointers Signed-off-by: Lukas Sommer --- polygeist/test/polygeist-opt/sycl/cast.mlir | 9 +++------ 1 file changed, 3 insertions(+), 6 deletions(-) diff --git a/polygeist/test/polygeist-opt/sycl/cast.mlir b/polygeist/test/polygeist-opt/sycl/cast.mlir index 7bd28e4428911..9bd30a590080c 100644 --- a/polygeist/test/polygeist-opt/sycl/cast.mlir +++ b/polygeist/test/polygeist-opt/sycl/cast.mlir @@ -5,8 +5,7 @@ // CHECK-LABEL: llvm.func @test1( // CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr) -> !llvm.ptr { -// CHECK: %[[VAL_1:.*]] = llvm.bitcast %[[VAL_0]] : !llvm.ptr to !llvm.ptr -// CHECK: llvm.return %[[VAL_1]] : !llvm.ptr +// CHECK: llvm.return %[[VAL_0]] : !llvm.ptr // CHECK: } func.func @test1(%arg0: memref) -> memref { @@ -18,8 +17,7 @@ func.func @test1(%arg0: memref) -> memref { // CHECK-LABEL: llvm.func @test2( // CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr) -> !llvm.ptr { -// CHECK: %[[VAL_1:.*]] = llvm.bitcast %[[VAL_0]] : !llvm.ptr to !llvm.ptr -// CHECK: llvm.return %[[VAL_1]] : !llvm.ptr +// CHECK: llvm.return %[[VAL_0]] : !llvm.ptr // CHECK: } !sycl_array_1_ = !sycl.array<[1], (memref<1xi64>)> @@ -33,8 +31,7 @@ func.func @test2(%arg0: memref) -> memref { // CHECK-LABEL: llvm.func @test_addrspaces( // CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr<4>) -> !llvm.ptr<4> { -// CHECK: %[[VAL_1:.*]] = llvm.bitcast %[[VAL_0]] : !llvm.ptr<4> to !llvm.ptr<4> -// CHECK: llvm.return %[[VAL_1]] : !llvm.ptr<4> +// CHECK: llvm.return %[[VAL_0]] : !llvm.ptr<4> // CHECK: } !sycl_array_1_ = !sycl.array<[1], (memref<1xi64>)> From a804ca371623e07165ae0ba0677566139389af8d Mon Sep 17 00:00:00 2001 From: Lukas Sommer Date: Wed, 5 Apr 2023 11:14:59 +0100 Subject: [PATCH 10/11] Address PR and offline feedback Signed-off-by: Lukas Sommer --- .../lib/Conversion/SYCLToLLVM/SYCLToLLVM.cpp | 75 ++++++------------- .../SYCLToLLVM/sycl-methods-to-llvm-m32.mlir | 12 +-- 2 files changed, 30 insertions(+), 57 deletions(-) diff --git a/mlir-sycl/lib/Conversion/SYCLToLLVM/SYCLToLLVM.cpp b/mlir-sycl/lib/Conversion/SYCLToLLVM/SYCLToLLVM.cpp index 4e42961e2830b..be3fe65f70df0 100644 --- a/mlir-sycl/lib/Conversion/SYCLToLLVM/SYCLToLLVM.cpp +++ b/mlir-sycl/lib/Conversion/SYCLToLLVM/SYCLToLLVM.cpp @@ -272,28 +272,20 @@ class GetMemberPatternBase { const auto addressSpace = targetAddressSpace.value_or(origAddressSpace); if (origAddressSpace != addressSpace) { - if (useOpaquePtr) { - ptr = builder.create( - loc, LLVM::LLVMPointerType::get(baseTy.getContext(), addressSpace), - ptr); - } else { - ptr = builder.create( - loc, - LLVM::LLVMPointerType::get( - cast(ptr.getType()).getElementType(), - addressSpace), - ptr); - } + auto ptrTy = + (useOpaquePtr) + ? LLVM::LLVMPointerType::get(baseTy.getContext(), addressSpace) + : LLVM::LLVMPointerType::get( + cast(ptr.getType()).getElementType(), + addressSpace); + ptr = builder.create(loc, ptrTy, ptr); } - if (useOpaquePtr) { - const auto ptrTy = - LLVM::LLVMPointerType::get(baseTy.getContext(), addressSpace); - return builder.create(loc, ptrTy, baseTy, ptr, indices, - /*inbounds*/ true); - } - const auto ptrTy = LLVM::LLVMPointerType::get(baseTy, addressSpace); - return builder.create(loc, ptrTy, ptr, indices, + const auto ptrTy = + (useOpaquePtr) + ? LLVM::LLVMPointerType::get(baseTy.getContext(), addressSpace) + : LLVM::LLVMPointerType::get(baseTy, addressSpace); + return builder.create(loc, ptrTy, baseTy, ptr, indices, /*inbounds*/ true); } @@ -1234,24 +1226,16 @@ class AccessorSubscriptPattern bool useOpaquePointers = getTypeConverter()->useOpaquePointers(); auto accTy = cast(orig.getAcc().getType().getElementType()); const auto addressSpace = targetToAddressSpace(accTy.getTargetMode()); - if (useOpaquePointers) { - const auto gepPtrTy = - LLVM::LLVMPointerType::get(ptrTy.getContext(), addressSpace); - const auto ptr = GetMemberPattern::loadValue( - builder, loc, accTy, gepPtrTy, acc, useOpaquePointers); - const Value gep = builder.create( - loc, gepPtrTy, accTy.getType(), ptr, index, /*inbounds*/ true); - return (ptrTy.getAddressSpace() == addressSpace) - ? gep - : builder.create(loc, ptrTy, gep); - } + const auto gepPtrTy = - LLVM::LLVMPointerType::get(ptrTy.getElementType(), addressSpace); + (useOpaquePointers) + ? LLVM::LLVMPointerType::get(ptrTy.getContext(), addressSpace) + : LLVM::LLVMPointerType::get(ptrTy.getElementType(), addressSpace); const auto ptr = GetMemberPattern::loadValue( builder, loc, accTy, gepPtrTy, acc, useOpaquePointers); - const Value gep = builder.create(loc, gepPtrTy, ptr, index, - /*inbounds*/ true); - return ptrTy == gepPtrTy + const Value gep = builder.create( + loc, gepPtrTy, accTy.getType(), ptr, index, /*inbounds*/ true); + return (ptrTy.getAddressSpace() == addressSpace) ? gep : builder.create(loc, ptrTy, gep); } @@ -1532,9 +1516,7 @@ class NDRangeGetGroupRangePattern const auto convRangeTy = getTypeConverter()->convertType(rangeTy); const auto indexTy = getTypeConverter()->getIndexType(); bool useOpaquePointers = getTypeConverter()->useOpaquePointers(); - const auto allocaTy = (useOpaquePointers) - ? LLVM::LLVMPointerType::get(rangeTy.getContext()) - : LLVM::LLVMPointerType::get(convRangeTy); + const auto allocaTy = getTypeConverter()->getPointerType(convRangeTy); Value alloca = rewriter.create( loc, allocaTy, convRangeTy, rewriter.create(loc, 1, indexTy), @@ -1551,11 +1533,7 @@ class NDRangeGetGroupRangePattern rewriter, loc, indexTy, alloca, std::nullopt, useOpaquePointers, i); rewriter.create(loc, val, ptr); } - if (useOpaquePointers) { - rewriter.replaceOpWithNewOp(op, convRangeTy, alloca); - return success(); - } - rewriter.replaceOpWithNewOp(op, alloca); + rewriter.replaceOpWithNewOp(op, convRangeTy, alloca); return success(); } }; @@ -1945,9 +1923,7 @@ class NDItemGetNDRange const auto ndrTy = getTypeConverter()->convertType(op.getType()); bool useOpaquePointers = getTypeConverter()->useOpaquePointers(); - const auto allocaTy = (useOpaquePointers) - ? LLVM::LLVMPointerType::get(ndrTy.getContext()) - : LLVM::LLVMPointerType::get(ndrTy); + const auto allocaTy = getTypeConverter()->getPointerType(ndrTy); const Value alloca = rewriter.create( loc, allocaTy, ndrTy, rewriter.create(loc, 1, 32)); @@ -1976,11 +1952,8 @@ class NDItemGetNDRange GetMemberPattern::getRef( rewriter, loc, (useOpaquePointers) ? ndrTy : idTy, alloca, std::nullopt, useOpaquePointers)); - if (useOpaquePointers) { - rewriter.replaceOpWithNewOp(op, ndrTy, alloca); - return success(); - } - rewriter.replaceOpWithNewOp(op, alloca); + + rewriter.replaceOpWithNewOp(op, ndrTy, alloca); return success(); } }; diff --git a/mlir-sycl/test/Conversion/SYCLToLLVM/sycl-methods-to-llvm-m32.mlir b/mlir-sycl/test/Conversion/SYCLToLLVM/sycl-methods-to-llvm-m32.mlir index 0c94440a3e961..b3b3d17e6ad55 100644 --- a/mlir-sycl/test/Conversion/SYCLToLLVM/sycl-methods-to-llvm-m32.mlir +++ b/mlir-sycl/test/Conversion/SYCLToLLVM/sycl-methods-to-llvm-m32.mlir @@ -1,8 +1,8 @@ // RUN: sycl-mlir-opt -split-input-file -convert-sycl-to-llvm="index-bitwidth=32 use-opaque-pointers=1" %s | FileCheck %s -//===-------------------------------------------------------------------------------------------------===// +//===----------------------------------------------------------------------===// // sycl.accessor.get_pointer -//===-------------------------------------------------------------------------------------------------===// +//===----------------------------------------------------------------------===// !sycl_id_1_ = !sycl.id<[1], (!sycl.array<[1], (memref<1xi32>)>)> !sycl_range_1_ = !sycl.range<[1], (!sycl.array<[1], (memref<1xi32>)>)> @@ -13,10 +13,10 @@ // CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr) -> !llvm.ptr<1> { // CHECK-NEXT: %0 = llvm.mlir.constant(0 : i32) : i32 // CHECK-NEXT: %1 = llvm.mlir.constant(0 : i32) : i32 -// CHECK-NEXT: %2 = llvm.getelementptr inbounds %arg0[0, 0, 2, 0, 0, 0] : (!llvm.ptr) -> !llvm.ptr -// CHECK-NEXT: %3 = llvm.load %2 : !llvm.ptr -// CHECK-NEXT: %4 = llvm.getelementptr inbounds %arg0[0, 0, 0, 0, 0, 0] : (!llvm.ptr) -> !llvm.ptr -// CHECK-NEXT: %5 = llvm.load %4 : !llvm.ptr +// CHECK-NEXT: %2 = llvm.getelementptr inbounds %arg0[0, 0, 2, 0, 0, 0] : (!llvm.ptr) -> !llvm.ptr, !sycl_accessor_1_i32_rw_gb +// CHECK-NEXT: %3 = llvm.load %2 : !llvm.ptr -> i32 +// CHECK-NEXT: %4 = llvm.getelementptr inbounds %arg0[0, 0, 0, 0, 0, 0] : (!llvm.ptr) -> !llvm.ptr, !sycl_accessor_1_i32_rw_gb +// CHECK-NEXT: %5 = llvm.load %4 : !llvm.ptr -> i32 // CHECK-NEXT: %6 = llvm.mul %1, %3 : i32 // CHECK-NEXT: %7 = llvm.add %6, %5 : i32 // CHECK-NEXT: %8 = llvm.sub %0, %7 : i32 From cc11fb3a2f907be480b57c784efc541053db6912 Mon Sep 17 00:00:00 2001 From: Lukas Sommer Date: Wed, 5 Apr 2023 14:18:08 +0100 Subject: [PATCH 11/11] Address more PR feedback Signed-off-by: Lukas Sommer --- mlir-sycl/lib/Conversion/SYCLToLLVM/SYCLToLLVM.cpp | 11 +++-------- 1 file changed, 3 insertions(+), 8 deletions(-) diff --git a/mlir-sycl/lib/Conversion/SYCLToLLVM/SYCLToLLVM.cpp b/mlir-sycl/lib/Conversion/SYCLToLLVM/SYCLToLLVM.cpp index be3fe65f70df0..4c99d72783469 100644 --- a/mlir-sycl/lib/Conversion/SYCLToLLVM/SYCLToLLVM.cpp +++ b/mlir-sycl/lib/Conversion/SYCLToLLVM/SYCLToLLVM.cpp @@ -299,15 +299,10 @@ class GetMemberPatternBase { is_empty_v>> Value loadValue(OpBuilder &builder, Location loc, Type baseTy, Type ty, Value ptr, bool useOpaquePtr, Args &&...args) const { - if (useOpaquePtr) { - const auto gep = - getRef(builder, loc, baseTy, ptr, std::nullopt, useOpaquePtr, - std::forward(args)...); - return builder.create(loc, ty, gep); - } - const auto gep = getRef(builder, loc, ty, ptr, std::nullopt, + const auto elemTy = (useOpaquePtr) ? baseTy : ty; + const auto gep = getRef(builder, loc, elemTy, ptr, std::nullopt, useOpaquePtr, std::forward(args)...); - return builder.create(loc, gep); + return builder.create(loc, ty, gep); } /// Return the indices needed to access the specific member this class is