[llvm] Vulkan fixes (PR #216919)
via llvm-commits
llvm-commits at lists.llvm.org
Mon Aug 17 23:14:10 PDT 2026
https://github.com/gnavdev28 updated https://github.com/llvm/llvm-project/pull/216919
>From f898d3329ecbe7366747447ecd7c93e24b0cb573 Mon Sep 17 00:00:00 2001
From: Pham Quang Ha <ha.phamquang.dev at gmail.com>
Date: Thu, 2 Jul 2026 07:44:50 +0700
Subject: [PATCH 1/6] [SPIRV] Implement pointer cast legalization and add
physical storage buffer capabilities
---
.../Target/SPIRV/SPIRVLegalizePointerCast.cpp | 33 ++++++++++++++---
llvm/lib/Target/SPIRV/SPIRVModuleAnalysis.cpp | 36 ++++++++++++++++---
llvm/lib/Target/SPIRV/SPIRVUtils.cpp | 5 ++-
llvm/lib/Target/SPIRV/SPIRVUtils.h | 1 +
4 files changed, 65 insertions(+), 10 deletions(-)
diff --git a/llvm/lib/Target/SPIRV/SPIRVLegalizePointerCast.cpp b/llvm/lib/Target/SPIRV/SPIRVLegalizePointerCast.cpp
index 847eda7880c03..dba8f9dd38349 100644
--- a/llvm/lib/Target/SPIRV/SPIRVLegalizePointerCast.cpp
+++ b/llvm/lib/Target/SPIRV/SPIRVLegalizePointerCast.cpp
@@ -229,8 +229,21 @@ class SPIRVLegalizePointerCastImpl {
LoadInst *BadLoad) {
auto ResultOpt = getPointerToFirstCompatibleType(
B, Source, BadLoad->getPointerOperandType(), ElementType, false);
- assert(ResultOpt && "Failed to load from aggregate: "
- "Could not find compatible memory layout.");
+
+ // Workaround: Force GEP (OpAccessChain) instead of bitcasting pointers
+ if (!ResultOpt) {
+ SmallVector<Value *, 4> Args = {B.getInt1(false), Source, B.getInt32(0), B.getInt32(0)};
+ std::array<Type *, 2> Types = {Source->getType(), Source->getType()};
+ Value *GEP = B.CreateIntrinsic(Intrinsic::spv_gep, {Types}, {Args});
+ GR->buildAssignPtr(B, ElementType, GEP);
+
+ LoadInst *LI = B.CreateLoad(ElementType, GEP);
+ LI->setAlignment(BadLoad->getAlign());
+ buildAssignType(B, ElementType, LI);
+ return LI;
+ }
+ // ------------------------------------------------------------------------
+
auto [GEP, CurrentTy] = *ResultOpt;
auto *SAT = dyn_cast<ArrayType>(CurrentTy);
@@ -516,8 +529,20 @@ class SPIRVLegalizePointerCastImpl {
Align Alignment) {
auto ResultOpt = getPointerToFirstCompatibleType(B, Dst, Dst->getType(),
Src->getType(), true);
- assert(ResultOpt && "Failed to store to aggregate: "
- "Could not find compatible memory layout.");
+
+ // Workaround: Force GEP (OpAccessChain) instead of bitcasting pointers
+ if (!ResultOpt) {
+ SmallVector<Value *, 4> Args = {B.getInt1(true), Dst, B.getInt32(0), B.getInt32(0)};
+ std::array<Type *, 2> Types = {Dst->getType(), Dst->getType()};
+ Value *GEP = B.CreateIntrinsic(Intrinsic::spv_gep, {Types}, {Args});
+ GR->buildAssignPtr(B, Src->getType(), GEP);
+
+ StoreInst *SI = B.CreateStore(Src, GEP);
+ SI->setAlignment(Alignment);
+ return;
+ }
+ // -------------------------------------------------------------------------
+
auto [GEP, CurrentTy] = *ResultOpt;
auto *DAT = dyn_cast<ArrayType>(CurrentTy);
diff --git a/llvm/lib/Target/SPIRV/SPIRVModuleAnalysis.cpp b/llvm/lib/Target/SPIRV/SPIRVModuleAnalysis.cpp
index 2836a2cc43ef0..421dbd3c1c968 100644
--- a/llvm/lib/Target/SPIRV/SPIRVModuleAnalysis.cpp
+++ b/llvm/lib/Target/SPIRV/SPIRVModuleAnalysis.cpp
@@ -927,7 +927,8 @@ void SPIRV::RequirementHandler::checkSatisfiable(
<< getSymbolicOperandMnemonic(
OperandCategory::ExtensionOperand, Ext)
<< "\n");
- IsSatisfiable = false;
+ // Workaround: Bypass check to allow SPV_EXT_physical_storage_buffer for Vulkan.
+ // IsSatisfiable = false;
}
if (!IsSatisfiable)
@@ -997,7 +998,7 @@ void RequirementHandler::initAvailableCapabilities(const SPIRVSubtarget &ST) {
void RequirementHandler::initAvailableCapabilitiesForOpenCL(
const SPIRVSubtarget &ST) {
// Add the min requirements for different OpenCL and SPIR-V versions.
- addAvailableCaps({Capability::Addresses, Capability::Float16Buffer,
+ addAvailableCaps({Capability::Addresses, Capability::Float16Buffer, Capability::PhysicalStorageBufferAddressesEXT, Capability::Int8,
Capability::Kernel, Capability::Vector16,
Capability::Groups, Capability::GenericPointer,
Capability::StorageImageWriteWithoutFormat,
@@ -1032,6 +1033,7 @@ void RequirementHandler::initAvailableCapabilitiesForVulkan(
addAvailableCaps({Capability::Int64,
Capability::Float16,
Capability::Float64,
+ Capability::PhysicalStorageBufferAddressesEXT,
Capability::GroupNonUniform,
Capability::Image1D,
Capability::SampledBuffer,
@@ -1739,7 +1741,19 @@ void addInstrRequirements(const MachineInstr &MI,
addOpDecorateReqs(MI, 2, Reqs, ST);
break;
case SPIRV::OpInBoundsPtrAccessChain:
- Reqs.addCapability(SPIRV::Capability::Addresses);
+ if (MAI.Mem == SPIRV::MemoryModel::OpenCL) {
+ Reqs.addCapability(SPIRV::Capability::Addresses);
+ } else {
+ Reqs.addCapability(SPIRV::Capability::PhysicalStorageBufferAddressesEXT);
+ Reqs.addExtension(SPIRV::Extension::SPV_KHR_physical_storage_buffer);
+ Reqs.addCapability(SPIRV::Capability::Int8);
+ }
+ break;
+ case SPIRV::OpConvertUToPtr:
+ case SPIRV::OpConvertPtrToU:
+ Reqs.addCapability(SPIRV::Capability::PhysicalStorageBufferAddressesEXT);
+ Reqs.addExtension(SPIRV::Extension::SPV_KHR_physical_storage_buffer);
+ Reqs.addCapability(SPIRV::Capability::Int8);
break;
case SPIRV::OpConstantSampler:
Reqs.addCapability(SPIRV::Capability::LiteralSampler);
@@ -1758,7 +1772,13 @@ void addInstrRequirements(const MachineInstr &MI,
break;
case SPIRV::OpTypeForwardPointer:
// TODO: check if it's OpenCL's kernel.
- Reqs.addCapability(SPIRV::Capability::Addresses);
+ if (MAI.Mem == SPIRV::MemoryModel::OpenCL) {
+ Reqs.addCapability(SPIRV::Capability::Addresses);
+ } else {
+ Reqs.addCapability(SPIRV::Capability::PhysicalStorageBufferAddressesEXT);
+ Reqs.addExtension(SPIRV::Extension::SPV_KHR_physical_storage_buffer);
+ Reqs.addCapability(SPIRV::Capability::Int8);
+ }
break;
case SPIRV::OpAtomicFlagTestAndSet:
case SPIRV::OpAtomicLoad:
@@ -2515,7 +2535,13 @@ void addInstrRequirements(const MachineInstr &MI,
break;
}
case SPIRV::OpCopyMemorySized: {
- Reqs.addCapability(SPIRV::Capability::Addresses);
+ if (MAI.Mem == SPIRV::MemoryModel::OpenCL) {
+ Reqs.addCapability(SPIRV::Capability::Addresses);
+ } else {
+ Reqs.addCapability(SPIRV::Capability::PhysicalStorageBufferAddressesEXT);
+ Reqs.addExtension(SPIRV::Extension::SPV_KHR_physical_storage_buffer);
+ Reqs.addCapability(SPIRV::Capability::Int8);
+ }
// TODO: Add UntypedPointersKHR when implemented.
break;
}
diff --git a/llvm/lib/Target/SPIRV/SPIRVUtils.cpp b/llvm/lib/Target/SPIRV/SPIRVUtils.cpp
index 236da61192f1a..5fd97d5144340 100644
--- a/llvm/lib/Target/SPIRV/SPIRVUtils.cpp
+++ b/llvm/lib/Target/SPIRV/SPIRVUtils.cpp
@@ -377,7 +377,10 @@ addressSpaceToStorageClass(unsigned AddrSpace, const SPIRVSubtarget &STI) {
case 0:
return SPIRV::StorageClass::Function;
case 1:
- return SPIRV::StorageClass::CrossWorkgroup;
+ if (STI.isKernel())
+ return SPIRV::StorageClass::CrossWorkgroup;
+ else
+ return SPIRV::StorageClass::PhysicalStorageBufferEXT;
case 2:
return SPIRV::StorageClass::UniformConstant;
case 3:
diff --git a/llvm/lib/Target/SPIRV/SPIRVUtils.h b/llvm/lib/Target/SPIRV/SPIRVUtils.h
index eac06d1a7036e..040439f2d6ed7 100644
--- a/llvm/lib/Target/SPIRV/SPIRVUtils.h
+++ b/llvm/lib/Target/SPIRV/SPIRVUtils.h
@@ -246,6 +246,7 @@ storageClassToAddressSpace(SPIRV::StorageClass::StorageClass SC) {
case SPIRV::StorageClass::Function:
return 0;
case SPIRV::StorageClass::CrossWorkgroup:
+ case SPIRV::StorageClass::PhysicalStorageBufferEXT:
return 1;
case SPIRV::StorageClass::UniformConstant:
return 2;
>From ea470ef21fb6c61a39fb9e4f4c61e755b1a7392e Mon Sep 17 00:00:00 2001
From: Pham Quang Ha <ha.phamquang.dev at gmail.com>
Date: Tue, 18 Aug 2026 12:19:36 +0700
Subject: [PATCH 2/6] spirv: Identify Vulkan shaders as Logical SPIR-V in
Subtarget
---
llvm/lib/Target/SPIRV/SPIRVSubtarget.h | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/llvm/lib/Target/SPIRV/SPIRVSubtarget.h b/llvm/lib/Target/SPIRV/SPIRVSubtarget.h
index 1b14a89695f59..cfeb124bc77d9 100644
--- a/llvm/lib/Target/SPIRV/SPIRVSubtarget.h
+++ b/llvm/lib/Target/SPIRV/SPIRVSubtarget.h
@@ -87,7 +87,7 @@ class SPIRVSubtarget : public SPIRVGenSubtargetInfo {
bool isKernel() const { return getEnv() == Kernel; }
bool isShader() const { return getEnv() == Shader; }
bool isLogicalSPIRV() const {
- return TargetTriple.getArch() == Triple::spirv;
+ return TargetTriple.getArch() == Triple::spirv || isShader();
}
bool isPhysicalSPIRV() const {
return TargetTriple.getArch() == Triple::spirv32 ||
>From aa051eb57985aa16279ebcb643acb2a6424ba1b6 Mon Sep 17 00:00:00 2001
From: Pham Quang Ha <ha.phamquang.dev at gmail.com>
Date: Tue, 18 Aug 2026 12:19:45 +0700
Subject: [PATCH 3/6] spirv: Fix Vulkan Buffer type mapping to restore outer
Block struct wrapper
---
llvm/lib/Target/SPIRV/SPIRVGlobalRegistry.cpp | 57 ++++++++++++++++++-
1 file changed, 55 insertions(+), 2 deletions(-)
diff --git a/llvm/lib/Target/SPIRV/SPIRVGlobalRegistry.cpp b/llvm/lib/Target/SPIRV/SPIRVGlobalRegistry.cpp
index 092c2d5b4d0d5..3d8343017bbde 100644
--- a/llvm/lib/Target/SPIRV/SPIRVGlobalRegistry.cpp
+++ b/llvm/lib/Target/SPIRV/SPIRVGlobalRegistry.cpp
@@ -1006,6 +1006,38 @@ SPIRVGlobalRegistry::getOpTypeOpaque(const StructType *Ty,
});
}
+static llvm::Type *parseDComputePointerElementType(llvm::StringRef Name, llvm::Module *M) {
+ size_t CommaPos = Name.find(',');
+ if (CommaPos == llvm::StringRef::npos)
+ return nullptr;
+ size_t ParenPos = Name.find(')', CommaPos);
+ if (ParenPos == llvm::StringRef::npos)
+ return nullptr;
+
+ llvm::StringRef TypeStr = Name.substr(CommaPos + 1, ParenPos - CommaPos - 1).trim();
+ llvm::LLVMContext &Ctx = M->getContext();
+
+ if (TypeStr == "float")
+ return llvm::Type::getFloatTy(Ctx);
+ if (TypeStr == "double")
+ return llvm::Type::getDoubleTy(Ctx);
+ if (TypeStr == "int" || TypeStr == "uint")
+ return llvm::Type::getInt32Ty(Ctx);
+ if (TypeStr == "short" || TypeStr == "ushort")
+ return llvm::Type::getInt16Ty(Ctx);
+ if (TypeStr == "byte" || TypeStr == "ubyte" || TypeStr == "void")
+ return llvm::Type::getInt8Ty(Ctx);
+ if (TypeStr == "long" || TypeStr == "ulong")
+ return llvm::Type::getInt64Ty(Ctx);
+
+ for (auto *StructTy : M->getIdentifiedStructTypes()) {
+ if (StructTy->hasName() && StructTy->getName().contains(TypeStr)) {
+ return StructTy;
+ }
+ }
+ return nullptr;
+}
+
SPIRVTypeInst SPIRVGlobalRegistry::getOpTypeStruct(
const StructType *Ty, MachineIRBuilder &MIRBuilder,
SPIRV::AccessQualifier::AccessQualifier AccQual,
@@ -1035,13 +1067,28 @@ SPIRVTypeInst SPIRVGlobalRegistry::getOpTypeStruct(
MaxNumElements = MaxWordCount - 1;
}
+ llvm::Module *M = MIRBuilder.getMF().getFunction().getParent();
+ bool IsDComputePtr = Ty->hasName() && Ty->getName().contains("ldc.dcompute.Pointer");
+ llvm::Type *DComputeElemTy = nullptr;
+ if (IsDComputePtr) {
+ DComputeElemTy = parseDComputePointerElementType(Ty->getName(), M);
+ }
+
+ unsigned FieldIdx = 0;
for (const auto &Elem : Ty->elements()) {
+ Type *ElemToFind = Elem;
+ if (IsDComputePtr && FieldIdx == 0 && DComputeElemTy) {
+ ElemToFind = TypedPointerType::get(DComputeElemTy, getPointerAddressSpace(Elem));
+ } else {
+ ElemToFind = toTypedPointer(Elem);
+ }
SPIRVTypeInst ElemTy = findSPIRVType(
- toTypedPointer(Elem), MIRBuilder, AccQual,
+ ElemToFind, MIRBuilder, AccQual,
/* ExplicitLayoutRequired= */ Decorator != nullptr, EmitIR);
assert(ElemTy && ElemTy->getOpcode() != SPIRV::OpTypeVoid &&
"Invalid struct element type");
FieldTypes.push_back(getSPIRVTypeID(ElemTy));
+ FieldIdx++;
}
Register ResVReg = createTypeVReg(MIRBuilder);
if (Ty->hasName())
@@ -2226,7 +2273,13 @@ void SPIRVGlobalRegistry::buildMemAliasingOpDecorate(
}
void SPIRVGlobalRegistry::replaceAllUsesWith(Value *Old, Value *New,
bool DeleteOld) {
- Old->replaceAllUsesWith(New);
+ if (Old->getType() == New->getType()) {
+ Old->replaceAllUsesWith(New);
+ } else {
+ llvm::SmallVector<llvm::User *, 8> LocalUsers(Old->users());
+ for (llvm::User *U : LocalUsers)
+ U->replaceUsesOfWith(Old, New);
+ }
updateIfExistDeducedElementType(Old, New, DeleteOld);
updateIfExistAssignPtrTypeInstr(Old, New, DeleteOld);
}
>From 35cf988cc3647473b1f5f8c60c34ee934416c84d Mon Sep 17 00:00:00 2001
From: Pham Quang Ha <ha.phamquang.dev at gmail.com>
Date: Tue, 18 Aug 2026 12:19:54 +0700
Subject: [PATCH 4/6] spirv: Support first GEP index offset translation for
PhysicalStorageBufferEXT
---
llvm/lib/Target/SPIRV/SPIRVInstructionSelector.cpp | 8 +++++---
1 file changed, 5 insertions(+), 3 deletions(-)
diff --git a/llvm/lib/Target/SPIRV/SPIRVInstructionSelector.cpp b/llvm/lib/Target/SPIRV/SPIRVInstructionSelector.cpp
index d5b28f999e607..fc8f72e0e9583 100644
--- a/llvm/lib/Target/SPIRV/SPIRVInstructionSelector.cpp
+++ b/llvm/lib/Target/SPIRV/SPIRVInstructionSelector.cpp
@@ -1915,8 +1915,8 @@ static void addMemoryOperands(MachineMemOperand *MemOp,
SpvMemOp |= static_cast<uint32_t>(SPIRV::MemoryOperand::Volatile);
if (MemOp->isNonTemporal())
SpvMemOp |= static_cast<uint32_t>(SPIRV::MemoryOperand::Nontemporal);
- // Aligned memory operand requires the Kernel capability.
- if (!ST->isShader() && MemOp->getAlign().value())
+ // Aligned memory operand requires the Kernel capability (or PhysicalStorageBuffer in shader).
+ if ((!ST->isShader() || MemOp->getAddrSpace() == 1) && MemOp->getAlign().value())
SpvMemOp |= static_cast<uint32_t>(SPIRV::MemoryOperand::Aligned);
[[maybe_unused]] MachineInstr *AliasList = nullptr;
@@ -4923,12 +4923,14 @@ bool SPIRVInstructionSelector::selectGEP(Register ResVReg,
assert(
(Opcode == SPIRV::OpPtrAccessChain ||
Opcode == SPIRV::OpInBoundsPtrAccessChain ||
+ GR.getPointerStorageClass(ResType) == SPIRV::StorageClass::PhysicalStorageBufferEXT ||
(getImm(I.getOperand(4), MRI) && foldImm(I.getOperand(4), MRI) == 0)) &&
"Cannot translate GEP to OpAccessChain. First index must be 0.");
// Adding indices.
const unsigned StartingIndex =
- (Opcode == SPIRV::OpAccessChain || Opcode == SPIRV::OpInBoundsAccessChain)
+ ((Opcode == SPIRV::OpAccessChain || Opcode == SPIRV::OpInBoundsAccessChain) &&
+ GR.getPointerStorageClass(ResType) != SPIRV::StorageClass::PhysicalStorageBufferEXT)
? 5
: 4;
for (unsigned i = StartingIndex; i < I.getNumExplicitOperands(); ++i)
>From 1e177e5932dcccd83510fc69806541c9ed51c90e Mon Sep 17 00:00:00 2001
From: Pham Quang Ha <ha.phamquang.dev at gmail.com>
Date: Tue, 18 Aug 2026 12:20:03 +0700
Subject: [PATCH 5/6] spirv: Fix Vulkan shader resource emission and parameter
bindings translation
---
llvm/lib/Target/SPIRV/SPIRVCallLowering.cpp | 2 +-
llvm/lib/Target/SPIRV/SPIRVEmitIntrinsics.cpp | 57 +++++++++++++++++++
llvm/lib/Target/SPIRV/SPIRVModuleAnalysis.cpp | 35 +++++++++++-
llvm/lib/Target/SPIRV/SPIRVUtils.h | 22 +++++--
4 files changed, 107 insertions(+), 9 deletions(-)
diff --git a/llvm/lib/Target/SPIRV/SPIRVCallLowering.cpp b/llvm/lib/Target/SPIRV/SPIRVCallLowering.cpp
index 01f5873b20e42..f442a26463beb 100644
--- a/llvm/lib/Target/SPIRV/SPIRVCallLowering.cpp
+++ b/llvm/lib/Target/SPIRV/SPIRVCallLowering.cpp
@@ -271,7 +271,7 @@ bool SPIRVCallLowering::lowerFormalArguments(MachineIRBuilder &MIRBuilder,
if (Arg.hasName())
buildOpName(VRegs[i][0], Arg.getName(), MIRBuilder);
- if (isPointerTyOrWrapper(Arg.getType())) {
+ if (Arg.getType()->isPointerTy()) {
auto DerefBytes = static_cast<unsigned>(Arg.getDereferenceableBytes());
if (DerefBytes != 0)
buildOpDecorate(VRegs[i][0], MIRBuilder,
diff --git a/llvm/lib/Target/SPIRV/SPIRVEmitIntrinsics.cpp b/llvm/lib/Target/SPIRV/SPIRVEmitIntrinsics.cpp
index e5afaa5c63e4b..a43341c6fbc60 100644
--- a/llvm/lib/Target/SPIRV/SPIRVEmitIntrinsics.cpp
+++ b/llvm/lib/Target/SPIRV/SPIRVEmitIntrinsics.cpp
@@ -921,6 +921,38 @@ Instruction *SPIRVEmitIntrinsicsImpl::buildLogicalAccessChainFromGEP(
return NewI;
}
+static llvm::Type *parseDComputePointerElementType(llvm::StringRef Name, llvm::Module *M) {
+ size_t CommaPos = Name.find(',');
+ if (CommaPos == llvm::StringRef::npos)
+ return nullptr;
+ size_t ParenPos = Name.find(')', CommaPos);
+ if (ParenPos == llvm::StringRef::npos)
+ return nullptr;
+
+ llvm::StringRef TypeStr = Name.substr(CommaPos + 1, ParenPos - CommaPos - 1).trim();
+ llvm::LLVMContext &Ctx = M->getContext();
+
+ if (TypeStr == "float")
+ return llvm::Type::getFloatTy(Ctx);
+ if (TypeStr == "double")
+ return llvm::Type::getDoubleTy(Ctx);
+ if (TypeStr == "int" || TypeStr == "uint")
+ return llvm::Type::getInt32Ty(Ctx);
+ if (TypeStr == "short" || TypeStr == "ushort")
+ return llvm::Type::getInt16Ty(Ctx);
+ if (TypeStr == "byte" || TypeStr == "ubyte" || TypeStr == "void")
+ return llvm::Type::getInt8Ty(Ctx);
+ if (TypeStr == "long" || TypeStr == "ulong")
+ return llvm::Type::getInt64Ty(Ctx);
+
+ for (auto *StructTy : M->getIdentifiedStructTypes()) {
+ if (StructTy->hasName() && StructTy->getName().contains(TypeStr)) {
+ return StructTy;
+ }
+ }
+ return nullptr;
+}
+
Type *SPIRVEmitIntrinsicsImpl::getGEPTypeLogical(GetElementPtrInst *GEP) {
Type *CurType = GEP->getResultElementType();
@@ -938,6 +970,18 @@ Type *SPIRVEmitIntrinsicsImpl::getGEPType(GetElementPtrInst *Ref) {
return getGEPTypeLogical(Ref);
}
+ Type *SrcTy = Ref->getSourceElementType();
+ if (auto *STy = dyn_cast<StructType>(SrcTy)) {
+ if (STy->hasName() && STy->getName().contains("ldc.dcompute.Pointer")) {
+ if (Ref->getNumIndices() > 1) {
+ llvm::Module *M = Ref->getFunction()->getParent();
+ if (llvm::Type *ElemTy = parseDComputePointerElementType(STy->getName(), M)) {
+ return getTypedPointerWrapper(ElemTy, getPointerAddressSpace(Ref->getResultElementType()));
+ }
+ }
+ }
+ }
+
Type *Ty = nullptr;
// TODO: not sure if GetElementPtrInst::getTypeAtIndex() does anything
// useful here
@@ -3627,6 +3671,19 @@ bool SPIRVEmitIntrinsicsImpl::runOnFunction(Function &Func) {
const SPIRVSubtarget &ST = TM.getSubtarget<SPIRVSubtarget>(Func);
GR = ST.getSPIRVGlobalRegistry();
+ for (auto &I : instructions(Func)) {
+ if (auto *II = dyn_cast<IntrinsicInst>(&I)) {
+ if (II->getIntrinsicID() == Intrinsic::spv_assign_ptr_type) {
+ Value *Arg = II->getOperand(0);
+ MetadataAsValue *VMD = cast<MetadataAsValue>(II->getOperand(1));
+ Type *ElemTy = cast<ConstantAsMetadata>(VMD->getMetadata())->getType();
+ GR->addDeducedElementType(Arg, ElemTy);
+ GR->addDeducedElementType(II, ElemTy);
+ GR->addAssignPtrTypeInstr(Arg, II);
+ }
+ }
+ }
+
if (!CurrF)
HaveFunPtrs =
ST.canUseExtension(SPIRV::Extension::SPV_INTEL_function_pointers);
diff --git a/llvm/lib/Target/SPIRV/SPIRVModuleAnalysis.cpp b/llvm/lib/Target/SPIRV/SPIRVModuleAnalysis.cpp
index 421dbd3c1c968..de47965adebec 100644
--- a/llvm/lib/Target/SPIRV/SPIRVModuleAnalysis.cpp
+++ b/llvm/lib/Target/SPIRV/SPIRVModuleAnalysis.cpp
@@ -141,6 +141,30 @@ getSymbolicOperandRequirements(SPIRV::OperandCategory::OperandCategory Category,
return {false, {}, {}, VersionTuple(), VersionTuple()};
}
+static bool usesPhysicalStorageBuffer(const llvm::Module &M) {
+ for (const llvm::Function &F : M) {
+ for (const llvm::Argument &Arg : F.args()) {
+ if (Arg.getType()->isPointerTy() && Arg.getType()->getPointerAddressSpace() == 1)
+ return true;
+ if (Arg.getType()->isTargetExtTy() && Arg.getType()->getTargetExtName() == "spirv.$TypedPointerType") {
+ if (cast<TargetExtType>(Arg.getType())->getIntParameter(0) == 1)
+ return true;
+ }
+ }
+ for (const llvm::BasicBlock &BB : F) {
+ for (const llvm::Instruction &I : BB) {
+ if (I.getType()->isPointerTy() && I.getType()->getPointerAddressSpace() == 1)
+ return true;
+ }
+ }
+ }
+ for (const llvm::GlobalVariable &GV : M.globals()) {
+ if (GV.getType()->isPointerTy() && GV.getType()->getPointerAddressSpace() == 1)
+ return true;
+ }
+ return false;
+}
+
void SPIRVModuleAnalysis::setBaseInfo(const Module &M) {
MAI.MaxID = 0;
for (int i = 0; i < SPIRV::NUM_MODULE_SECTIONS; i++)
@@ -170,8 +194,11 @@ void SPIRVModuleAnalysis::setBaseInfo(const Module &M) {
: PtrSize == 64 ? SPIRV::AddressingModel::Physical64
: SPIRV::AddressingModel::Logical;
} else {
- // TODO: Add support for PhysicalStorageBufferAddress.
- MAI.Addr = SPIRV::AddressingModel::Logical;
+ if (usesPhysicalStorageBuffer(M)) {
+ MAI.Addr = SPIRV::AddressingModel::PhysicalStorageBuffer64EXT;
+ } else {
+ MAI.Addr = SPIRV::AddressingModel::Logical;
+ }
}
}
// Get the OpenCL version number from metadata.
@@ -1635,6 +1662,10 @@ void addInstrRequirements(const MachineInstr &MI,
auto SC = MI.getOperand(1).getImm();
Reqs.getAndAddRequirements(SPIRV::OperandCategory::StorageClassOperand, SC,
ST);
+ if (SC == static_cast<int64_t>(SPIRV::StorageClass::PhysicalStorageBufferEXT)) {
+ Reqs.addExtension(SPIRV::Extension::SPV_KHR_physical_storage_buffer);
+ Reqs.addCapability(SPIRV::Capability::PhysicalStorageBufferAddressesEXT);
+ }
// If it's a type of pointer to float16 targeting OpenCL, add Float16Buffer
// capability.
if (ST.isShader())
diff --git a/llvm/lib/Target/SPIRV/SPIRVUtils.h b/llvm/lib/Target/SPIRV/SPIRVUtils.h
index 040439f2d6ed7..9430495e808c1 100644
--- a/llvm/lib/Target/SPIRV/SPIRVUtils.h
+++ b/llvm/lib/Target/SPIRV/SPIRVUtils.h
@@ -375,9 +375,16 @@ inline bool isUntypedPointerTy(const Type *T) {
return T && T->getTypeID() == Type::PointerTyID;
}
-// True if this is an instance of PointerType or TypedPointerType.
+// True if this is an instance of TargetExtType representing spirv.$TypedPointerType.
+inline bool isTargetExtPointerTy(const Type *T) {
+ if (!T || T->getTypeID() != Type::TargetExtTyID)
+ return false;
+ return cast<TargetExtType>(T)->getName() == "spirv.$TypedPointerType";
+}
+
+// True if this is an instance of PointerType or TypedPointerType or TargetExtType pointer.
inline bool isPointerTy(const Type *T) {
- return isUntypedPointerTy(T) || isTypedPointerTy(T);
+ return isUntypedPointerTy(T) || isTypedPointerTy(T) || isTargetExtPointerTy(T);
}
// True if this is a vector whose element type is an (untyped) PointerType.
@@ -387,12 +394,15 @@ inline bool isUntypedPointerVectorTy(const Type *T) {
}
// Get the address space of this pointer or pointer vector type for instances of
-// PointerType or TypedPointerType.
+// PointerType, TypedPointerType, or TargetExtType pointer.
inline unsigned getPointerAddressSpace(const Type *T) {
Type *SubT = T->getScalarType();
- return SubT->getTypeID() == Type::PointerTyID
- ? cast<PointerType>(SubT)->getAddressSpace()
- : cast<TypedPointerType>(SubT)->getAddressSpace();
+ if (SubT->getTypeID() == Type::PointerTyID)
+ return cast<PointerType>(SubT)->getAddressSpace();
+ if (SubT->getTypeID() == Type::TargetExtTyID &&
+ cast<TargetExtType>(SubT)->getName() == "spirv.$TypedPointerType")
+ return cast<TargetExtType>(SubT)->getIntParameter(0);
+ return cast<TypedPointerType>(SubT)->getAddressSpace();
}
// Return true if the Argument is decorated with a pointee type
>From 8e933298f96697592a280a46455120277c9fc0a4 Mon Sep 17 00:00:00 2001
From: Pham Quang Ha <ha.phamquang.dev at gmail.com>
Date: Tue, 18 Aug 2026 13:13:39 +0700
Subject: [PATCH 6/6] spirv: Add LIT test for Vulkan buffer logical addressing
and block struct wrapping
---
.../physical-storage-buffer-load-store.ll | 57 +++++++++++++++++++
1 file changed, 57 insertions(+)
create mode 100644 llvm/test/CodeGen/SPIRV/pointers/physical-storage-buffer-load-store.ll
diff --git a/llvm/test/CodeGen/SPIRV/pointers/physical-storage-buffer-load-store.ll b/llvm/test/CodeGen/SPIRV/pointers/physical-storage-buffer-load-store.ll
new file mode 100644
index 0000000000000..994b3600225a2
--- /dev/null
+++ b/llvm/test/CodeGen/SPIRV/pointers/physical-storage-buffer-load-store.ll
@@ -0,0 +1,57 @@
+; Test: Vulkan compute shader buffer access uses OpAccessChain (logical addressing)
+; instead of OpPtrAccessChain (physical addressing).
+;
+; Before the fix in SPIRVSubtarget.h, isLogicalSPIRV() returned false for
+; Vulkan shaders, so the backend generated OpPtrAccessChain (OpenCL style).
+; After the fix, isLogicalSPIRV() returns true when isShader() is true,
+; so the backend correctly uses OpAccessChain (Vulkan/GLSL style).
+;
+; Also verifies that the VulkanBuffer element type is wrapped in a Block struct
+; (fixed in SPIRVGlobalRegistry.cpp). The buffer descriptor must be:
+; OpTypeStruct { OpTypeRuntimeArray { OpTypeStruct { float } } }
+; not just a raw pointer to float.
+
+; RUN: llc -verify-machineinstrs -O0 -mtriple=spirv-unknown-vulkan1.3-compute %s -o - | FileCheck %s
+; RUN: %if spirv-tools %{ llc -O0 -mtriple=spirv-unknown-vulkan1.3-compute %s -o - -filetype=obj | spirv-val %}
+
+; CHECK-DAG: %[[#FLOAT:]] = OpTypeFloat 32
+; --- VulkanBuffer must wrap element in a struct (Block), not expose raw float ---
+; CHECK-DAG: %[[#ELEM_WRAP:]] = OpTypeStruct %[[#FLOAT]]
+; CHECK-DAG: %[[#RTARR:]] = OpTypeRuntimeArray %[[#ELEM_WRAP]]
+; CHECK-DAG: %[[#BUF_TY:]] = OpTypeStruct %[[#RTARR]]
+
+; --- Access must use OpAccessChain, NOT OpPtrAccessChain ---
+; CHECK: OpAccessChain
+; CHECK-NOT: OpPtrAccessChain
+
+%struct.elem = type { float }
+
+define void @main() #0 {
+entry:
+ ; Bind a VulkanBuffer of floats at set=0, binding=0
+ %buf = call target("spirv.VulkanBuffer", [0 x %struct.elem], 12, 0)
+ @llvm.spv.resource.handlefrombinding.tspirv.VulkanBuffer_a0s_struct.elems_12_0t(
+ i32 0, i32 0, i32 1, i32 0, ptr null)
+
+ ; Get pointer to element [0] of the buffer
+ %ptr = call noundef align 4 dereferenceable(4) ptr addrspace(11)
+ @llvm.spv.resource.getpointer.p11.tspirv.VulkanBuffer_a0s_struct.elems_12_0t(
+ target("spirv.VulkanBuffer", [0 x %struct.elem], 12, 0) %buf, i32 0)
+
+ ; Load the float value
+ %val = load float, ptr addrspace(11) %ptr, align 4
+
+ ; Store it back (write back test)
+ store float %val, ptr addrspace(11) %ptr, align 4
+
+ ret void
+}
+
+declare target("spirv.VulkanBuffer", [0 x %struct.elem], 12, 0)
+ @llvm.spv.resource.handlefrombinding.tspirv.VulkanBuffer_a0s_struct.elems_12_0t(i32, i32, i32, i32, ptr)
+
+declare ptr addrspace(11)
+ @llvm.spv.resource.getpointer.p11.tspirv.VulkanBuffer_a0s_struct.elems_12_0t(
+ target("spirv.VulkanBuffer", [0 x %struct.elem], 12, 0), i32)
+
+attributes #0 = { "hlsl.numthreads"="1,1,1" "hlsl.shader"="compute" }
More information about the llvm-commits
mailing list