gpuav: Fix Slang doing real pointer math (KhronosGroup#11503)

spencer-lunarg · web-flow · commit 60017849aa74 · 2026-01-18T14:24:45.000-05:00
diff --git a/layers/gpuav/spirv/buffer_device_address_pass.cpp b/layers/gpuav/spirv/buffer_device_address_pass.cpp
@@ -1,4 +1,4 @@
-/* Copyright (c) 2024-2025 LunarG, Inc.
+/* Copyright (c) 2024-2026 LunarG, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -231,8 +231,16 @@ bool BufferDeviceAddressPass::Instrument() {
                         load_type_pointer->inst_.StorageClass() == spv::StorageClassPhysicalStorageBuffer) {
                         const Type* struct_type = type_manager_.FindTypeById(load_type_pointer->inst_.Operand(1));
                         if (struct_type && struct_type->spv_type_ == SpvType::kStruct) {
-                            const uint32_t struct_offset =
-                                FindOffsetInStruct(struct_type->Id(), nullptr, false, access_chain_insts);
+                            uint32_t root_struct_id = struct_type->Id();
+
+                            // GLSL/HLSL will only ever a struct, but for Slang, we might have the first access be the pointer and
+                            // we actually need that outer struct, which "looks" an OpTypePointer with an ArrayStride attached to it
+                            const Instruction* last_access = access_chain_insts.back();
+                            if (!last_access->IsNonPtrAccessChain() && last_access->TypeId() == load_type_pointer->Id()) {
+                                root_struct_id = load_type_pointer->Id();
+                            }
+
+                            const uint32_t struct_offset = FindOffsetInStruct(root_struct_id, nullptr, false, access_chain_insts);
                             if (struct_offset == 0) {
                                 continue;
                             }
diff --git a/layers/gpuav/spirv/pass.cpp b/layers/gpuav/spirv/pass.cpp
@@ -1,4 +1,4 @@
-/* Copyright (c) 2024-2025 LunarG, Inc.
+/* Copyright (c) 2024-2026 LunarG, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -681,16 +681,21 @@ uint32_t Pass::FindOffsetInStruct(uint32_t struct_id, const CooperativeMatrixAcc
 
                 current_type_id = current_type->inst_.Operand(constant_value);  // Get element type for next step
             } break;
+            case SpvType::kPointer: {
+                // So what this means is we have a pointer of structs, found in Slang doing something like
+                //
+                //     struct PerFrame {};
+                //     PerFrame* bufPerFrame;
+                //
+                // And the first PtrAccessChain is going to try and index into.
+                // There should be ArrayStride to know how large the Struct is
+                const uint32_t array_stride = GetDecoration(current_type_id, spv::DecorationArrayStride)->Word(3);
+                current_offset = constant_value * array_stride;
+
+                current_type_id = current_type->inst_.Word(3);  // Get pointer type
+            } break;
             default: {
-                // A non-composite implies that this must be the end of the access-chain chain
-                auto next_access_chain_iter = (access_chain_iter)+1;
-                if (next_access_chain_iter != access_chain_insts.rend())
-                {
-                    module_.InternalError(Name(), "FindOffsetInStruct has unexpected non-composite type");
-                    break;
-                }
-                const uint32_t type_size = FindTypeByteSize(current_type_id);
-                current_offset = constant_value * type_size;
+                module_.InternalError(Name(), "FindOffsetInStruct has unexpected non-composite type");
             } break;
         }
 
diff --git a/tests/unit/gpu_av_buffer_device_address_positive.cpp b/tests/unit/gpu_av_buffer_device_address_positive.cpp
@@ -1,8 +1,8 @@
 /*
- * Copyright (c) 2020-2025 The Khronos Group Inc.
- * Copyright (c) 2020-2025 Valve Corporation
- * Copyright (c) 2020-2025 LunarG, Inc.
- * Copyright (c) 2020-2025 Google, Inc.
+ * Copyright (c) 2020-2026 The Khronos Group Inc.
+ * Copyright (c) 2020-2026 Valve Corporation
+ * Copyright (c) 2020-2026 LunarG, Inc.
+ * Copyright (c) 2020-2026 Google, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -1381,11 +1381,11 @@ TEST_F(PositiveGpuAVBufferDeviceAddress, MultipleAccessChains) {
     m_default_queue->SubmitAndWait(m_command_buffer);
 }
 
-TEST_F(PositiveGpuAVBufferDeviceAddress, AccessChainStartIsStructEndIsNonComposite) {
-    TEST_DESCRIPTION("Slang will produce a chain of access chains that start with a base of a composite and end on a result type of a non-composite");
-
+TEST_F(PositiveGpuAVBufferDeviceAddress, DescriptorStructPointerSlang) {
+    TEST_DESCRIPTION(
+        "Slang will produce a chain of access chains that start with a base of a composite and end on a result type of a "
+        "non-composite");
     RETURN_IF_SKIP(CheckSlangSupport());
-
     RETURN_IF_SKIP(InitGpuVUBufferDeviceAddress(false));
 
     const char *slang_shader = R"slang(
@@ -1426,6 +1426,121 @@ TEST_F(PositiveGpuAVBufferDeviceAddress, AccessChainStartIsStructEndIsNonComposi
     m_default_queue->SubmitAndWait(m_command_buffer);
 }
 
+TEST_F(PositiveGpuAVBufferDeviceAddress, PushConstantStructPointerSlang) {
+    TEST_DESCRIPTION("https://github.com/KhronosGroup/Vulkan-ValidationLayers/issues/11348");
+    RETURN_IF_SKIP(CheckSlangSupport());
+    SetTargetApiVersion(VK_API_VERSION_1_2);
+    AddRequiredFeature(vkt::Feature::bufferDeviceAddress);
+    AddRequiredFeature(vkt::Feature::shaderDrawParameters);
+    AddRequiredFeature(vkt::Feature::multiview);
+    RETURN_IF_SKIP(InitGpuVUBufferDeviceAddress(false));
+    InitRenderTarget();
+
+    const char *vert_source = R"(
+        float4 operator*(float4x4 a, float4 b) { return mul(b, a); }
+
+        struct PerFrame {
+            uint a;
+            uint b;
+            uint c;
+            uint d;
+            float4x4 proj[2];
+        };
+
+        struct PushConstants {
+            PerFrame* bufPerFrame;
+        };
+
+        [[vk::push_constant]] PushConstants pc;
+
+        struct VSOutput {
+            float4 position : SV_Position;
+        };
+
+        [shader("vertex")]
+            VSOutput main() {
+            PerFrame* perFrame = pc.bufPerFrame;
+
+            VSOutput out;
+            out.position = perFrame[2].proj[1] * float4(50.0);
+
+            return out;
+        }
+    )";
+
+    VkShaderObj vs(*m_device, vert_source, VK_SHADER_STAGE_VERTEX_BIT, SPV_ENV_VULKAN_1_2, SPV_SOURCE_SLANG);
+
+    VkPushConstantRange pc_range = {VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT, 0, 64};
+    const vkt::PipelineLayout pipeline_layout(*m_device, {}, {pc_range});
+
+    CreatePipelineHelper pipe(*this);
+    pipe.gp_ci_.layout = pipeline_layout;
+    pipe.shader_stages_ = {vs.GetStageCreateInfo(), pipe.fs_->GetStageCreateInfo()};
+    pipe.CreateGraphicsPipeline();
+}
+
+TEST_F(PositiveGpuAVBufferDeviceAddress, MultipleStructPointerSlang) {
+    TEST_DESCRIPTION("https://github.com/KhronosGroup/Vulkan-ValidationLayers/issues/11348");
+    RETURN_IF_SKIP(CheckSlangSupport());
+    SetTargetApiVersion(VK_API_VERSION_1_2);
+    AddRequiredFeature(vkt::Feature::bufferDeviceAddress);
+    AddRequiredFeature(vkt::Feature::shaderDrawParameters);
+    AddRequiredFeature(vkt::Feature::multiview);
+    RETURN_IF_SKIP(InitGpuVUBufferDeviceAddress(false));
+    InitRenderTarget();
+
+    const char *vert_source = R"(
+        struct Data {
+            float4 a;
+            float4 b;
+            float4 c;
+            float4 d;
+        }
+
+        struct PerFrame {
+            Data proj[4];
+        };
+
+        struct PushConstants {
+            // Each |PerFrame| is has a 256 array stride
+            PerFrame* bufPerFrame;
+        };
+
+        [[vk::push_constant]] PushConstants pc;
+
+        struct VSOutput {
+            float4 position : SV_Position;
+        };
+
+        [shader("vertex")]
+            VSOutput main() {
+            PerFrame* perFrame = pc.bufPerFrame;
+
+            VSOutput out;
+            // Range is from 0 to 1024
+            out.position = (
+                perFrame[0].proj[0].a *
+                perFrame[1].proj[1].b *
+                perFrame[2].proj[2].c *
+                perFrame[3].proj[3].d
+            )
+                * float4(50.0);
+
+            return out;
+        }
+    )";
+
+    VkShaderObj vs(*m_device, vert_source, VK_SHADER_STAGE_VERTEX_BIT, SPV_ENV_VULKAN_1_2, SPV_SOURCE_SLANG);
+
+    VkPushConstantRange pc_range = {VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT, 0, 64};
+    const vkt::PipelineLayout pipeline_layout(*m_device, {}, {pc_range});
+
+    CreatePipelineHelper pipe(*this);
+    pipe.gp_ci_.layout = pipeline_layout;
+    pipe.shader_stages_ = {vs.GetStageCreateInfo(), pipe.fs_->GetStageCreateInfo()};
+    pipe.CreateGraphicsPipeline();
+}
+
 TEST_F(PositiveGpuAVBufferDeviceAddress, MultipleAccessChainsDescriptorBuffer) {
     TEST_DESCRIPTION("Slang will produce a chain of OpAccessChains");
 
