[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