layers: GPL with VkPipelineRenderingCreateInfo madness (#11593)

spencer-lunarg · web-flow · commit e62727596442 · 2026-01-31T08:52:55.000-05:00
diff --git a/layers/core_checks/cc_pipeline_graphics.cpp b/layers/core_checks/cc_pipeline_graphics.cpp
@@ -3523,6 +3523,7 @@ bool CoreChecks::ValidateDrawPipelineRenderpass(const LastBound &last_bound_stat
     bool skip = false;
     const vvl::CommandBuffer &cb_state = last_bound_state.cb_state;
 
+    // Can use RenderPassState() here even GPL because we only need to check for compatible renderpasses
     const auto &pipeline_rp_state = pipeline.RenderPassState();
     // TODO: AMD extension codes are included here, but actual function entrypoints are not yet intercepted
     if (rp_state.VkHandle() != pipeline_rp_state->VkHandle()) {
@@ -3546,6 +3547,7 @@ bool CoreChecks::ValidateDrawPipelineDynamicRenderpass(const LastBound &last_bou
     bool skip = false;
     const vvl::CommandBuffer &cb_state = last_bound_state.cb_state;
 
+    // Can use RenderPassState() here even GPL because we only need to check for it being null
     const auto pipeline_rp_state = pipeline.RenderPassState();
     ASSERT_AND_RETURN_SKIP(pipeline_rp_state);
     if (pipeline_rp_state->VkHandle() != VK_NULL_HANDLE) {
@@ -3557,7 +3559,7 @@ bool CoreChecks::ValidateDrawPipelineDynamicRenderpass(const LastBound &last_bou
         return skip;
     }
 
-    const VkPipelineRenderingCreateInfo &pipeline_rendering_ci = *(pipeline_rp_state->dynamic_pipeline_rendering_create_info.ptr());
+    const VkPipelineRenderingCreateInfo& pipeline_rendering_ci = pipeline.GetRenderPassPipelineRenderingCreateInfo();
     const auto rendering_view_mask = rp_state.GetDynamicRenderingViewMask();
     // There is currently a 06031 VU that catches the viewMask at vkCmdExecuteCommands time, so seems like this is not suppose to be
     // validated with inherited render passes
diff --git a/layers/state_tracker/cmd_buffer_state.cpp b/layers/state_tracker/cmd_buffer_state.cpp
@@ -867,7 +867,7 @@ static void InitDefaultRenderingAttachments(CommandBuffer::RenderingAttachment &
 
 void CommandBuffer::RecordBeginRendering(const VkRenderingInfo &rendering_info, const Location &loc) {
     RecordCommand(loc);
-    active_render_pass = std::make_shared<vvl::RenderPass>(&rendering_info, true);
+    active_render_pass = std::make_shared<vvl::RenderPass>(rendering_info);
     render_area = rendering_info.renderArea;
     render_pass_queries.clear();
 
diff --git a/layers/state_tracker/pipeline_state.cpp b/layers/state_tracker/pipeline_state.cpp
@@ -839,6 +839,11 @@ std::vector<std::shared_ptr<const vvl::PipelineLayout>> Pipeline::PipelineLayout
     return {merged_graphics_layout};
 }
 
+// See DeviceState::PreCallValidateCreateGraphicsPipelines() why we need this awful function
+const VkPipelineRenderingCreateInfo& Pipeline::GetRenderPassPipelineRenderingCreateInfo() const {
+    return *(rp_state->dynamic_pipeline_rendering_create_info.ptr());
+}
+
 // Currently will return vvl::ShaderModule with no SPIR-V
 std::shared_ptr<const vvl::ShaderModule> Pipeline::GetGraphicsLibraryStateShader(VkShaderStageFlagBits state) const {
     switch (state) {
diff --git a/layers/state_tracker/pipeline_state.h b/layers/state_tracker/pipeline_state.h
@@ -243,19 +243,19 @@ class Pipeline : public StateObject, public SubStateManager<PipelineSubState> {
 
     // Used to know if the pipeline library is being created (as opposed to being linked)
     // Important as some pipeline checks need pipeline state that won't be there if the library is from linking
-    // Many VUs say "the pipeline require" which means "not being linked in as a library"
+    // Many VUs say "the pipeline requires" which means "not being linked in as a library"
     // If the VUs says "created with" then you should NOT use this function
     // TODO - This could probably just be a check to VkGraphicsPipelineLibraryCreateInfoEXT::flags
     bool OwnsLibState(const std::shared_ptr<PipelineLibraryState> lib_state) const {
         return lib_state && (&lib_state->parent == this);
     }
 
-    // This grabs the render pass at pipeline creation time, if you are inside a command buffer, use the vvl::RenderPass inside the
-    // command buffer! (The render pass can be different as they just have to be compatible, see
-    // vkspec.html#renderpass-compatibility)
+    // If you are inside a command buffer, use the vvl::RenderPass inside the command buffer!!
+    // - This grabs the render pass at pipeline creation time
+    // - The render pass can be different as they just have to be compatible, see vkspec.html#renderpass-compatibility
+    // - The issue is for something like VkPipelineRenderingCreateInfo we want executable version... so why this is ONLY suppose to
+    // be used when we don't have the command buffer scope
     const std::shared_ptr<const vvl::RenderPass> RenderPassState() const {
-        // TODO A render pass object is required for all of these library states. Which one should be used for an "executable
-        // pipeline"?
         if (fragment_output_state && fragment_output_state->rp_state) {
             return fragment_output_state->rp_state;
         } else if (fragment_shader_state && fragment_shader_state->rp_state) {
@@ -266,6 +266,8 @@ class Pipeline : public StateObject, public SubStateManager<PipelineSubState> {
         return rp_state;
     }
 
+    const VkPipelineRenderingCreateInfo& GetRenderPassPipelineRenderingCreateInfo() const;
+
     // A pipeline does not "require" state that is specified in a library.
     bool IsRenderPassStateRequired() const {
         return OwnsLibState(pre_raster_state) || OwnsLibState(fragment_shader_state) || OwnsLibState(fragment_output_state);
@@ -515,69 +517,31 @@ class Pipeline : public StateObject, public SubStateManager<PipelineSubState> {
         return EnablesRasterizationStates(create_info);
     }
 
-    template <typename CreateInfo>
-    static bool ContainsLibraryState(const vvl::DeviceState &device_state, const CreateInfo &create_info,
-                                     VkGraphicsPipelineLibraryFlagsEXT lib_flags) {
-        constexpr VkGraphicsPipelineLibraryFlagsEXT null_lib = static_cast<VkGraphicsPipelineLibraryFlagsEXT>(0);
-        VkGraphicsPipelineLibraryFlagsEXT current_state = null_lib;
-
-        // Check linked libraries
-        auto link_info = vku::FindStructInPNextChain<VkPipelineLibraryCreateInfoKHR>(create_info.pNext);
-        if (link_info) {
-            const auto libs = vvl::make_span(link_info->pLibraries, link_info->libraryCount);
-            for (const auto handle : libs) {
-                auto lib = device_state.Get<vvl::Pipeline>(handle);
-                current_state |= lib->graphics_lib_type;
-            }
-        }
-
-        // Check if this is a graphics library
-        auto lib_info = vku::FindStructInPNextChain<VkGraphicsPipelineLibraryCreateInfoEXT>(create_info.pNext);
-        if (lib_info) {
-            current_state |= lib_info->flags;
-        }
-
-        if (!link_info && !lib_info) {
-            // This is not a graphics pipeline library, and therefore contains all necessary state
-            return true;
-        }
-
-        return (current_state & lib_flags) != null_lib;
-    }
-
-    // Version used at dispatch time for stateless VOs
-    template <typename CreateInfo>
-    static bool ContainsLibraryState(const CreateInfo &create_info, VkGraphicsPipelineLibraryFlagsEXT lib_flags) {
-        constexpr VkGraphicsPipelineLibraryFlagsEXT null_lib = static_cast<VkGraphicsPipelineLibraryFlagsEXT>(0);
-        VkGraphicsPipelineLibraryFlagsEXT current_state = null_lib;
-
-        auto link_info = vku::FindStructInPNextChain<VkPipelineLibraryCreateInfoKHR>(create_info.pNext);
-        // Cannot check linked library state in stateless VO
-
-        // Check if this is a graphics library
-        auto lib_info = vku::FindStructInPNextChain<VkGraphicsPipelineLibraryCreateInfoEXT>(create_info.pNext);
-        if (lib_info) {
-            current_state |= lib_info->flags;
-        }
-
-        if (!link_info && !lib_info) {
-            // This is not a graphics pipeline library, and therefore (should) contains all necessary state
-            return true;
-        }
-
-        return (current_state & lib_flags) != null_lib;
-    }
-
     // This is a helper that is meant to be used during safe_VkPipelineRenderingCreateInfo construction to determine whether or not
     // certain fields should be ignored based on graphics pipeline state
     static bool PnextRenderingInfoCustomCopy(const DeviceState &device_state, const VkGraphicsPipelineCreateInfo &graphics_info,
                                              VkBaseOutStructure *safe_struct, const VkBaseOutStructure *in_struct) {
         // "safe_struct" is assumed to be non-null as it should be the "this" member of calling class instance
         assert(safe_struct);
         if (safe_struct->sType == VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO) {
-            const bool has_fo_state = Pipeline::ContainsLibraryState(
-                device_state, graphics_info, VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_OUTPUT_INTERFACE_BIT_EXT);
-            if (!has_fo_state) {
+            // If using normal, non-GPL pipline, this is simply true
+            bool has_fragment_output_state = true;
+
+            {
+                // Same as OwnsLibState() but when there is no vvl::Pipeline state
+                auto lib_info = vku::FindStructInPNextChain<VkGraphicsPipelineLibraryCreateInfoEXT>(graphics_info.pNext);
+                if (lib_info) {
+                    has_fragment_output_state =
+                        (lib_info->flags & VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_OUTPUT_INTERFACE_BIT_EXT) != 0;
+                } else if (auto link_info = vku::FindStructInPNextChain<VkPipelineLibraryCreateInfoKHR>(graphics_info.pNext)) {
+                    if (link_info->libraryCount != 0) {
+                        // We are linking in, so we now know this pipeline doesn't "own" FragmentOuptut
+                        has_fragment_output_state = false;
+                    }
+                }
+            }
+
+            if (!has_fragment_output_state) {
                 // Clear out all pointers except for viewMask. Since viewMask is a scalar, it has already been copied at this point
                 // in vku::safe_VkPipelineRenderingCreateInfo construction.
                 auto pri = reinterpret_cast<vku::safe_VkPipelineRenderingCreateInfo *>(safe_struct);
diff --git a/layers/state_tracker/render_pass_state.cpp b/layers/state_tracker/render_pass_state.cpp
@@ -1,7 +1,7 @@
-/* Copyright (c) 2015-2025 The Khronos Group Inc.
- * Copyright (c) 2015-2025 Valve Corporation
- * Copyright (c) 2015-2025 LunarG, Inc.
- * Copyright (C) 2015-2025 Google Inc.
+/* Copyright (c) 2015-2026 The Khronos Group Inc.
+ * Copyright (c) 2015-2026 Valve Corporation
+ * Copyright (c) 2015-2026 LunarG, Inc.
+ * Copyright (C) 2015-2026 Google Inc.
  * Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights reserved.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
@@ -255,10 +255,6 @@ static bool IsRenderPassMultiViewEnabled(const VkRenderPassCreateInfo2 &renderpa
     return is_multiview_enabled;
 }
 
-static bool IsDynamicRenderingMultiviewEnabled(const VkRenderingInfo *rendering_info) {
-    return rendering_info && rendering_info->viewMask != 0u;
-}
-
 static void InitRenderPassState(vvl::RenderPass &render_pass) {
     auto create_info = render_pass.create_info.ptr();
 
@@ -280,12 +276,11 @@ static void InitRenderPassState(vvl::RenderPass &render_pass) {
 namespace vvl {
 
 // vkCreateRenderPass2
-RenderPass::RenderPass(VkRenderPass handle, VkRenderPassCreateInfo2 const *pCreateInfo)
+RenderPass::RenderPass(VkRenderPass handle, VkRenderPassCreateInfo2 const* pCreateInfo)
     : StateObject(handle, kVulkanObjectTypeRenderPass),
       create_info(pCreateInfo),
       use_dynamic_rendering(false),
       use_dynamic_rendering_inherited(false),
-      rasterization_enabled(true),
       dynamic_rendering_color_attachment_count(0),
       has_multiview_enabled(IsRenderPassMultiViewEnabled(*create_info.ptr())) {
     InitRenderPassState(*this);
@@ -297,31 +292,25 @@ static vku::safe_VkRenderPassCreateInfo2 ConvertCreateInfo(const VkRenderPassCre
 }
 
 // vkCreateRenderPass
-RenderPass::RenderPass(VkRenderPass handle, VkRenderPassCreateInfo const *pCreateInfo)
+RenderPass::RenderPass(VkRenderPass handle, VkRenderPassCreateInfo const* pCreateInfo)
     : StateObject(handle, kVulkanObjectTypeRenderPass),
       create_info(ConvertCreateInfo(*pCreateInfo)),
       use_dynamic_rendering(false),
       use_dynamic_rendering_inherited(false),
-      rasterization_enabled(true),
       dynamic_rendering_color_attachment_count(0),
       has_multiview_enabled(IsRenderPassMultiViewEnabled(*create_info.ptr())) {
     InitRenderPassState(*this);
 }
 
-const VkPipelineRenderingCreateInfo VkPipelineRenderingCreateInfo_default = {
-    VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO, nullptr, 0, 0, nullptr, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED};
-
 // vkCreateGraphicsPipelines (dynamic rendering state tied to pipeline state)
-RenderPass::RenderPass(VkPipelineRenderingCreateInfo const *pPipelineRenderingCreateInfo, bool rasterization_enabled)
+// (created in DeviceState::PreCallValidateCreateGraphicsPipelines)
+RenderPass::RenderPass(const VkPipelineRenderingCreateInfo& rendering_ci)
     : StateObject(static_cast<VkRenderPass>(VK_NULL_HANDLE), kVulkanObjectTypeRenderPass),
       use_dynamic_rendering(true),
       use_dynamic_rendering_inherited(false),
-      rasterization_enabled(rasterization_enabled),
-      dynamic_pipeline_rendering_create_info((pPipelineRenderingCreateInfo && rasterization_enabled)
-                                                 ? pPipelineRenderingCreateInfo
-                                                 : &VkPipelineRenderingCreateInfo_default),
-      dynamic_rendering_color_attachment_count(dynamic_pipeline_rendering_create_info.colorAttachmentCount),
-      has_multiview_enabled(dynamic_pipeline_rendering_create_info.viewMask != 0) {}
+      dynamic_pipeline_rendering_create_info(&rendering_ci),
+      dynamic_rendering_color_attachment_count(rendering_ci.colorAttachmentCount),
+      has_multiview_enabled(rendering_ci.viewMask != 0) {}
 
 bool RenderPass::UsesColorAttachment(uint32_t subpass_num) const {
     bool result = false;
@@ -396,22 +385,19 @@ const VkMultisampledRenderToSingleSampledInfoEXT *RenderPass::GetMSRTSSInfo(uint
 }
 
 // vkCmdBeginRendering
-RenderPass::RenderPass(VkRenderingInfo const *pRenderingInfo, bool rasterization_enabled)
+RenderPass::RenderPass(const VkRenderingInfo& rendering_info)
     : StateObject(static_cast<VkRenderPass>(VK_NULL_HANDLE), kVulkanObjectTypeRenderPass),
       use_dynamic_rendering(true),
       use_dynamic_rendering_inherited(false),
-      rasterization_enabled(rasterization_enabled),
-      dynamic_rendering_begin_rendering_info((pRenderingInfo && rasterization_enabled) ? pRenderingInfo : nullptr),
+      dynamic_rendering_begin_rendering_info(&rendering_info),
       dynamic_rendering_color_attachment_count(dynamic_rendering_begin_rendering_info.colorAttachmentCount),
-      has_multiview_enabled(
-          IsDynamicRenderingMultiviewEnabled((pRenderingInfo && rasterization_enabled) ? pRenderingInfo : nullptr)) {}
+      has_multiview_enabled(rendering_info.viewMask != 0u) {}
 
 // vkBeginCommandBuffer (dynamic rendering in secondary command buffer)
-RenderPass::RenderPass(VkCommandBufferInheritanceRenderingInfo const *pInheritanceRenderingInfo)
+RenderPass::RenderPass(VkCommandBufferInheritanceRenderingInfo const* pInheritanceRenderingInfo)
     : StateObject(static_cast<VkRenderPass>(VK_NULL_HANDLE), kVulkanObjectTypeRenderPass),
       use_dynamic_rendering(false),
       use_dynamic_rendering_inherited(true),
-      rasterization_enabled(true),
       inheritance_rendering_info(pInheritanceRenderingInfo),
       dynamic_rendering_color_attachment_count(inheritance_rendering_info.colorAttachmentCount),
       has_multiview_enabled(false) {}
diff --git a/layers/state_tracker/render_pass_state.h b/layers/state_tracker/render_pass_state.h
@@ -1,7 +1,7 @@
-/* Copyright (c) 2015-2025 The Khronos Group Inc.
- * Copyright (c) 2015-2025 Valve Corporation
- * Copyright (c) 2015-2025 LunarG, Inc.
- * Copyright (C) 2015-2025 Google Inc.
+/* Copyright (c) 2015-2026 The Khronos Group Inc.
+ * Copyright (c) 2015-2026 Valve Corporation
+ * Copyright (c) 2015-2026 LunarG, Inc.
+ * Copyright (C) 2015-2026 Google Inc.
  * Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights reserved.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
@@ -79,9 +79,9 @@ class RenderPass : public StateObject {
 
     const bool use_dynamic_rendering;
     const bool use_dynamic_rendering_inherited;
-    const bool rasterization_enabled;
 
     const vku::safe_VkRenderingInfo dynamic_rendering_begin_rendering_info;
+    // Note, this is not the exact VkPipelineRenderingCreateInfo passed in, instead it will handle fields being ignored
     const vku::safe_VkPipelineRenderingCreateInfo dynamic_pipeline_rendering_create_info;
     // when a secondary command buffer is recorded with VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT
     const vku::safe_VkCommandBufferInheritanceRenderingInfo inheritance_rendering_info;
@@ -112,12 +112,12 @@ class RenderPass : public StateObject {
     RenderPass(VkRenderPass handle, VkRenderPassCreateInfo2 const *pCreateInfo);
 
     // vkCmdBeginRendering
-    RenderPass(VkRenderingInfo const *pRenderingInfo, bool rasterization_enabled);
+    explicit RenderPass(const VkRenderingInfo& rendering_info);
     // vkBeginCommandBuffer (dynamic rendering in secondary commadn buffer)
     explicit RenderPass(VkCommandBufferInheritanceRenderingInfo const *pInheritanceRenderingInfo);
 
     // vkCreateGraphicsPipelines (dynamic rendering state tied to pipeline state)
-    RenderPass(VkPipelineRenderingCreateInfo const *pPipelineRenderingCreateInfo, bool rasterization_enabled);
+    explicit RenderPass(const VkPipelineRenderingCreateInfo& rendering_ci);
 
     VkRenderPass VkHandle() const { return handle_.Cast<VkRenderPass>(); }
 
diff --git a/layers/state_tracker/state_tracker.cpp b/layers/state_tracker/state_tracker.cpp
diff --git a/tests/unit/graphics_library.cpp b/tests/unit/graphics_library.cpp
diff --git a/tests/unit/graphics_library_positive.cpp b/tests/unit/graphics_library_positive.cpp
