Support subgroup block read/write builtins translation with untyped pointers (#3458)

`SPV_KHR_untyped_pointers` does not modify
[`SPV_INTEL_subgroups`](https://github.khronos.org/SPIRV-Registry/extensions/INTEL/SPV_INTEL_subgroups.html)
extension, meaning we should preserve typed logic for the pointers used
in subgroup instructions
(pointers are used only in `OpSubgroupBlockReadINTEL` and
`OpSubgroupBlockWriteINTEL`).

Original commit:
KhronosGroup/SPIRV-LLVM-Translator@81d49784bc32658

Author: vmaksimo

llvm-spirv/lib/SPIRV/SPIRVReader.cpp

@@ -2415,13 +2415,18 @@ Value *SPIRVToLLVM::transValueWithoutDecoration(SPIRVValue *BV, Function *F,
          BaseSPVTy->isTypeCooperativeMatrixKHR())) {
       return mapValue(BV, transSPIRVBuiltinFromInst(AC, BB));
     }
-    Type *BaseTy =
-        BaseSPVTy->isTypeVector()
-            ? transType(
-                  BaseSPVTy->getVectorComponentType()->getPointerElementType())
-        : BaseSPVTy->isTypePointer()
-            ? transType(BaseSPVTy->getPointerElementType())
-            : transType(BaseSPVTy);
+    Type *BaseTy = nullptr;
+    if (BaseSPVTy->isTypeVector()) {
+      auto *VecCompTy = BaseSPVTy->getVectorComponentType();
+      if (VecCompTy->isTypePointer())
+        BaseTy = transType(VecCompTy->getPointerElementType());
+      else
+        BaseTy = transType(VecCompTy);
+    } else if (BaseSPVTy->isTypePointer()) {
+      BaseTy = transType(BaseSPVTy->getPointerElementType());
+    } else {
+      BaseTy = transType(BaseSPVTy);
+    }
     auto Index = transValue(AC->getIndices(), F, BB);
     if (!AC->hasPtrIndex())
       Index.insert(Index.begin(), getInt32(M, 0));

llvm-spirv/lib/SPIRV/SPIRVWriter.cpp

@@ -7181,6 +7181,18 @@ LLVMToSPIRVBase::transBuiltinToInstWithoutDecoration(Op OC, CallInst *CI,
       return BM->addBinaryInst(OC, transScavengedType(CI),
                                transValue(CI->getArgOperand(0), BB),
                                transValue(CI->getArgOperand(1), BB), BB);
+    } else if (OC == OpSubgroupBlockReadINTEL) {
+      SPIRVType *RetTy = transScavengedType(CI);
+      SPIRVValue *Ptr = transValue(CI->getArgOperand(0), BB);
+
+      if (Ptr->getType()->getPointerElementType() != RetTy &&
+          Ptr->getType()->getPointerElementType()->isTypeUntypedPointerKHR()) {
+        // Bitcast untyped pointer to typed pointer.
+        SPIRVType *ExpectedType = BM->addPointerType(
+            Ptr->getType()->getPointerStorageClass(), RetTy->getScalarType());
+        Ptr = BM->addUnaryInst(OpBitcast, ExpectedType, Ptr, BB);
+      }
+      return BM->addUnaryInst(OC, RetTy, Ptr, BB);
     } else if (CI->arg_size() == 1 && !CI->getType()->isVoidTy() &&
                !hasExecScope(OC) && !isAtomicOpCode(OC)) {
       return BM->addUnaryInst(OC, transScavengedType(CI),
@@ -7232,6 +7244,22 @@ LLVMToSPIRVBase::transBuiltinToInstWithoutDecoration(Op OC, CallInst *CI,
           SPArgs.push_back(cast<ConstantInt>(Args[I])->getZExtValue());
         }
       }
+      if (OC == OpSubgroupBlockWriteINTEL) {
+        // First argument should be a pointer to the same scalar type as the
+        // second argument's component type is. Do the bitcast if the pointer is
+        // untyped.
+        if (BM->getValue(SPArgs[0])->getType()->isTypeUntypedPointerKHR()) {
+          // TODO: rewrite vector of IDs to vector of values?
+          SPIRVType *ScalarTy =
+              BM->getValue(SPArgs[1])->getType()->getScalarType();
+          SPIRVType *NewPtrTy = BM->addPointerType(
+              BM->getValue(SPArgs[0])->getType()->getPointerStorageClass(),
+              ScalarTy);
+          SPIRVValue *NewPtr = BM->addUnaryInst(OpBitcast, NewPtrTy,
+                                                BM->getValue(SPArgs[0]), BB);
+          SPArgs[0] = NewPtr->getId();
+        }
+      }
       BM->addInstTemplate(SPI, SPArgs, BB, SPRetTy);
       if (!SPRetTy || !SPRetTy->isTypeStruct())
         return SPI;

llvm-spirv/test/extensions/INTEL/SPV_INTEL_subgroups/cl_intel_sub_groups.ll

@@ -52,6 +52,13 @@
 ; RUN: llvm-dis < %t.rev.bc | FileCheck %s --check-prefix=CHECK-LLVM-SPIRV
 ; RUN: llvm-spirv %t.rev.bc -o - -spirv-text --spirv-ext=+SPV_INTEL_subgroups | FileCheck %s --check-prefix=CHECK-SPIRV
 
+; Verify the mangling works correctly with the untyped pointers enabled.
+; RUN: llvm-spirv %s -o %t.spv --spirv-ext=+SPV_INTEL_subgroups,+SPV_KHR_untyped_pointers
+; RUN: llvm-spirv -r %t.spv -o %t.rev.bc
+; RUN: llvm-dis < %t.rev.bc | FileCheck %s --check-prefix=CHECK-LLVM-UNTYPED
+; RUN: llvm-spirv -r %t.spv -o %t.rev.bc --spirv-target-env=SPV-IR
+; RUN: llvm-dis < %t.rev.bc | FileCheck %s --check-prefix=CHECK-LLVM-SPIRV
+
 ; CHECK-SPIRV: Capability SubgroupShuffleINTEL
 ; CHECK-SPIRV: Capability SubgroupBufferBlockIOINTEL
 ; CHECK-SPIRV: Capability SubgroupImageBlockIOINTEL
@@ -138,6 +145,36 @@ define spir_kernel void @test(<2 x float> %x, i32 %c, ptr addrspace(1) %image_in
 ; CHECK-LLVM-NEXT:    call spir_func void @_Z32intel_sub_group_block_write_us16PU3AS1tDv16_t(ptr addrspace(1) [[SP]], <16 x i16> [[CALL15]])
 ; CHECK-LLVM-NEXT:    ret void
 
+; The checks are the same as above, just skipping function parameters name check (because bitcasts in between instructions are involved).
+; CHECK-LLVM-UNTYPED: call spir_func <2 x float> @_Z23intel_sub_group_shuffleDv2_fj(<2 x float> [[X:%.*]], i32 [[C:%.*]])
+; CHECK-LLVM-UNTYPED: call spir_func <2 x float> @_Z28intel_sub_group_shuffle_downDv2_fS_j(<2 x float> [[X]], <2 x float> [[X]], i32 [[C]])
+; CHECK-LLVM-UNTYPED: call spir_func <2 x float> @_Z26intel_sub_group_shuffle_upDv2_fS_j(<2 x float> [[X]], <2 x float> [[X]], i32 [[C]])
+; CHECK-LLVM-UNTYPED: call spir_func <2 x float> @_Z27intel_sub_group_shuffle_xorDv2_fj(<2 x float> [[X]], i32 [[C]])
+; CHECK-LLVM-UNTYPED: call spir_func <2 x i32> @_Z27intel_sub_group_block_read214ocl_image2d_roDv2_i(target("spirv.Image", void, 1, 0, 0, 0, 0, 0, 0) [[IMAGE_IN:%.*]], <2 x i32> [[COORD:%.*]])
+; CHECK-LLVM-UNTYPED: call spir_func void @_Z28intel_sub_group_block_write214ocl_image2d_woDv2_iDv2_j(target("spirv.Image", void, 1, 0, 0, 0, 0, 0, 1) [[IMAGE_OUT:%.*]], <2 x i32> [[COORD]], <2 x i32> {{%.*}})
+; CHECK-LLVM-UNTYPED: call spir_func <2 x i32> @_Z27intel_sub_group_block_read2PU3AS1Kj(ptr addrspace(1) {{%.*}})
+; CHECK-LLVM-UNTYPED: call spir_func void @_Z28intel_sub_group_block_write2PU3AS1jDv2_j(ptr addrspace(1) {{%.*}}, <2 x i32> {{%.*}})
+; CHECK-LLVM-UNTYPED: call spir_func <2 x i16> @_Z30intel_sub_group_block_read_us214ocl_image2d_roDv2_i(target("spirv.Image", void, 1, 0, 0, 0, 0, 0, 0) [[IMAGE_IN]], <2 x i32> [[COORD]])
+; CHECK-LLVM-UNTYPED: call spir_func void @_Z31intel_sub_group_block_write_us214ocl_image2d_woDv2_iDv2_t(target("spirv.Image", void, 1, 0, 0, 0, 0, 0, 1) [[IMAGE_OUT]], <2 x i32> [[COORD]], <2 x i16> {{%.*}})
+; CHECK-LLVM-UNTYPED: call spir_func <2 x i16> @_Z30intel_sub_group_block_read_us2PU3AS1Kt(ptr addrspace(1) {{%.*}})
+; CHECK-LLVM-UNTYPED: call spir_func void @_Z31intel_sub_group_block_write_us2PU3AS1tDv2_t(ptr addrspace(1) {{%.*}}, <2 x i16> {{%.*}})
+; CHECK-LLVM-UNTYPED: call spir_func <2 x i8> @_Z30intel_sub_group_block_read_uc214ocl_image2d_roDv2_i(target("spirv.Image", void, 1, 0, 0, 0, 0, 0, 0) [[IMAGE_IN]], <2 x i32> [[COORD]])
+; CHECK-LLVM-UNTYPED: call spir_func void @_Z31intel_sub_group_block_write_uc214ocl_image2d_woDv2_iDv2_h(target("spirv.Image", void, 1, 0, 0, 0, 0, 0, 1) [[IMAGE_OUT]], <2 x i32> [[COORD]], <2 x i8> {{%.*}})
+; CHECK-LLVM-UNTYPED: call spir_func <2 x i8> @_Z30intel_sub_group_block_read_uc2PU3AS1Kh(ptr addrspace(1) {{%.*}})
+; CHECK-LLVM-UNTYPED: call spir_func void @_Z31intel_sub_group_block_write_uc2PU3AS1hDv2_h(ptr addrspace(1) {{%.*}}, <2 x i8> {{%.*}})
+; CHECK-LLVM-UNTYPED: call spir_func <2 x i64> @_Z30intel_sub_group_block_read_ul214ocl_image2d_roDv2_i(target("spirv.Image", void, 1, 0, 0, 0, 0, 0, 0) [[IMAGE_IN]], <2 x i32> [[COORD]])
+; CHECK-LLVM-UNTYPED: call spir_func void @_Z31intel_sub_group_block_write_ul214ocl_image2d_woDv2_iDv2_m(target("spirv.Image", void, 1, 0, 0, 0, 0, 0, 1) [[IMAGE_OUT]], <2 x i32> [[COORD]], <2 x i64> {{%.*}})
+; CHECK-LLVM-UNTYPED: call spir_func <2 x i64> @_Z30intel_sub_group_block_read_ul2PU3AS1Km(ptr addrspace(1) {{%.*}})
+; CHECK-LLVM-UNTYPED: call spir_func void @_Z31intel_sub_group_block_write_ul2PU3AS1mDv2_m(ptr addrspace(1) {{%.*}}, <2 x i64> {{%.*}})
+; CHECK-LLVM-UNTYPED: call spir_func <16 x i8> @_Z31intel_sub_group_block_read_uc1614ocl_image2d_roDv2_i(target("spirv.Image", void, 1, 0, 0, 0, 0, 0, 0) [[IMAGE_IN]], <2 x i32> [[COORD]])
+; CHECK-LLVM-UNTYPED: call spir_func void @_Z32intel_sub_group_block_write_uc1614ocl_image2d_woDv2_iDv16_h(target("spirv.Image", void, 1, 0, 0, 0, 0, 0, 1) [[IMAGE_OUT]], <2 x i32> [[COORD]], <16 x i8> {{%.*}})
+; CHECK-LLVM-UNTYPED: call spir_func <16 x i8> @_Z31intel_sub_group_block_read_uc16PU3AS1Kh(ptr addrspace(1) {{%.*}})
+; CHECK-LLVM-UNTYPED: call spir_func void @_Z32intel_sub_group_block_write_uc16PU3AS1hDv16_h(ptr addrspace(1) {{%.*}}, <16 x i8> {{%.*}})
+; CHECK-LLVM-UNTYPED: call spir_func <16 x i16> @_Z31intel_sub_group_block_read_us1614ocl_image2d_roDv2_i(target("spirv.Image", void, 1, 0, 0, 0, 0, 0, 0) [[IMAGE_IN]], <2 x i32> [[COORD]])
+; CHECK-LLVM-UNTYPED: call spir_func void @_Z32intel_sub_group_block_write_us1614ocl_image2d_woDv2_iDv16_t(target("spirv.Image", void, 1, 0, 0, 0, 0, 0, 1) [[IMAGE_OUT]], <2 x i32> [[COORD]], <16 x i16> {{%.*}})
+; CHECK-LLVM-UNTYPED: call spir_func <16 x i16> @_Z31intel_sub_group_block_read_us16PU3AS1Kt(ptr addrspace(1) {{%.*}})
+; CHECK-LLVM-UNTYPED: call spir_func void @_Z32intel_sub_group_block_write_us16PU3AS1tDv16_t(ptr addrspace(1) {{%.*}}, <16 x i16> {{%.*}})
+
 ; CHECK-LLVM-SPIRV: call spir_func <2 x float> @_Z28__spirv_SubgroupShuffleINTELDv2_fj(
 ; CHECK-LLVM-SPIRV: call spir_func <2 x float> @_Z32__spirv_SubgroupShuffleDownINTELDv2_fS_j(
 ; CHECK-LLVM-SPIRV: call spir_func <2 x float> @_Z30__spirv_SubgroupShuffleUpINTELDv2_fS_j(

llvm-spirv/test/extensions/INTEL/SPV_INTEL_subgroups/untyped_read_write.ll

@@ -0,0 +1,77 @@
+; This test checks the translation of SPV_INTEL_subgroups extension with the SPV_KHR_untyped_pointers extension.
+; It verifies instructions validity and mangling even if the pointer is fortified with other instructions like bitcast and addrspacecast.
+
+; RUN: llvm-spirv %s -o %t.spt -spirv-text --spirv-ext=+SPV_INTEL_subgroups,+SPV_KHR_untyped_pointers
+; RUN: FileCheck < %t.spt %s --check-prefix=CHECK-SPIRV
+; RUN: llvm-spirv %s -o %t.spv --spirv-ext=+SPV_INTEL_subgroups,+SPV_KHR_untyped_pointers
+; RUN: spirv-val %t.spv
+; RUN: llvm-spirv -r %t.spv -o %t.rev.bc
+; RUN: llvm-dis < %t.rev.bc | FileCheck %s --check-prefix=CHECK-LLVM
+; RUN: llvm-spirv -r %t.spv -o %t.rev.bc --spirv-target-env=SPV-IR
+; RUN: llvm-dis < %t.rev.bc | FileCheck %s --check-prefix=CHECK-LLVM-SPIRV
+
+target datalayout = "e-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-v512:512-v1024:1024"
+target triple = "spir64"
+
+; CHECK-SPIRV: Capability SubgroupBufferBlockIOINTEL
+; CHECK-SPIRV: Extension "SPV_INTEL_subgroups"
+
+; CHECK-SPIRV: TypeInt [[#Int32:]] 32 0
+; CHECK-SPIRV-DAG: TypeVector [[#IntVec2:]] [[#Int32]] 2
+; CHECK-SPIRV-DAG: TypeUntypedPointerKHR [[#PtrTy:]] 5
+; CHECK-SPIRV-DAG: TypePointer [[#Int32Ptr:]] 5 [[#Int32]]
+
+; CHECK-SPIRV: Function
+; CHECK-SPIRV: FunctionParameter [[#PtrTy]] [[#ParamPtr:]]
+
+; CHECK-SPIRV: Bitcast [[#Int32Ptr]] [[#TypedPtr:]] [[#]]
+; CHECK-SPIRV: SubgroupBlockReadINTEL [[#IntVec2]] [[#Res:]] [[#TypedPtr]]
+; CHECK-SPIRV: Bitcast [[#Int32Ptr]] [[#TypedPtr:]] [[#ParamPtr]]
+; CHECK-SPIRV: SubgroupBlockWriteINTEL [[#TypedPtr]] [[#Res]]
+
+; CHECK-SPIRV: SubgroupBlockReadINTEL
+; CHECK-SPIRV: SubgroupBlockWriteINTEL
+
+; CHECK-LLVM:    %[[#IntVec:]] = call spir_func <2 x i32> @_Z27intel_sub_group_block_read2PU3AS1Kj(ptr addrspace(1) %[[#]])
+; CHECK-LLVM:    %[[#P:]] = bitcast ptr addrspace(1) %p0 to ptr addrspace(1)
+; CHECK-LLVM:    call spir_func void @_Z28intel_sub_group_block_write2PU3AS1jDv2_j(ptr addrspace(1) %[[#P]], <2 x i32> %[[#IntVec]])
+
+; CHECK-LLVM:    %[[#CP:]] = bitcast ptr addrspace(1) %p1 to ptr addrspace(1)
+; CHECK-LLVM:    %[[#CharVec:]] = call spir_func <16 x i8> @_Z31intel_sub_group_block_read_uc16PU3AS1Kh(ptr addrspace(1) %[[#CP]])
+; CHECK-LLVM:    %[[#CP1:]] = bitcast ptr addrspace(1) %p1 to ptr addrspace(1)
+; CHECK-LLVM:    call spir_func void @_Z32intel_sub_group_block_write_uc16PU3AS1hDv16_h(ptr addrspace(1) %[[#CP1]], <16 x i8> %[[#CharVec]])
+
+; CHECK-LLVM-SPIRV: call spir_func <2 x i32> @_Z36__spirv_SubgroupBlockReadINTEL_Rint2PU3AS1Kj(
+; CHECK-LLVM-SPIRV: call spir_func void @_Z31__spirv_SubgroupBlockWriteINTELPU3AS1jDv2_j(
+; CHECK-LLVM-SPIRV: call spir_func <16 x i8> @_Z38__spirv_SubgroupBlockReadINTEL_Rchar16PU3AS1Kh(
+; CHECK-LLVM-SPIRV: call spir_func void @_Z31__spirv_SubgroupBlockWriteINTELPU3AS1hDv16_h(
+
+target datalayout = "e-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-v512:512-v1024:1024"
+target triple = "spir64"
+
+define spir_kernel void @test_subgroup_block_read_write(ptr addrspace(1) %p0, ptr addrspace(1) %p1) {
+
+entry:
+  %0 = addrspacecast ptr addrspace(1) %p0 to ptr addrspace(4)
+  %1 = call spir_func ptr addrspace(1) @__to_global(ptr addrspace(4) %0)
+  %2 = tail call spir_func <2 x i32> @_Z27intel_sub_group_block_read2PU3AS1Kj(ptr addrspace(1) %1)
+  tail call spir_func void @_Z28intel_sub_group_block_write2PU3AS1jDv2_j(ptr addrspace(1) %p0, <2 x i32> %2)
+
+  %3 = tail call spir_func <16 x i8> @_Z31intel_sub_group_block_read_uc16PU3AS1Kh(ptr addrspace(1) %p1)
+  tail call spir_func void @_Z32intel_sub_group_block_write_uc16PU3AS1hDv16_h(ptr addrspace(1) %p1, <16 x i8> %3)
+
+  ret void
+}
+
+declare spir_func <2 x i32> @_Z27intel_sub_group_block_read2PU3AS1Kj(ptr addrspace(1))
+declare spir_func <16 x i8> @_Z31intel_sub_group_block_read_uc16PU3AS1Kh(ptr addrspace(1))
+
+declare spir_func void @_Z28intel_sub_group_block_write2PU3AS1jDv2_j(ptr addrspace(1), <2 x i32>)
+declare spir_func void @_Z32intel_sub_group_block_write_uc16PU3AS1hDv16_h(ptr addrspace(1), <16 x i8>)
+
+declare spir_func ptr addrspace(1) @__to_global(ptr addrspace(4))
+
+!opencl.ocl.version = !{!0}
+!opencl.spir.version = !{!0}
+
+!0 = !{i32 1, i32 2}