[SPIR-V] Remove calls to deprecated PointerType methods (1/2) #68336
Conversation
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
|
@llvm/pr-subscribers-backend-spir-v ChangesPlease consider only the second commit in this patch. This patch removes calls to deprecated PointerType methods where it does not require any further work or explanation. Another patch removing the rest is coming. Patch is 23.82 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/68336.diff 10 Files Affected:
diff --git a/llvm/lib/Target/SPIRV/SPIRVBuiltins.cpp b/llvm/lib/Target/SPIRV/SPIRVBuiltins.cpp
index b4452d0f46a3475..d6354876b558744 100644
--- a/llvm/lib/Target/SPIRV/SPIRVBuiltins.cpp
+++ b/llvm/lib/Target/SPIRV/SPIRVBuiltins.cpp
@@ -2010,60 +2010,6 @@ static Type *parseTypeString(const StringRef Name, LLVMContext &Context) {
llvm_unreachable("Unable to recognize type!");
}
-static const TargetExtType *parseToTargetExtType(const Type *OpaqueType,
- MachineIRBuilder &MIRBuilder) {
- assert(isSpecialOpaqueType(OpaqueType) &&
- "Not a SPIR-V/OpenCL special opaque type!");
- assert(!OpaqueType->isTargetExtTy() &&
- "This already is SPIR-V/OpenCL TargetExtType!");
-
- StringRef NameWithParameters = OpaqueType->getStructName();
-
- // Pointers-to-opaque-structs representing OpenCL types are first translated
- // to equivalent SPIR-V types. OpenCL builtin type names should have the
- // following format: e.g. %opencl.event_t
- if (NameWithParameters.startswith("opencl.")) {
- const SPIRV::OpenCLType *OCLTypeRecord =
- SPIRV::lookupOpenCLType(NameWithParameters);
- if (!OCLTypeRecord)
- report_fatal_error("Missing TableGen record for OpenCL type: " +
- NameWithParameters);
- NameWithParameters = OCLTypeRecord->SpirvTypeLiteral;
- // Continue with the SPIR-V builtin type...
- }
-
- // Names of the opaque structs representing a SPIR-V builtins without
- // parameters should have the following format: e.g. %spirv.Event
- assert(NameWithParameters.startswith("spirv.") &&
- "Unknown builtin opaque type!");
-
- // Parameterized SPIR-V builtins names follow this format:
- // e.g. %spirv.Image._void_1_0_0_0_0_0_0, %spirv.Pipe._0
- if (NameWithParameters.find('_') == std::string::npos)
- return TargetExtType::get(OpaqueType->getContext(), NameWithParameters);
-
- SmallVector<StringRef> Parameters;
- unsigned BaseNameLength = NameWithParameters.find('_') - 1;
- SplitString(NameWithParameters.substr(BaseNameLength + 1), Parameters, "_");
-
- SmallVector<Type *, 1> TypeParameters;
- bool HasTypeParameter = !isDigit(Parameters[0][0]);
- if (HasTypeParameter)
- TypeParameters.push_back(parseTypeString(
- Parameters[0], MIRBuilder.getMF().getFunction().getContext()));
- SmallVector<unsigned> IntParameters;
- for (unsigned i = HasTypeParameter ? 1 : 0; i < Parameters.size(); i++) {
- unsigned IntParameter = 0;
- bool ValidLiteral = !Parameters[i].getAsInteger(10, IntParameter);
- assert(ValidLiteral &&
- "Invalid format of SPIR-V builtin parameter literal!");
- IntParameters.push_back(IntParameter);
- }
- return TargetExtType::get(OpaqueType->getContext(),
- NameWithParameters.substr(0, BaseNameLength),
- TypeParameters, IntParameters);
-}
-
//===----------------------------------------------------------------------===//
// Implementation functions for builtin types.
//===----------------------------------------------------------------------===//
@@ -2127,6 +2073,56 @@ static SPIRVType *getSampledImageType(const TargetExtType *OpaqueType,
}
namespace SPIRV {
+const TargetExtType *
+parseBuiltinTypeNameToTargetExtType(std::string TypeName,
+ MachineIRBuilder &MIRBuilder) {
+ StringRef NameWithParameters = TypeName;
+
+ // Pointers-to-opaque-structs representing OpenCL types are first translated
+ // to equivalent SPIR-V types. OpenCL builtin type names should have the
+ // following format: e.g. %opencl.event_t
+ if (NameWithParameters.startswith("opencl.")) {
+ const SPIRV::OpenCLType *OCLTypeRecord =
+ SPIRV::lookupOpenCLType(NameWithParameters);
+ if (!OCLTypeRecord)
+ report_fatal_error("Missing TableGen record for OpenCL type: " +
+ NameWithParameters);
+ NameWithParameters = OCLTypeRecord->SpirvTypeLiteral;
+ // Continue with the SPIR-V builtin type...
+ }
+
+ // Names of the opaque structs representing a SPIR-V builtins without
+ // parameters should have the following format: e.g. %spirv.Event
+ assert(NameWithParameters.startswith("spirv.") &&
+ "Unknown builtin opaque type!");
+
+ // Parameterized SPIR-V builtins names follow this format:
+ // e.g. %spirv.Image._void_1_0_0_0_0_0_0, %spirv.Pipe._0
+ if (NameWithParameters.find('_') == std::string::npos)
+ return TargetExtType::get(MIRBuilder.getContext(), NameWithParameters);
+
+ SmallVector<StringRef> Parameters;
+ unsigned BaseNameLength = NameWithParameters.find('_') - 1;
+ SplitString(NameWithParameters.substr(BaseNameLength + 1), Parameters, "_");
+
+ SmallVector<Type *, 1> TypeParameters;
+ bool HasTypeParameter = !isDigit(Parameters[0][0]);
+ if (HasTypeParameter)
+ TypeParameters.push_back(parseTypeString(
+ Parameters[0], MIRBuilder.getMF().getFunction().getContext()));
+ SmallVector<unsigned> IntParameters;
+ for (unsigned i = HasTypeParameter ? 1 : 0; i < Parameters.size(); i++) {
+ unsigned IntParameter = 0;
+ bool ValidLiteral = !Parameters[i].getAsInteger(10, IntParameter);
+ assert(ValidLiteral &&
+ "Invalid format of SPIR-V builtin parameter literal!");
+ IntParameters.push_back(IntParameter);
+ }
+ return TargetExtType::get(MIRBuilder.getContext(),
+ NameWithParameters.substr(0, BaseNameLength),
+ TypeParameters, IntParameters);
+}
+
SPIRVType *lowerBuiltinType(const Type *OpaqueType,
SPIRV::AccessQualifier::AccessQualifier AccessQual,
MachineIRBuilder &MIRBuilder,
@@ -2141,7 +2137,8 @@ SPIRVType *lowerBuiltinType(const Type *OpaqueType,
// will be removed in the future release of LLVM.
const TargetExtType *BuiltinType = dyn_cast<TargetExtType>(OpaqueType);
if (!BuiltinType)
- BuiltinType = parseToTargetExtType(OpaqueType, MIRBuilder);
+ BuiltinType = parseBuiltinTypeNameToTargetExtType(
+ OpaqueType->getStructName().str(), MIRBuilder);
unsigned NumStartingVRegs = MIRBuilder.getMRI()->getNumVirtRegs();
diff --git a/llvm/lib/Target/SPIRV/SPIRVBuiltins.h b/llvm/lib/Target/SPIRV/SPIRVBuiltins.h
index 7ee5c49dc5b3259..6f957295464812e 100644
--- a/llvm/lib/Target/SPIRV/SPIRVBuiltins.h
+++ b/llvm/lib/Target/SPIRV/SPIRVBuiltins.h
@@ -37,6 +37,18 @@ std::optional<bool> lowerBuiltin(const StringRef DemangledCall,
const Register OrigRet, const Type *OrigRetTy,
const SmallVectorImpl<Register> &Args,
SPIRVGlobalRegistry *GR);
+
+/// Translates a string representing a SPIR-V or OpenCL builtin type to a
+/// TargetExtType that can be further lowered with lowerBuiltinType().
+///
+/// \return A TargetExtType representing the builtin SPIR-V type.
+///
+/// \p TypeName is the full string representation of the SPIR-V or OpenCL
+/// builtin type.
+const TargetExtType *
+parseBuiltinTypeNameToTargetExtType(std::string TypeName,
+ MachineIRBuilder &MIRBuilder);
+
/// Handles the translation of the provided special opaque/builtin type \p Type
/// to SPIR-V type. Generates the corresponding machine instructions for the
/// target type or gets the already existing OpType<...> register from the
diff --git a/llvm/lib/Target/SPIRV/SPIRVCallLowering.cpp b/llvm/lib/Target/SPIRV/SPIRVCallLowering.cpp
index cae7c0e9ac5b8ac..629db8e2eb4d04f 100644
--- a/llvm/lib/Target/SPIRV/SPIRVCallLowering.cpp
+++ b/llvm/lib/Target/SPIRV/SPIRVCallLowering.cpp
@@ -194,23 +194,38 @@ getKernelArgTypeQual(const Function &KernelFunction, unsigned ArgIdx) {
return {};
}
-static Type *getArgType(const Function &F, unsigned ArgIdx) {
+static SPIRVType *getArgSPIRVType(const Function &F, unsigned ArgIdx,
+ SPIRVGlobalRegistry *GR,
+ MachineIRBuilder &MIRBuilder) {
+ // Read argument's access qualifier from metadata or default.
+ SPIRV::AccessQualifier::AccessQualifier ArgAccessQual =
+ getArgAccessQual(F, ArgIdx);
+
Type *OriginalArgType = getOriginalFunctionType(F)->getParamType(ArgIdx);
+
+ // In case of non-kernel SPIR-V function or already TargetExtType, use the
+ // original IR type.
if (F.getCallingConv() != CallingConv::SPIR_KERNEL ||
isSpecialOpaqueType(OriginalArgType))
- return OriginalArgType;
+ return GR->getOrCreateSPIRVType(OriginalArgType, MIRBuilder, ArgAccessQual);
MDString *MDKernelArgType =
getKernelArgAttribute(F, ArgIdx, "kernel_arg_type");
- if (!MDKernelArgType || !MDKernelArgType->getString().endswith("_t"))
- return OriginalArgType;
-
- std::string KernelArgTypeStr = "opencl." + MDKernelArgType->getString().str();
- Type *ExistingOpaqueType =
- StructType::getTypeByName(F.getContext(), KernelArgTypeStr);
- return ExistingOpaqueType
- ? ExistingOpaqueType
- : StructType::create(F.getContext(), KernelArgTypeStr);
+ if (!MDKernelArgType || (MDKernelArgType->getString().ends_with("*") &&
+ MDKernelArgType->getString().ends_with("_t")))
+ return GR->getOrCreateSPIRVType(OriginalArgType, MIRBuilder, ArgAccessQual);
+
+ if (MDKernelArgType->getString().ends_with("*"))
+ return GR->getOrCreateSPIRVTypeByName(
+ MDKernelArgType->getString(), MIRBuilder,
+ addressSpaceToStorageClass(OriginalArgType->getPointerAddressSpace()));
+
+ if (MDKernelArgType->getString().ends_with("_t"))
+ return GR->getOrCreateSPIRVTypeByName(
+ "opencl." + MDKernelArgType->getString().str(), MIRBuilder,
+ SPIRV::StorageClass::Function, ArgAccessQual);
+
+ llvm_unreachable("Unable to recognize argument type name.");
}
static bool isEntryPoint(const Function &F) {
@@ -262,10 +277,8 @@ bool SPIRVCallLowering::lowerFormalArguments(MachineIRBuilder &MIRBuilder,
// TODO: handle the case of multiple registers.
if (VRegs[i].size() > 1)
return false;
- SPIRV::AccessQualifier::AccessQualifier ArgAccessQual =
- getArgAccessQual(F, i);
- auto *SpirvTy = GR->assignTypeToVReg(getArgType(F, i), VRegs[i][0],
- MIRBuilder, ArgAccessQual);
+ auto *SpirvTy = getArgSPIRVType(F, i, GR, MIRBuilder);
+ GR->assignSPIRVTypeToVReg(SpirvTy, VRegs[i][0], MIRBuilder.getMF());
ArgTypeVRegs.push_back(SpirvTy);
if (Arg.hasName())
diff --git a/llvm/lib/Target/SPIRV/SPIRVGlobalRegistry.cpp b/llvm/lib/Target/SPIRV/SPIRVGlobalRegistry.cpp
index d68454f26a80282..9a4ab0f79332bba 100644
--- a/llvm/lib/Target/SPIRV/SPIRVGlobalRegistry.cpp
+++ b/llvm/lib/Target/SPIRV/SPIRVGlobalRegistry.cpp
@@ -591,12 +591,6 @@ SPIRVType *SPIRVGlobalRegistry::getOpTypeStruct(const StructType *Ty,
SPIRVType *SPIRVGlobalRegistry::getOrCreateSpecialType(
const Type *Ty, MachineIRBuilder &MIRBuilder,
SPIRV::AccessQualifier::AccessQualifier AccQual) {
- // Some OpenCL and SPIRV builtins like image2d_t are passed in as
- // pointers, but should be treated as custom types like OpTypeImage.
- if (auto PType = dyn_cast<PointerType>(Ty)) {
- assert(!PType->isOpaque());
- Ty = PType->getNonOpaquePointerElementType();
- }
assert(isSpecialOpaqueType(Ty) && "Not a special opaque builtin type");
return SPIRV::lowerBuiltinType(Ty, AccQual, MIRBuilder, this);
}
@@ -752,13 +746,10 @@ SPIRVType *SPIRVGlobalRegistry::restOfCreateSPIRVType(
!isSpecialOpaqueType(Ty)) {
if (!Ty->isPointerTy())
DT.add(Ty, &MIRBuilder.getMF(), getSPIRVTypeID(SpirvType));
- else if (Ty->isOpaquePointerTy())
+ else
DT.add(Type::getInt8Ty(MIRBuilder.getMF().getFunction().getContext()),
Ty->getPointerAddressSpace(), &MIRBuilder.getMF(),
getSPIRVTypeID(SpirvType));
- else
- DT.add(Ty->getNonOpaquePointerElementType(), Ty->getPointerAddressSpace(),
- &MIRBuilder.getMF(), getSPIRVTypeID(SpirvType));
}
return SpirvType;
@@ -953,40 +944,82 @@ SPIRVGlobalRegistry::checkSpecialInstr(const SPIRV::SpecialTypeDescriptor &TD,
}
// TODO: maybe use tablegen to implement this.
-SPIRVType *
-SPIRVGlobalRegistry::getOrCreateSPIRVTypeByName(StringRef TypeStr,
- MachineIRBuilder &MIRBuilder) {
+SPIRVType *SPIRVGlobalRegistry::getOrCreateSPIRVTypeByName(
+ StringRef TypeStr, MachineIRBuilder &MIRBuilder,
+ SPIRV::StorageClass::StorageClass SC,
+ SPIRV::AccessQualifier::AccessQualifier AQ) {
unsigned VecElts = 0;
auto &Ctx = MIRBuilder.getMF().getFunction().getContext();
+ // Parse strings representing either a SPIR-V or OpenCL builtin type.
+ if (hasBuiltinTypePrefix(TypeStr))
+ return getOrCreateSPIRVType(
+ SPIRV::parseBuiltinTypeNameToTargetExtType(TypeStr.str(), MIRBuilder),
+ MIRBuilder, AQ);
+
// Parse type name in either "typeN" or "type vector[N]" format, where
// N is the number of elements of the vector.
- Type *Type;
+ Type *Ty;
+
+ if (TypeStr.starts_with("atomic_"))
+ TypeStr = TypeStr.substr(strlen("atomic_"));
+
if (TypeStr.startswith("void")) {
- Type = Type::getVoidTy(Ctx);
+ Ty = Type::getVoidTy(Ctx);
TypeStr = TypeStr.substr(strlen("void"));
+ } else if (TypeStr.startswith("bool")) {
+ Ty = Type::getIntNTy(Ctx, 1);
+ TypeStr = TypeStr.substr(strlen("bool"));
+ } else if (TypeStr.startswith("char") || TypeStr.startswith("uchar")) {
+ Ty = Type::getInt8Ty(Ctx);
+ TypeStr = TypeStr.startswith("char") ? TypeStr.substr(strlen("char"))
+ : TypeStr.substr(strlen("uchar"));
+ } else if (TypeStr.startswith("short") || TypeStr.startswith("ushort")) {
+ Ty = Type::getInt16Ty(Ctx);
+ TypeStr = TypeStr.startswith("short") ? TypeStr.substr(strlen("short"))
+ : TypeStr.substr(strlen("ushort"));
} else if (TypeStr.startswith("int") || TypeStr.startswith("uint")) {
- Type = Type::getInt32Ty(Ctx);
+ Ty = Type::getInt32Ty(Ctx);
TypeStr = TypeStr.startswith("int") ? TypeStr.substr(strlen("int"))
: TypeStr.substr(strlen("uint"));
- } else if (TypeStr.startswith("float")) {
- Type = Type::getFloatTy(Ctx);
- TypeStr = TypeStr.substr(strlen("float"));
+ } else if (TypeStr.starts_with("long") || TypeStr.starts_with("ulong")) {
+ Ty = Type::getInt64Ty(Ctx);
+ TypeStr = TypeStr.startswith("long") ? TypeStr.substr(strlen("long"))
+ : TypeStr.substr(strlen("ulong"));
} else if (TypeStr.startswith("half")) {
- Type = Type::getHalfTy(Ctx);
+ Ty = Type::getHalfTy(Ctx);
TypeStr = TypeStr.substr(strlen("half"));
- } else if (TypeStr.startswith("opencl.sampler_t")) {
- Type = StructType::create(Ctx, "opencl.sampler_t");
+ } else if (TypeStr.startswith("float")) {
+ Ty = Type::getFloatTy(Ctx);
+ TypeStr = TypeStr.substr(strlen("float"));
+ } else if (TypeStr.startswith("double")) {
+ Ty = Type::getDoubleTy(Ctx);
+ TypeStr = TypeStr.substr(strlen("double"));
} else
llvm_unreachable("Unable to recognize SPIRV type name.");
+
+ auto SpirvTy = getOrCreateSPIRVType(Ty, MIRBuilder, AQ);
+
+ // Handle "type*" or "type* vector[N]".
+ if (TypeStr.starts_with("*")) {
+ SpirvTy = getOrCreateSPIRVPointerType(SpirvTy, MIRBuilder, SC);
+ TypeStr = TypeStr.substr(strlen("*"));
+ }
+
+ // Handle "typeN*" or "type vector[N]*".
+ bool IsPtrToVec = TypeStr.consume_back("*");
+
if (TypeStr.startswith(" vector[")) {
TypeStr = TypeStr.substr(strlen(" vector["));
TypeStr = TypeStr.substr(0, TypeStr.find(']'));
}
TypeStr.getAsInteger(10, VecElts);
- auto SpirvTy = getOrCreateSPIRVType(Type, MIRBuilder);
if (VecElts > 0)
SpirvTy = getOrCreateSPIRVVectorType(SpirvTy, VecElts, MIRBuilder);
+
+ if (IsPtrToVec)
+ SpirvTy = getOrCreateSPIRVPointerType(SpirvTy, MIRBuilder, SC);
+
return SpirvTy;
}
diff --git a/llvm/lib/Target/SPIRV/SPIRVGlobalRegistry.h b/llvm/lib/Target/SPIRV/SPIRVGlobalRegistry.h
index 88769f84b3e504b..60967bfb68a87e3 100644
--- a/llvm/lib/Target/SPIRV/SPIRVGlobalRegistry.h
+++ b/llvm/lib/Target/SPIRV/SPIRVGlobalRegistry.h
@@ -138,8 +138,11 @@ class SPIRVGlobalRegistry {
// Either generate a new OpTypeXXX instruction or return an existing one
// corresponding to the given string containing the name of the builtin type.
- SPIRVType *getOrCreateSPIRVTypeByName(StringRef TypeStr,
- MachineIRBuilder &MIRBuilder);
+ SPIRVType *getOrCreateSPIRVTypeByName(
+ StringRef TypeStr, MachineIRBuilder &MIRBuilder,
+ SPIRV::StorageClass::StorageClass SC = SPIRV::StorageClass::Function,
+ SPIRV::AccessQualifier::AccessQualifier AQ =
+ SPIRV::AccessQualifier::ReadWrite);
// Return the SPIR-V type instruction corresponding to the given VReg, or
// nullptr if no such type instruction exists.
diff --git a/llvm/lib/Target/SPIRV/SPIRVUtils.cpp b/llvm/lib/Target/SPIRV/SPIRVUtils.cpp
index e5094e8a4d33e9f..6cb51d782919d50 100644
--- a/llvm/lib/Target/SPIRV/SPIRVUtils.cpp
+++ b/llvm/lib/Target/SPIRV/SPIRVUtils.cpp
@@ -332,7 +332,7 @@ const Type *getTypedPtrEltType(const Type *Ty) {
return PType->getNonOpaquePointerElementType();
}
-static bool hasBuiltinTypePrefix(StringRef Name) {
+bool hasBuiltinTypePrefix(StringRef Name) {
if (Name.starts_with("opencl.") || Name.starts_with("spirv."))
return true;
return false;
diff --git a/llvm/lib/Target/SPIRV/SPIRVUtils.h b/llvm/lib/Target/SPIRV/SPIRVUtils.h
index 7c193611a857453..30fae6c7de479f2 100644
--- a/llvm/lib/Target/SPIRV/SPIRVUtils.h
+++ b/llvm/lib/Target/SPIRV/SPIRVUtils.h
@@ -92,6 +92,9 @@ std::string getOclOrSpirvBuiltinDemangledName(StringRef Name);
// element type, otherwise return Type.
const Type *getTypedPtrEltType(const Type *Type);
+// Check if a string contains a builtin prefix.
+bool hasBuiltinTypePrefix(StringRef Name);
+
// Check if given LLVM type is a special opaque builtin type.
bool isSpecialOpaqueType(const Type *Ty);
} // namespace llvm
diff --git a/llvm/test/CodeGen/SPIRV/pointers/getelementptr-base-type.ll b/llvm/test/CodeGen/SPIRV/pointers/getelementptr-base-type.ll
new file mode 100644
index 000000000000000..aaf97f8cc836c6b
--- /dev/null
+++ b/llvm/test/CodeGen/SPIRV/pointers/getelementptr-base-type.ll
@@ -0,0 +1,18 @@
+; RUN: llc -O0 -mtriple=spirv64-unknown-unknown %s -o - | FileCheck %s
+
+; CHECK: %[[#FLOAT32:]] = OpTypeFloat 32
+; CHECK: %[[#PTR:]] = OpTypePointer CrossWorkgroup %[[#FLOAT32]]
+; CHECK: %[[#ARG:]] = OpFunctionParameter %[[#PTR]]
+; CHECK: %[[#GEP:]] = OpInBoundsPtrAccessChain %[[#PTR]] %[[#ARG]] %[[#]]
+; CHECK: %[[#]] = OpLoad %[[#FLOAT32]] %[[#GEP]] Aligned 4
+
+define spir_kernel void @test1(ptr addrspace(1) %arg1) !kernel_arg_addr_space !1 !kernel_arg_access_qual !2 !kernel_arg_type !3 !kernel_arg_type_qual !4 {
+ %a = getelementptr inbounds float, ptr addrspace(1) %arg1, i64 1
+ %b = load float, ptr addrspace(1) %a, align 4
+ ret void
+}
+
+!1 = !{i32 1}
+!2 = !{!"none"}
+!3 = !{!"float*"}
+!4 = !{!""}
diff --git a/llvm/test/CodeGen/SPIRV/pointers/kernel-argument-pointer-addressspace.ll b/llvm/test/CodeGen/SPIRV/pointers/kernel-argument-pointer-addressspace.ll
new file mode 100644
index 000000000000000..6d1202328197d95
--- /dev/null
+++ b/llvm/test/CodeGen/SPIRV/pointers/kernel-argument-pointer-addressspace.ll
@@ -0,0 +1,63 @@
+; RUN: llc -O0 -mtriple=spirv64-unknown-unknown %s -o - | FileCheck %s
+
+; CHECK-DAG: %[[#INT:]] = OpTypeInt 32 0
+; CHECK-DAG: %[[#PTR1:]] = OpTypePointer Function %[[#INT]]
+; CHECK-DAG: %[[#ARG:]] = OpFunctionParameter %[[#PTR1]]
+
+define spir_kernel void @test1(ptr addrspace(0) %arg1) !kernel_arg_addr_space !1 !kernel_arg_type !2 {
+ %a = getelementptr inbounds i32, ptr addrspace(0) %arg1, i32 2
+ ret void
+}
+
+!1 = !{i32 0}
+!2 = !{!"int*"}
+
+; CHECK-DAG: %[[#PTR2:]] = OpTypePointer CrossWorkgroup %[[#INT]]
+; CHECK-DAG: %[[#ARG:]] = OpFunctionParameter %[[#PTR2]]
+
+define spir_kernel void @test2(ptr addrspace(1) %arg1) !kernel_arg_addr_space !3 !kernel_arg_type !2 {
+ %a = getelementptr inbounds i32, ptr addrspace(1) %arg1, i32 2
+ ret void
+}
+
+!3 = !{i32 1}
+
+; CHECK-DAG: %[[#PTR3:]] = OpTypePointer Un...
[truncated]
|
iliya-diyachkov
approved these changes
Oct 12, 2023
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
Please consider only the second commit in this patch. This patch removes calls to deprecated PointerType methods where it does not require any further work or explanation. Another patch removing the rest is coming.