gpuav: Check if vertex input before instrumenting

spencer-lunarg · spencer-lunarg · commit 2f46bb98ca3d · 2026-01-29T12:18:04.000-05:00
diff --git a/layers/gpuav/spirv/vertex_attribute_fetch_oob_pass.cpp b/layers/gpuav/spirv/vertex_attribute_fetch_oob_pass.cpp
@@ -1,6 +1,6 @@
-/* Copyright (c) 2025 The Khronos Group Inc.
- * Copyright (c) 2025 Valve Corporation
- * Copyright (c) 2025 LunarG, Inc.
+/* Copyright (c) 2025-2026 The Khronos Group Inc.
+ * Copyright (c) 2025-2026 Valve Corporation
+ * Copyright (c) 2025-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.
@@ -43,6 +43,30 @@ bool VertexAttributeFetchOobPass::Instrument() {
             continue;
         }
 
+        // Handle edge case where there is no vertex input actually
+        // the entry point must list all input variables
+        {
+            bool found_input = false;
+
+            uint32_t word = entry_point_inst->GetEntryPointInterfaceStart();
+            const uint32_t total_words = entry_point_inst->Length();
+            for (; word < total_words; word++) {
+                const uint32_t interface_id = entry_point_inst->Word(word);
+                const Variable* variable = type_manager_.FindVariableById(interface_id);
+                // guaranteed by spirv-val to be a OpVariable
+                assert(variable);
+                if (variable->StorageClass() == spv::StorageClassInput) {
+                    found_input = true;
+                    break;
+                }
+            }
+
+            if (!found_input) {
+                // vertex shader has no input, nothing to validate
+                return false;
+            }
+        }
+
         const uint32_t vertex_shader_entry_point_id = entry_point_inst->Word(2);
         for (const auto& function : module_.functions_) {
             if (function->instrumentation_added_) {
diff --git a/layers/state_tracker/shader_instruction.cpp b/layers/state_tracker/shader_instruction.cpp
@@ -13,6 +13,7 @@
  * limitations under the License.
  */
 
+#include <spirv/unified1/spirv.hpp>
 #include <sstream>
 #include "state_tracker/shader_instruction.h"
 #include "generated/spirv_grammar_helper.h"
@@ -262,6 +263,19 @@ spv::StorageClass Instruction::StorageClass() const {
     return storage_class;
 }
 
+// OpEntryPoint are annoying because the offset to the interface variable requires you to first detect how big the "Name" string is
+uint32_t Instruction::GetEntryPointInterfaceStart() const {
+    assert(Opcode() == spv::OpEntryPoint || Opcode() == spv::OpGraphEntryPointARM);
+    uint32_t word = 3;  // operand Name operand starts
+    // Find the end of the entrypoint's name string. additional zero bytes follow the actual null terminator, to fill out the rest
+    // of the word - so we only need to look at the last byte in the word to determine which word contains the terminator.
+    while (Word(word) & 0xff000000u) {
+        ++word;
+    }
+    ++word;
+    return word;
+}
+
 void Instruction::Fill(const std::vector<uint32_t>& words) {
     for (uint32_t word : words) {
         words_.emplace_back(word);
diff --git a/layers/state_tracker/shader_instruction.h b/layers/state_tracker/shader_instruction.h
@@ -92,6 +92,8 @@ class Instruction {
     bool operator==(Instruction const& other) const { return words_ == other.words_; }
     bool operator!=(Instruction const& other) const { return words_ != other.words_; }
 
+    uint32_t GetEntryPointInterfaceStart() const;
+
     // The following is only used for GPU-AV where we need to possibly update an Instruction
     Instruction(spirv_iterator it, uint32_t position_offset);
     // Assumes caller will fill remaining words
diff --git a/layers/state_tracker/shader_module.cpp b/layers/state_tracker/shader_module.cpp
@@ -683,14 +683,7 @@ std::vector<StageInterfaceVariable> EntryPoint::GetStageInterfaceVariables(const
     std::vector<StageInterfaceVariable> variables;
 
     // spirv-val validates that any Input/Output used in the entrypoint is listed in as interface IDs
-    uint32_t word = 3;  // operand Name operand starts
-    // Find the end of the entrypoint's name string. additional zero bytes follow the actual null terminator, to fill out
-    // the rest of the word - so we only need to look at the last byte in the word to determine which word contains the
-    // terminator.
-    while (entrypoint.entrypoint_insn.Word(word) & 0xff000000u) {
-        ++word;
-    }
-    ++word;
+    uint32_t word = entrypoint.entrypoint_insn.GetEntryPointInterfaceStart();
 
     vvl::unordered_set<uint32_t> unique_interface_id;
     for (; word < entrypoint.entrypoint_insn.Length(); word++) {
@@ -700,7 +693,7 @@ std::vector<StageInterfaceVariable> EntryPoint::GetStageInterfaceVariables(const
         };
         // guaranteed by spirv-val to be a OpVariable
         const Instruction& insn = *module_state.FindDef(interface_id);
-        const spv::StorageClass storage_class = (spv::StorageClass)insn.Word(3);
+        const spv::StorageClass storage_class = insn.StorageClass();
 
         if (storage_class == spv::StorageClassInput || storage_class == spv::StorageClassOutput) {
             variables.emplace_back(module_state, insn, entrypoint.stage, parsed);
diff --git a/tests/unit/gpu_av_vertex_attribute_fetch_positive.cpp b/tests/unit/gpu_av_vertex_attribute_fetch_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.
@@ -15,6 +15,7 @@
 #include "../framework/layer_validation_tests.h"
 #include "../framework/pipeline_helper.h"
 #include "../framework/buffer_helper.h"
+#include "../framework/shader_helper.h"
 
 class PositiveGpuAVVertexAttributeFetch : public GpuAVTest {};
 
@@ -70,3 +71,152 @@ TEST_F(PositiveGpuAVVertexAttributeFetch, IndirectDrawZeroStride) {
     m_default_queue->SubmitAndWait(m_command_buffer);
     m_errorMonitor->VerifyFound();
 }
+
+TEST_F(PositiveGpuAVVertexAttributeFetch, NoVertexInput) {
+    TEST_DESCRIPTION("https://github.com/KhronosGroup/Vulkan-ValidationLayers/issues/11475");
+    RETURN_IF_SKIP(InitGpuAvFramework());
+    RETURN_IF_SKIP(InitState());
+    InitRenderTarget();
+
+    const char* vs_source = R"glsl(
+        #version 450
+        layout (location = 0) out vec3 outEyespacePosition;
+        layout (location = 1) out vec2 outTexcoords;
+
+        void main() {
+            outEyespacePosition = vec3(0);
+            outTexcoords = vec2(0);
+        }
+    )glsl";
+    VkShaderObj vs(*m_device, vs_source, VK_SHADER_STAGE_VERTEX_BIT);
+
+    const char* fs_source = R"glsl(
+        #version 450
+        layout (location = 0) in vec3 inEyeSpacePosition;
+        layout (location = 0) out vec4 outColour;
+
+        void main() {
+            outColour = vec4(0);
+        }
+    )glsl";
+    VkShaderObj fs(*m_device, fs_source, VK_SHADER_STAGE_FRAGMENT_BIT);
+
+    CreatePipelineHelper pipe(*this);
+    VkVertexInputBindingDescription input_binding = {0, 0, VK_VERTEX_INPUT_RATE_VERTEX};
+    VkVertexInputAttributeDescription input_attrib = {1, 0, VK_FORMAT_A2B10G10R10_UNORM_PACK32, 0};
+    pipe.vi_ci_.pVertexBindingDescriptions = &input_binding;
+    pipe.vi_ci_.vertexBindingDescriptionCount = 1;
+    pipe.vi_ci_.pVertexAttributeDescriptions = &input_attrib;
+    pipe.vi_ci_.vertexAttributeDescriptionCount = 1;
+    pipe.shader_stages_ = {vs.GetStageCreateInfo(), fs.GetStageCreateInfo()};
+    pipe.CreateGraphicsPipeline();
+
+    VkCommandBufferBeginInfo begin_info = vku::InitStructHelper();
+    m_command_buffer.Begin(&begin_info);
+    m_command_buffer.BeginRenderPass(m_renderPassBeginInfo);
+    vk::CmdBindPipeline(m_command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipe);
+
+    vkt::Buffer index_buffer = vkt::IndexBuffer<uint32_t>(*m_device, {0, 666, 42});
+    vkt::Buffer vertex_buffer = vkt::VertexBuffer<float>(*m_device, {1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f});
+    VkDeviceSize vertex_buffer_offset = 0;
+    vk::CmdBindIndexBuffer(m_command_buffer, index_buffer, 0, VK_INDEX_TYPE_UINT32);
+    vk::CmdBindVertexBuffers(m_command_buffer, 0, 1, &vertex_buffer.handle(), &vertex_buffer_offset);
+
+    vk::CmdDrawIndexed(m_command_buffer, 3, 1, 0, 0, 0);
+
+    m_command_buffer.EndRenderPass();
+    m_command_buffer.End();
+
+    m_default_queue->SubmitAndWait(m_command_buffer);
+    m_errorMonitor->VerifyFound();
+}
+
+TEST_F(PositiveGpuAVVertexAttributeFetch, NoVertexInputWithBuiltin) {
+    TEST_DESCRIPTION("https://github.com/KhronosGroup/Vulkan-ValidationLayers/issues/11475");
+    SetTargetApiVersion(VK_API_VERSION_1_2);
+    AddRequiredFeature(vkt::Feature::shaderDrawParameters);
+    RETURN_IF_SKIP(InitGpuAvFramework());
+    RETURN_IF_SKIP(InitState());
+    InitRenderTarget();
+
+    // Declares the variable for builtin [VertexIndex, InstanceIndex, BaseVertex] but never accesses them
+    const char* vs_source = R"(
+               OpCapability DrawParameters
+               OpCapability Shader
+               OpMemoryModel Logical GLSL450
+               OpEntryPoint Vertex %main "main" %entryPointParam_main_outEyespacePosition %entryPointParam_main_outTexcoords
+               OpDecorate %entryPointParam_main_outEyespacePosition Location 0
+               OpDecorate %entryPointParam_main_outTexcoords Location 1
+               OpDecorate %gl_Position BuiltIn Position
+               OpDecorate %gl_VertexIndex BuiltIn VertexIndex
+               OpDecorate %gl_InstanceIndex BuiltIn InstanceIndex
+               OpDecorate %15 BuiltIn BaseVertex
+      %float = OpTypeFloat 32
+    %v3float = OpTypeVector %float 3
+%_ptr_Output_v3float = OpTypePointer Output %v3float
+    %v2float = OpTypeVector %float 2
+%_ptr_Output_v2float = OpTypePointer Output %v2float
+    %v4float = OpTypeVector %float 4
+%_ptr_Output_v4float = OpTypePointer Output %v4float
+        %int = OpTypeInt 32 1
+%_ptr_Input_int = OpTypePointer Input %int
+       %void = OpTypeVoid
+         %18 = OpTypeFunction %void
+    %float_0 = OpConstant %float 0
+         %20 = OpConstantComposite %v3float %float_0 %float_0 %float_0
+         %23 = OpConstantComposite %v2float %float_0 %float_0
+%entryPointParam_main_outEyespacePosition = OpVariable %_ptr_Output_v3float Output
+%entryPointParam_main_outTexcoords = OpVariable %_ptr_Output_v2float Output
+%gl_Position = OpVariable %_ptr_Output_v4float Output
+%gl_VertexIndex = OpVariable %_ptr_Input_int Input
+%gl_InstanceIndex = OpVariable %_ptr_Input_int Input
+         %15 = OpVariable %_ptr_Input_int Input
+       %main = OpFunction %void None %18
+         %19 = OpLabel
+               OpStore %entryPointParam_main_outEyespacePosition %20
+               OpStore %entryPointParam_main_outTexcoords %23
+               OpReturn
+               OpFunctionEnd
+    )";
+    VkShaderObj vs(*m_device, vs_source, VK_SHADER_STAGE_VERTEX_BIT, SPV_ENV_VULKAN_1_2, SPV_SOURCE_ASM);
+
+    const char* fs_source = R"glsl(
+        #version 450
+        layout (location = 0) in vec3 inEyeSpacePosition;
+        layout (location = 0) out vec4 outColour;
+
+        void main() {
+            outColour = vec4(0);
+        }
+    )glsl";
+    VkShaderObj fs(*m_device, fs_source, VK_SHADER_STAGE_FRAGMENT_BIT, SPV_ENV_VULKAN_1_2);
+
+    CreatePipelineHelper pipe(*this);
+    VkVertexInputBindingDescription input_binding = {0, 0, VK_VERTEX_INPUT_RATE_VERTEX};
+    VkVertexInputAttributeDescription input_attrib = {1, 0, VK_FORMAT_A2B10G10R10_UNORM_PACK32, 0};
+    pipe.vi_ci_.pVertexBindingDescriptions = &input_binding;
+    pipe.vi_ci_.vertexBindingDescriptionCount = 1;
+    pipe.vi_ci_.pVertexAttributeDescriptions = &input_attrib;
+    pipe.vi_ci_.vertexAttributeDescriptionCount = 1;
+    pipe.shader_stages_ = {vs.GetStageCreateInfo(), fs.GetStageCreateInfo()};
+    pipe.CreateGraphicsPipeline();
+
+    VkCommandBufferBeginInfo begin_info = vku::InitStructHelper();
+    m_command_buffer.Begin(&begin_info);
+    m_command_buffer.BeginRenderPass(m_renderPassBeginInfo);
+    vk::CmdBindPipeline(m_command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipe);
+
+    vkt::Buffer index_buffer = vkt::IndexBuffer<uint32_t>(*m_device, {0, 666, 42});
+    vkt::Buffer vertex_buffer = vkt::VertexBuffer<float>(*m_device, {1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f});
+    VkDeviceSize vertex_buffer_offset = 0;
+    vk::CmdBindIndexBuffer(m_command_buffer, index_buffer, 0, VK_INDEX_TYPE_UINT32);
+    vk::CmdBindVertexBuffers(m_command_buffer, 0, 1, &vertex_buffer.handle(), &vertex_buffer_offset);
+
+    vk::CmdDrawIndexed(m_command_buffer, 3, 1, 0, 0, 0);
+
+    m_command_buffer.EndRenderPass();
+    m_command_buffer.End();
+
+    m_default_queue->SubmitAndWait(m_command_buffer);
+    m_errorMonitor->VerifyFound();
+}
