[mlir][spirv] Add client-api option to -convert-spirv-to-llvm

[victor-eds]

Summary

Option to express that spirv StorageClasses should be mapped to LLVM
address spaces in the conversion process. This mapping will be
client-dependent.

The client API cannot be taken from the code as more than one module
could be present, resulting in more than one VCE triple and different
StorageClass to address space mappings. This information would not be
available during type conversion.

A specific mapping for the OpenCL client is defined, based on the OpenCL Extended Instruction Set
and this mapping.

Signed-off-by: Victor Perez <[e-mail]>

[kuhar]

LGTM but please wait for thumbs up from @antiagainst before submitting

mlir/lib/Conversion/SPIRVToLLVM/SPIRVToLLVM.cpp

36

nit: could you confirm that this name conforms with the coding style? In other spir-v-related code I saw kVariableName used, but I think a more general policy is VariableName?
nit: static is redundant here, constexpr in the namespace/global scope already has internal linkage

[mehdi_amini]

mlir/lib/Conversion/SPIRVToLLVM/SPIRVToLLVM.cpp

36

This is conform to MLIR coding style I believe. The k prefix is a habit from googlers, and VariableName is the general LLVM convention that MLIR diverges from (for historical reasons).

[victor-eds]

Drop static

[victor-eds]

mlir/lib/Conversion/SPIRVToLLVM/SPIRVToLLVM.cpp

36

Nice catch. Dropped static

mlir/include/mlir/Conversion/Passes.td

let description = [{
     See https://mlir.llvm.org/docs/SPIRVToLLVMDialectConversion/
     for more details.
   }];
   let dependentDialects = ["LLVM::LLVMDialect"];
 
   let options = [
     Option<"useOpaquePointers", "use-opaque-pointers", "bool",
                  /*default=*/"true", "Generate LLVM IR using opaque pointers "
-                 "instead of typed pointers">
+                 "instead of typed pointers">,
+    Option<"clientAPI", "client-api", "::mlir::spirv::ClientAPI",
+     /*default=*/"::mlir::spirv::ClientAPI::Unknown",
+     "Derive StorageClass to address space mapping from the client API",
+     [{::llvm::cl::values(
+       clEnumValN(::mlir::spirv::ClientAPI::Unknown, "Unknown", "Unknown (default)"),
+       clEnumValN(::mlir::spirv::ClientAPI::Metal, "Metal", "Metal"),
+       clEnumValN(::mlir::spirv::ClientAPI::OpenCL, "OpenCL", "OpenCL"),
+       clEnumValN(::mlir::spirv::ClientAPI::Vulkan, "Vulkan", "Vulkan"),
+       clEnumValN(::mlir::spirv::ClientAPI::WebGPU, "WebGPU", "WebGPU")
+     )}]>,
   ];
 }
 
 //===----------------------------------------------------------------------===//
 // TensorToLinalg
 //===----------------------------------------------------------------------===//
 
 def ConvertTensorToLinalg : Pass<"convert-tensor-to-linalg", "ModuleOp"> {

mlir/include/mlir/Conversion/SPIRVToLLVM/SPIRVToLLVM.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_CONVERSION_SPIRVTOLLVM_SPIRVTOLLVM_H
 #define MLIR_CONVERSION_SPIRVTOLLVM_SPIRVTOLLVM_H
 
 #include "mlir/Transforms/DialectConversion.h"
 
+#include "mlir/Dialect/SPIRV/IR/SPIRVEnums.h"
+
 namespace mlir {
 class LLVMTypeConverter;
 class MLIRContext;
 class ModuleOp;
 
 template <typename SPIRVOp>
 class SPIRVToLLVMConversion : public OpConversionPattern<SPIRVOp> {
 public:
   SPIRVToLLVMConversion(MLIRContext *context, LLVMTypeConverter &typeConverter,
                         PatternBenefit benefit = 1)
       : OpConversionPattern<SPIRVOp>(typeConverter, context, benefit),
         typeConverter(typeConverter) {}
 
 protected:
   LLVMTypeConverter &typeConverter;
 };
 
 /// Encodes global variable's descriptor set and binding into its name if they
 /// both exist.
 void encodeBindAttribute(ModuleOp module);
 
 /// Populates type conversions with additional SPIR-V types.
-void populateSPIRVToLLVMTypeConversion(LLVMTypeConverter &typeConverter);
+void populateSPIRVToLLVMTypeConversion(
+    LLVMTypeConverter &typeConverter,
+    spirv::ClientAPI clientAPIForAddressSpaceMapping =
+        spirv::ClientAPI::Unknown);
 
 /// Populates the given list with patterns that convert from SPIR-V to LLVM.
-void populateSPIRVToLLVMConversionPatterns(LLVMTypeConverter &typeConverter,
-                                           RewritePatternSet &patterns);
+void populateSPIRVToLLVMConversionPatterns(
+    LLVMTypeConverter &typeConverter, RewritePatternSet &patterns,
+    spirv::ClientAPI clientAPIForAddressSpaceMapping =
+        spirv::ClientAPI::Unknown);
 
 /// Populates the given list with patterns for function conversion from SPIR-V
 /// to LLVM.
 void populateSPIRVToLLVMFunctionConversionPatterns(
     LLVMTypeConverter &typeConverter, RewritePatternSet &patterns);
 
 /// Populates the given patterns for module conversion from SPIR-V to LLVM.
 void populateSPIRVToLLVMModuleConversionPatterns(
     LLVMTypeConverter &typeConverter, RewritePatternSet &patterns);
 
 } // namespace mlir
 
 #endif // MLIR_CONVERSION_SPIRVTOLLVM_SPIRVTOLLVM_H

mlir/include/mlir/Conversion/SPIRVToLLVM/SPIRVToLLVMPass.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_CONVERSION_SPIRVTOLLVM_SPIRVTOLLVMPASS_H
 #define MLIR_CONVERSION_SPIRVTOLLVM_SPIRVTOLLVMPASS_H
 
 #include <memory>
 
+#include "mlir/Dialect/SPIRV/IR/SPIRVEnums.h"
+
 namespace mlir {
 class Pass;
 
 #define GEN_PASS_DECL_LOWERHOSTCODETOLLVMPASS
 #define GEN_PASS_DECL_CONVERTSPIRVTOLLVMPASS
 #include "mlir/Conversion/Passes.h.inc"
 
 } // namespace mlir
 
 #endif // MLIR_CONVERSION_SPIRVTOLLVM_SPIRVTOLLVMPASS_H

mlir/lib/Conversion/SPIRVToLLVM/SPIRVToLLVM.cpp

 #include "llvm/Support/Debug.h"
 #include "llvm/Support/FormatVariadic.h"
 
 #define DEBUG_TYPE "spirv-to-llvm-pattern"
 
 using namespace mlir;
 
 //===----------------------------------------------------------------------===//
+// Constants
+//===----------------------------------------------------------------------===//
+
+static constexpr unsigned defaultAddressSpace = 0;
+
+//===----------------------------------------------------------------------===//
 // Utility functions
 //===----------------------------------------------------------------------===//
 
 /// Returns true if the given type is a signed integer or vector type.
 static bool isSignedIntegerOrVector(Type type) {
   if (type.isSignedInteger())
     return true;
   if (auto vecType = dyn_cast<VectorType>(type))
static std::optional<Type> convertArrayType(spirv::ArrayType type,
   if (stride != 0 && (!sizeInBytes || *sizeInBytes != stride))
     return std::nullopt;
 
   auto llvmElementType = converter.convertType(elementType);
   unsigned numElements = type.getNumElements();
   return LLVM::LLVMArrayType::get(llvmElementType, numElements);
 }
 
+static unsigned mapToOpenCLAddressSpace(spirv::StorageClass storageClass) {
+  // Based on
+  // https://registry.khronos.org/SPIR-V/specs/unified1/OpenCL.ExtendedInstructionSet.100.html#_binary_form
+  // and clang/lib/Basic/Targets/SPIR.h.
+  switch (storageClass) {
+#define STORAGE_SPACE_MAP(storage, space)                                      \
+  case spirv::StorageClass::storage:                                           \
+    return space;
+    STORAGE_SPACE_MAP(Function, 0)
+    STORAGE_SPACE_MAP(CrossWorkgroup, 1)
+    STORAGE_SPACE_MAP(Input, 1)
+    STORAGE_SPACE_MAP(UniformConstant, 2)
+    STORAGE_SPACE_MAP(Workgroup, 3)
+    STORAGE_SPACE_MAP(Generic, 4)
+    STORAGE_SPACE_MAP(DeviceOnlyINTEL, 5)
+    STORAGE_SPACE_MAP(HostOnlyINTEL, 6)
+#undef STORAGE_SPACE_MAP
+  default:
+    return defaultAddressSpace;
+  }
+}
+
+static unsigned mapToAddressSpace(spirv::ClientAPI clientAPI,
+                                  spirv::StorageClass storageClass) {
+  switch (clientAPI) {
+#define CLIENT_MAP(client, storage)                                            \
+  case spirv::ClientAPI::client:                                               \
+    return mapTo##client##AddressSpace(storage);
+    CLIENT_MAP(OpenCL, storageClass)
+#undef CLIENT_MAP
+  default:
+    return defaultAddressSpace;
+  }
+}
+
 /// Converts SPIR-V pointer type to LLVM pointer. Pointer's storage class is not
 /// modelled at the moment.
 static Type convertPointerType(spirv::PointerType type,
-                               LLVMTypeConverter &converter) {
+                               LLVMTypeConverter &converter,
+                               spirv::ClientAPI clientAPI) {
   auto pointeeType = converter.convertType(type.getPointeeType());
-  return converter.getPointerType(pointeeType);
+  unsigned addressSpace = mapToAddressSpace(clientAPI, type.getStorageClass());
+  return converter.getPointerType(pointeeType, addressSpace);
 }
 
 /// Converts SPIR-V runtime array to LLVM array. Since LLVM allows indexing over
 /// the bounds, the runtime array is converted to a 0-sized LLVM array. There is
 /// no modelling of array stride at the moment.
 static std::optional<Type> convertRuntimeArrayType(spirv::RuntimeArrayType type,
                                                    TypeConverter &converter) {
   if (type.getArrayStride() != 0)

 
 /// Converts `spirv.GlobalVariable` to `llvm.mlir.global`. Note that SPIR-V
 /// global returns a pointer, whereas in LLVM dialect the global holds an actual
 /// value. This difference is handled by `spirv.mlir.addressof` and
 /// `llvm.mlir.addressof`ops that both return a pointer.
 class GlobalVariablePattern
     : public SPIRVToLLVMConversion<spirv::GlobalVariableOp> {
 public:
-  using SPIRVToLLVMConversion<spirv::GlobalVariableOp>::SPIRVToLLVMConversion;
+  template <typename... Args>
+  GlobalVariablePattern(spirv::ClientAPI clientAPI, Args &&...args)
+      : SPIRVToLLVMConversion<spirv::GlobalVariableOp>(
+            std::forward<Args>(args)...),
+        clientAPI(clientAPI) {}
 
   LogicalResult
   matchAndRewrite(spirv::GlobalVariableOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     // Currently, there is no support of initialization with a constant value in
     // SPIR-V dialect. Specialization constants are not considered as well.
     if (op.getInitializer())
       return failure();
matchAndRewrite(spirv::GlobalVariableOp op, OpAdaptor adaptor,
     // written to export or import functions and global (module scope)
     // variables.". Therefore, map 'Private' storage class to private linkage,
     // 'Input' and 'Output' to external linkage.
     auto linkage = storageClass == spirv::StorageClass::Private
                        ? LLVM::Linkage::Private
                        : LLVM::Linkage::External;
     auto newGlobalOp = rewriter.replaceOpWithNewOp<LLVM::GlobalOp>(
         op, dstType, isConstant, linkage, op.getSymName(), Attribute(),
-        /*alignment=*/0);
+        /*alignment=*/0, mapToAddressSpace(clientAPI, storageClass));
 
     // Attach location attribute if applicable
     if (op.getLocationAttr())
       newGlobalOp->setAttr(op.getLocationAttrName(), op.getLocationAttr());
 
     return success();
   }
+
+private:
+  spirv::ClientAPI clientAPI;
 };
 
 /// Converts SPIR-V cast ops that do not have straightforward LLVM
 /// equivalent in LLVM dialect.
 template <typename SPIRVOp, typename LLVMExtOp, typename LLVMTruncOp>
 class IndirectCastPattern : public SPIRVToLLVMConversion<SPIRVOp> {
 public:
   using SPIRVToLLVMConversion<SPIRVOp>::SPIRVToLLVMConversion;
public:
   }
 };
 } // namespace
 
 //===----------------------------------------------------------------------===//
 // Pattern population
 //===----------------------------------------------------------------------===//
 
-void mlir::populateSPIRVToLLVMTypeConversion(LLVMTypeConverter &typeConverter) {
+void mlir::populateSPIRVToLLVMTypeConversion(LLVMTypeConverter &typeConverter,
+                                             spirv::ClientAPI clientAPI) {
   typeConverter.addConversion([&](spirv::ArrayType type) {
     return convertArrayType(type, typeConverter);
   });
-  typeConverter.addConversion([&](spirv::PointerType type) {
-    return convertPointerType(type, typeConverter);
+  typeConverter.addConversion([&, clientAPI](spirv::PointerType type) {
+    return convertPointerType(type, typeConverter, clientAPI);
   });
   typeConverter.addConversion([&](spirv::RuntimeArrayType type) {
     return convertRuntimeArrayType(type, typeConverter);
   });
   typeConverter.addConversion([&](spirv::StructType type) {
     return convertStructType(type, typeConverter);
   });
 }
 
 void mlir::populateSPIRVToLLVMConversionPatterns(
-    LLVMTypeConverter &typeConverter, RewritePatternSet &patterns) {
+    LLVMTypeConverter &typeConverter, RewritePatternSet &patterns,
+    spirv::ClientAPI clientAPI) {
   patterns.add<
       // Arithmetic ops
       DirectConversionPattern<spirv::IAddOp, LLVM::AddOp>,
       DirectConversionPattern<spirv::IMulOp, LLVM::MulOp>,
       DirectConversionPattern<spirv::ISubOp, LLVM::SubOp>,
       DirectConversionPattern<spirv::FAddOp, LLVM::FAddOp>,
       DirectConversionPattern<spirv::FDivOp, LLVM::FDivOp>,
       DirectConversionPattern<spirv::FMulOp, LLVM::FMulOp>,
patterns.add<
       // Logical ops
       DirectConversionPattern<spirv::LogicalAndOp, LLVM::AndOp>,
       DirectConversionPattern<spirv::LogicalOrOp, LLVM::OrOp>,
       IComparePattern<spirv::LogicalEqualOp, LLVM::ICmpPredicate::eq>,
       IComparePattern<spirv::LogicalNotEqualOp, LLVM::ICmpPredicate::ne>,
       NotPattern<spirv::LogicalNotOp>,
 
       // Memory ops
-      AccessChainPattern, AddressOfPattern, GlobalVariablePattern,
-      LoadStorePattern<spirv::LoadOp>, LoadStorePattern<spirv::StoreOp>,
-      VariablePattern,
+      AccessChainPattern, AddressOfPattern, LoadStorePattern<spirv::LoadOp>,
+      LoadStorePattern<spirv::StoreOp>, VariablePattern,
 
       // Miscellaneous ops
       CompositeExtractPattern, CompositeInsertPattern,
       DirectConversionPattern<spirv::SelectOp, LLVM::SelectOp>,
       DirectConversionPattern<spirv::UndefOp, LLVM::UndefOp>,
       VectorShufflePattern,
 
       // Shift ops
       ShiftPattern<spirv::ShiftRightArithmeticOp, LLVM::AShrOp>,
       ShiftPattern<spirv::ShiftRightLogicalOp, LLVM::LShrOp>,
       ShiftPattern<spirv::ShiftLeftLogicalOp, LLVM::ShlOp>,
 
       // Return ops
       ReturnPattern, ReturnValuePattern>(patterns.getContext(), typeConverter);
+
+  patterns.add<GlobalVariablePattern>(clientAPI, patterns.getContext(),
+                                      typeConverter);
 }
 
 void mlir::populateSPIRVToLLVMFunctionConversionPatterns(
     LLVMTypeConverter &typeConverter, RewritePatternSet &patterns) {
   patterns.add<FuncConversionPattern>(patterns.getContext(), typeConverter);
 }
 
 void mlir::populateSPIRVToLLVMModuleConversionPatterns(

mlir/lib/Conversion/SPIRVToLLVM/SPIRVToLLVMPass.cpp

 //===----------------------------------------------------------------------===//
 
 #include "mlir/Conversion/SPIRVToLLVM/SPIRVToLLVMPass.h"
 
 #include "mlir/Conversion/LLVMCommon/TypeConverter.h"
 #include "mlir/Conversion/SPIRVToLLVM/SPIRVToLLVM.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
+#include "mlir/Dialect/SPIRV/IR/SPIRVEnums.h"
 #include "mlir/Pass/Pass.h"
 
 namespace mlir {
 #define GEN_PASS_DEF_CONVERTSPIRVTOLLVMPASS
 #include "mlir/Conversion/Passes.h.inc"
 } // namespace mlir
 
 using namespace mlir;
void ConvertSPIRVToLLVMPass::runOnOperation() {
 
   LLVMTypeConverter converter(&getContext(), options);
 
   // Encode global variable's descriptor set and binding if they exist.
   encodeBindAttribute(module);
 
   RewritePatternSet patterns(context);
 
-  populateSPIRVToLLVMTypeConversion(converter);
+  populateSPIRVToLLVMTypeConversion(converter, clientAPI);
 
   populateSPIRVToLLVMModuleConversionPatterns(converter, patterns);
-  populateSPIRVToLLVMConversionPatterns(converter, patterns);
+  populateSPIRVToLLVMConversionPatterns(converter, patterns, clientAPI);
   populateSPIRVToLLVMFunctionConversionPatterns(converter, patterns);
 
   ConversionTarget target(*context);
   target.addIllegalDialect<spirv::SPIRVDialect>();
   target.addLegalDialect<LLVM::LLVMDialect>();
 
+  if (clientAPI != spirv::ClientAPI::OpenCL &&
+      clientAPI != spirv::ClientAPI::Unknown)
+    getOperation()->emitWarning()
+        << "address space mapping for client '"
+        << spirv::stringifyClientAPI(clientAPI) << "' not implemented";
+
   // Set `ModuleOp` as legal for `spirv.module` conversion.
   target.addLegalOp<ModuleOp>();
   if (failed(applyPartialConversion(module, target, std::move(patterns))))
     signalPassFailure();
 }

mlir/test/Conversion/SPIRVToLLVM/spirv-storage-class-mapping-unsupported.mlir

+// RUN: mlir-opt -convert-spirv-to-llvm='client-api=Metal' -verify-diagnostics %s
+// RUN: mlir-opt -convert-spirv-to-llvm='client-api=Vulkan' -verify-diagnostics %s
+// RUN: mlir-opt -convert-spirv-to-llvm='client-api=WebGPU' -verify-diagnostics %s
+
+module {}  // expected-warning-re {{address space mapping for client '{{.*}}' not implemented}}

mlir/test/Conversion/SPIRVToLLVM/spirv-storage-class-mapping.mlir

+// RUN: mlir-opt -convert-spirv-to-llvm='use-opaque-pointers=1' -verify-diagnostics %s | FileCheck %s --check-prefixes=CHECK-UNKNOWN,CHECK-ALL
+// RUN: mlir-opt -convert-spirv-to-llvm='use-opaque-pointers=1 client-api=OpenCL' -verify-diagnostics %s | FileCheck %s --check-prefixes=CHECK-OPENCL,CHECK-ALL
+
+// CHECK-OPENCL:         llvm.func @pointerUniformConstant(!llvm.ptr<2>)
+// CHECK-UNKNOWN:        llvm.func @pointerUniformConstant(!llvm.ptr)
+spirv.func @pointerUniformConstant(!spirv.ptr<i1, UniformConstant>) "None"
+
+// CHECK-OPENCL:         llvm.mlir.global external constant @varUniformConstant() {addr_space = 2 : i32} : i1
+// CHECK-UNKNOWN:        llvm.mlir.global external constant @varUniformConstant() {addr_space = 0 : i32} : i1
+spirv.GlobalVariable @varUniformConstant : !spirv.ptr<i1, UniformConstant>
+
+// CHECK-OPENCL:         llvm.func @pointerInput(!llvm.ptr<1>)
+// CHECK-UNKNOWN:        llvm.func @pointerInput(!llvm.ptr)
+spirv.func @pointerInput(!spirv.ptr<i1, Input>) "None"
+
+// CHECK-OPENCL:         llvm.mlir.global external constant @varInput() {addr_space = 1 : i32} : i1
+// CHECK-UNKNOWN:        llvm.mlir.global external constant @varInput() {addr_space = 0 : i32} : i1
+spirv.GlobalVariable @varInput : !spirv.ptr<i1, Input>
+
+// CHECK-ALL:            llvm.func @pointerUniform(!llvm.ptr)
+spirv.func @pointerUniform(!spirv.ptr<i1, Uniform>) "None"
+
+// CHECK-ALL:            llvm.func @pointerOutput(!llvm.ptr)
+spirv.func @pointerOutput(!spirv.ptr<i1, Output>) "None"
+
+// CHECK-ALL:            llvm.mlir.global external @varOutput() {addr_space = 0 : i32} : i1
+spirv.GlobalVariable @varOutput : !spirv.ptr<i1, Output>
+
+// CHECK-OPENCL:         llvm.func @pointerWorkgroup(!llvm.ptr<3>)
+// CHECK-UNKNOWN:        llvm.func @pointerWorkgroup(!llvm.ptr)
+spirv.func @pointerWorkgroup(!spirv.ptr<i1, Workgroup>) "None"
+
+// CHECK-OPENCL:         llvm.func @pointerCrossWorkgroup(!llvm.ptr<1>)
+// CHECK-UNKNOWN:        llvm.func @pointerCrossWorkgroup(!llvm.ptr)
+spirv.func @pointerCrossWorkgroup(!spirv.ptr<i1, CrossWorkgroup>) "None"
+
+// CHECK-ALL:            llvm.func @pointerPrivate(!llvm.ptr)
+spirv.func @pointerPrivate(!spirv.ptr<i1, Private>) "None"
+
+// CHECK-ALL:            llvm.mlir.global private @varPrivate() {addr_space = 0 : i32} : i1
+spirv.GlobalVariable @varPrivate : !spirv.ptr<i1, Private>
+
+// CHECK-ALL:            llvm.func @pointerFunction(!llvm.ptr)
+spirv.func @pointerFunction(!spirv.ptr<i1, Function>) "None"
+
+// CHECK-OPENCL:         llvm.func @pointerGeneric(!llvm.ptr<4>)
+// CHECK-UNKNOWN:         llvm.func @pointerGeneric(!llvm.ptr)
+spirv.func @pointerGeneric(!spirv.ptr<i1, Generic>) "None"
+
+// CHECK-ALL:            llvm.func @pointerPushConstant(!llvm.ptr)
+spirv.func @pointerPushConstant(!spirv.ptr<i1, PushConstant>) "None"
+
+// CHECK-ALL:            llvm.func @pointerAtomicCounter(!llvm.ptr)
+spirv.func @pointerAtomicCounter(!spirv.ptr<i1, AtomicCounter>) "None"
+
+// CHECK-ALL:            llvm.func @pointerImage(!llvm.ptr)
+spirv.func @pointerImage(!spirv.ptr<i1, Image>) "None"
+
+// CHECK-ALL:            llvm.func @pointerStorageBuffer(!llvm.ptr)
+spirv.func @pointerStorageBuffer(!spirv.ptr<i1, StorageBuffer>) "None"
+
+// CHECK-ALL:            llvm.mlir.global external @varStorageBuffer() {addr_space = 0 : i32} : i1
+spirv.GlobalVariable @varStorageBuffer : !spirv.ptr<i1, StorageBuffer>
+
+// CHECK-ALL:            llvm.func @pointerCallableDataKHR(!llvm.ptr)
+spirv.func @pointerCallableDataKHR(!spirv.ptr<i1, CallableDataKHR>) "None"
+
+// CHECK-ALL:            llvm.func @pointerIncomingCallableDataKHR(!llvm.ptr)
+spirv.func @pointerIncomingCallableDataKHR(!spirv.ptr<i1, IncomingCallableDataKHR>) "None"
+
+// CHECK-ALL:            llvm.func @pointerRayPayloadKHR(!llvm.ptr)
+spirv.func @pointerRayPayloadKHR(!spirv.ptr<i1, RayPayloadKHR>) "None"
+
+// CHECK-ALL:            llvm.func @pointerHitAttributeKHR(!llvm.ptr)
+spirv.func @pointerHitAttributeKHR(!spirv.ptr<i1, HitAttributeKHR>) "None"
+
+// CHECK-ALL:            llvm.func @pointerIncomingRayPayloadKHR(!llvm.ptr)
+spirv.func @pointerIncomingRayPayloadKHR(!spirv.ptr<i1, IncomingRayPayloadKHR>) "None"
+
+// CHECK-ALL:            llvm.func @pointerShaderRecordBufferKHR(!llvm.ptr)
+spirv.func @pointerShaderRecordBufferKHR(!spirv.ptr<i1, ShaderRecordBufferKHR>) "None"
+
+// CHECK-ALL:            llvm.func @pointerPhysicalStorageBuffer(!llvm.ptr)
+spirv.func @pointerPhysicalStorageBuffer(!spirv.ptr<i1, PhysicalStorageBuffer>) "None"
+
+// CHECK-ALL:            llvm.func @pointerCodeSectionINTEL(!llvm.ptr)
+spirv.func @pointerCodeSectionINTEL(!spirv.ptr<i1, CodeSectionINTEL>) "None"
+
+// CHECK-OPENCL:         llvm.func @pointerDeviceOnlyINTEL(!llvm.ptr<5>)
+// CHECK-UNKNOWN:        llvm.func @pointerDeviceOnlyINTEL(!llvm.ptr)
+spirv.func @pointerDeviceOnlyINTEL(!spirv.ptr<i1, DeviceOnlyINTEL>) "None"
+
+// CHECK-OPENCL:         llvm.func @pointerHostOnlyINTEL(!llvm.ptr<6>)
+// CHECK-UNKOWN:         llvm.func @pointerHostOnlyINTEL(!llvm.ptr)
+spirv.func @pointerHostOnlyINTEL(!spirv.ptr<i1, HostOnlyINTEL>) "None"