layers: Add VK_KHR_maintenance11

Author: spencer-lunarg

layers/core_checks/cc_copy_blit_resolve.cpp

@@ -766,14 +766,16 @@ bool CoreChecks::ValidateBufferImageCopyData(const vvl::CommandBuffer& cb_state,
         }
     }
 
-    if (!IsIntegerMultipleOf(region.bufferOffset, 4)) {
+    if (!enabled_features.maintenance11 && !IsIntegerMultipleOf(region.bufferOffset, 4)) {
         const VkQueueFlags required_flags = VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT;
         if (!HasRequiredQueueFlags(cb_state, *physical_device_state, required_flags)) {
             const char* vuid = GetCopyBufferImageDeviceVUID(region_loc, vvl::CopyError::BufferOffset_07737).c_str();
             const LogObjectList objlist(cb_state.Handle(), cb_state.command_pool->Handle());
-            skip |=
-                LogError(vuid, objlist, region_loc.dot(Field::bufferOffset), "(%" PRIu64 ") is not a multiple of 4, but is %s",
-                         region.bufferOffset, DescribeRequiredQueueFlag(cb_state, *physical_device_state, required_flags).c_str());
+            skip |= LogError(
+                vuid, objlist, region_loc.dot(Field::bufferOffset),
+                "(%" PRIu64
+                ") is not a multiple of 4, but is %s\nHint: This can be allowed in some cases if maintenance11 feature is enabled.",
+                region.bufferOffset, DescribeRequiredQueueFlag(cb_state, *physical_device_state, required_flags).c_str());
         }
     }
 

layers/core_checks/cc_image.cpp

@@ -2008,10 +2008,19 @@ bool CoreChecks::ValidateImageViewCreateInfo(const VkImageViewCreateInfo& create
     }
 
     const bool multiplane_image = vkuFormatIsMultiplane(image_format);
-    if (multiplane_image && IsMultiplePlaneAspect(aspect_mask)) {
-        skip |= LogError("VUID-VkImageViewCreateInfo-subresourceRange-07818", create_info.image,
-                         create_info_loc.dot(Field::subresourceRange).dot(Field::aspectMask), "(%s) is invalid for %s.",
-                         string_VkImageAspectFlags(aspect_mask).c_str(), string_VkFormat(image_format));
+    if (multiplane_image) {
+        if (IsMultiplePlaneAspect(aspect_mask)) {
+            skip |= LogError("VUID-VkImageViewCreateInfo-subresourceRange-07818", create_info.image,
+                             create_info_loc.dot(Field::subresourceRange).dot(Field::aspectMask), "(%s) is invalid for %s.",
+                             string_VkImageAspectFlags(aspect_mask).c_str(), string_VkFormat(image_format));
+        }
+
+        if (image_flags & VK_IMAGE_CREATE_ALIAS_SINGLE_LAYER_DESCRIPTOR_BIT_KHR) {
+            skip |= LogError("VUID-VkImageViewCreateInfo-image-13357", create_info.image, create_info_loc.dot(Field::format),
+                             "(%s) is a multiplane format, but the image was created with flag "
+                             "VK_IMAGE_CREATE_ALIAS_SINGLE_LAYER_DESCRIPTOR_BIT_KHR. (image flags: %s).",
+                             string_VkFormat(view_format), string_VkImageCreateFlags(image_flags).c_str());
+        }
     }
 
     if ((image_flags & VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT) && (image_format != view_format)) {

layers/core_checks/cc_shader_object.cpp

@@ -16,6 +16,7 @@
 
 #include <vulkan/vulkan_core.h>
 #include <spirv/unified1/spirv.hpp>
+#include <sstream>
 #include "chassis/chassis_modification_state.h"
 #include "core_validation.h"
 #include "error_message/logging.h"
@@ -687,6 +688,133 @@ bool CoreChecks::ValidateDrawShaderObjectBoundShader(const LastBound& last_bound
     return skip;
 }
 
+bool CoreChecks::ValidateDrawShaderObjectFlags(const LastBound& last_bound_state, const Location& loc) const {
+    bool skip = false;
+
+    const vvl::ShaderObject* shader_with_independent_sets{};
+    const vvl::ShaderObject* shader_without_independent_sets{};
+    for (const vvl::ShaderObject* shader : last_bound_state.shader_object_states) {
+        if (!shader || !shader->stage.HasSpirv()) {
+            continue;
+        }
+
+        if (shader->safe_create_info.flags & VK_SHADER_CREATE_INDEPENDENT_SETS_BIT_KHR) {
+            shader_with_independent_sets = shader;
+        } else {
+            shader_without_independent_sets = shader;
+        }
+
+        constexpr VkShaderCreateFlagsEXT independent_and_no_task =
+            VK_SHADER_CREATE_INDEPENDENT_SETS_BIT_KHR | VK_SHADER_CREATE_NO_TASK_SHADER_BIT_EXT;
+        if ((shader->safe_create_info.flags & independent_and_no_task) == independent_and_no_task) {
+            if (!(last_bound_state.desc_set_pipeline_layout->create_flags & VK_PIPELINE_LAYOUT_CREATE_NO_TASK_SHADER_BIT_KHR)) {
+                const LogObjectList objlist(last_bound_state.cb_state.Handle(),
+                                            last_bound_state.desc_set_pipeline_layout->VkHandle(),
+                                            shader_with_independent_sets->VkHandle());
+                skip |=
+                    LogError(CreateActionVuid(loc.function, vvl::ActionVUID::INDEPENDENT_SETS_13364), objlist, loc,
+                             "Shader object bound at stage %s has both VK_SHADER_CREATE_INDEPENDENT_SETS_BIT_KHR and "
+                             "VK_SHADER_CREATE_NO_TASK_SHADER_BIT_EXT but the VkPipelineLayout (bound with %s) was created without "
+                             "VK_PIPELINE_LAYOUT_CREATE_NO_TASK_SHADER_BIT_KHR.\nVkShaderEXT create flags: %s\nVkPipelineLayout "
+                             "create flags: %s",
+                             string_VkShaderStageFlagBits(shader->safe_create_info.stage),
+                             vvl::String(last_bound_state.GetDescriptorModeFunc()),
+                             string_VkShaderCreateFlagsEXT(shader->safe_create_info.flags).c_str(),
+                             string_VkPipelineLayoutCreateFlags(last_bound_state.desc_set_pipeline_layout->create_flags).c_str());
+            }
+
+            if (last_bound_state.IsValidShaderObjectBound(ShaderObjectStage::TASK)) {
+                const LogObjectList objlist(last_bound_state.cb_state.Handle());
+                skip |= LogError(CreateActionVuid(loc.function, vvl::ActionVUID::INDEPENDENT_SETS_13365), objlist, loc,
+                                 "A shader object bound with VK_SHADER_CREATE_NO_TASK_SHADER_BIT_EXT is bound, but a task "
+                                 "stage shader object is also bound.");
+            }
+        }
+    }
+
+    if (shader_with_independent_sets && shader_without_independent_sets) {
+        const LogObjectList objlist(last_bound_state.cb_state.Handle(), shader_with_independent_sets->VkHandle(),
+                                    shader_without_independent_sets->VkHandle());
+        skip |= LogError(CreateActionVuid(loc.function, vvl::ActionVUID::INDEPENDENT_SETS_13361), objlist, loc,
+                         "Shader object bound at stage %s has flag VK_SHADER_CREATE_INDEPENDENT_SETS_BIT_KHR but shader object "
+                         "bound at stage %s does not.",
+                         string_VkShaderStageFlagBits(shader_with_independent_sets->safe_create_info.stage),
+                         string_VkShaderStageFlagBits(shader_without_independent_sets->safe_create_info.stage));
+    }
+
+    if (shader_with_independent_sets && last_bound_state.desc_set_pipeline_layout) {
+        if (!(last_bound_state.desc_set_pipeline_layout->create_flags & VK_PIPELINE_LAYOUT_CREATE_INDEPENDENT_SETS_BIT_EXT)) {
+            const LogObjectList objlist(last_bound_state.cb_state.Handle(), last_bound_state.desc_set_pipeline_layout->VkHandle(),
+                                        shader_with_independent_sets->VkHandle());
+            skip |= LogError(CreateActionVuid(loc.function, vvl::ActionVUID::INDEPENDENT_SETS_13362), objlist, loc,
+                             "Shader object bound at stage %s has flag VK_SHADER_CREATE_INDEPENDENT_SETS_BIT_KHR but the "
+                             "VkPipelineLayout (bound with %s) "
+                             "was created without the INDEPENDENT_SETS flag\nCreate flags: %s.",
+                             string_VkShaderStageFlagBits(shader_with_independent_sets->safe_create_info.stage),
+                             vvl::String(last_bound_state.GetDescriptorModeFunc()),
+                             string_VkPipelineLayoutCreateFlags(last_bound_state.desc_set_pipeline_layout->create_flags).c_str());
+        }
+
+        std::optional<std::pair<uint32_t, uint32_t>> binding_with_pre_rast_stage;
+        std::optional<std::pair<uint32_t, uint32_t>> binding_with_mesh_stage;
+        const auto& set_layouts_list = last_bound_state.desc_set_pipeline_layout->set_layouts.list;
+        for (auto [dsl_i, dsl] : vvl::enumerate(set_layouts_list)) {
+            if (!dsl) {
+                continue;
+            }
+            if (binding_with_pre_rast_stage.has_value() && binding_with_mesh_stage.has_value()) {
+                break;
+            }
+
+            // While there are few sets, the binding lists may be large
+            // The goal is to only search the binding list if we can detect possible mixing of mesh/non-mesh pre-raster stages
+            if ((dsl->HasTaskMesh() && !binding_with_mesh_stage.has_value()) ||
+                (dsl->HasNonMeshPreRaster() && !binding_with_pre_rast_stage.has_value())) {
+                for (uint32_t binding_idx = 0; binding_idx < dsl->GetBindingCount(); binding_idx++) {
+                    const VkDescriptorSetLayoutBinding* binding = dsl->GetDescriptorSetLayoutBindingPtrFromIndex(binding_idx);
+                    if (binding->stageFlags & (VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT |
+                                               VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT | VK_SHADER_STAGE_GEOMETRY_BIT)) {
+                        binding_with_pre_rast_stage = std::make_pair((uint32_t)dsl_i, binding->binding);
+                    }
+                    if (binding->stageFlags & (VK_SHADER_STAGE_TASK_BIT_EXT | VK_SHADER_STAGE_MESH_BIT_EXT)) {
+                        binding_with_mesh_stage = std::make_pair((uint32_t)dsl_i, binding->binding);
+                    }
+                }
+            }
+        }
+
+        if (binding_with_pre_rast_stage.has_value() && binding_with_mesh_stage.has_value()) {
+            const auto pre_raster_dsl = set_layouts_list[binding_with_pre_rast_stage->first];
+            const auto mesh_dsl = set_layouts_list[binding_with_mesh_stage->first];
+
+            std::ostringstream ss;
+            ss << "Shader object bound at stage "
+               << string_VkShaderStageFlagBits(shader_with_independent_sets->safe_create_info.stage)
+               << " has flag VK_SHADER_CREATE_INDEPENDENT_SETS_BIT_KHR but the VkPipelineLayout (bound with ";
+            ss << vvl::String(last_bound_state.GetDescriptorModeFunc())
+               << ") is mixing mesh and non-mesh pre-rasterization shader stages\n";
+            ss << FormatHandle(pre_raster_dsl->VkHandle()) << " at set " << binding_with_pre_rast_stage->first << ", binding "
+               << binding_with_pre_rast_stage->second << " has stageFlags "
+               << string_VkShaderStageFlags(
+                      pre_raster_dsl->GetDescriptorSetLayoutBindingPtrFromBinding(binding_with_pre_rast_stage->second)->stageFlags)
+               << '\n';
+            if (pre_raster_dsl != mesh_dsl) {
+                ss << FormatHandle(mesh_dsl->VkHandle()) << " at set " << binding_with_mesh_stage->first << ", binding "
+                   << binding_with_mesh_stage->second << " has stageFlags "
+                   << string_VkShaderStageFlags(
+                          mesh_dsl->GetDescriptorSetLayoutBindingPtrFromBinding(binding_with_mesh_stage->second)->stageFlags)
+                   << '\n';
+            }
+            const LogObjectList objlist(last_bound_state.cb_state.Handle(), last_bound_state.desc_set_pipeline_layout->VkHandle(),
+                                        pre_raster_dsl->VkHandle(), mesh_dsl->VkHandle(), shader_with_independent_sets->VkHandle());
+            skip |= LogError(CreateActionVuid(loc.function, vvl::ActionVUID::INDEPENDENT_SETS_13363), objlist, loc, "%s",
+                             ss.str().c_str());
+        }
+    }
+
+    return skip;
+}
+
 bool CoreChecks::ValidateDrawShaderObject(const LastBound& last_bound_state, const Location& loc) const {
     bool skip = false;
     const vvl::CommandBuffer& cb_state = last_bound_state.cb_state;
@@ -707,6 +835,7 @@ bool CoreChecks::ValidateDrawShaderObject(const LastBound& last_bound_state, con
 
     skip |= ValidateDrawShaderObjectNextStage(last_bound_state, loc);
     skip |= ValidateDrawShaderObjectBoundShader(last_bound_state, loc);
+    skip |= ValidateDrawShaderObjectFlags(last_bound_state, loc);
     skip |= ValidateDrawShaderObjectLinking(last_bound_state, loc);
     skip |= ValidateDrawShaderObjectPushConstantAndLayout(last_bound_state, loc);
     skip |= ValidateDrawShaderObjectMesh(last_bound_state, loc);

layers/core_checks/core_validation.h

@@ -741,6 +741,7 @@ class CoreChecks : public vvl::DeviceProxy {
                               const vvl::DrawDispatchVuid& vuid) const;
     bool ValidateDrawShaderObjectNextStage(const LastBound& last_bound_state, const Location& loc) const;
     bool ValidateDrawShaderObjectBoundShader(const LastBound& last_bound_state, const Location& loc) const;
+    bool ValidateDrawShaderObjectFlags(const LastBound& last_bound_state, const Location& loc) const;
     bool ValidateDrawShaderObject(const LastBound& last_bound_state, const Location& loc) const;
     bool ValidateDrawShaderObjectLinking(const LastBound& last_bound_state, const Location& loc) const;
     bool ValidateDrawShaderObjectPushConstantAndLayout(const LastBound& last_bound_state, const Location& loc) const;

layers/drawdispatch/drawdispatch_vuids.cpp

@@ -774,6 +774,16 @@ std::string CreateActionVuid(vvl::Func function, const ActionVUID id) {
 
         // ### VUID-vkCmdDraw-None-08601
         case ActionVUID::PUSH_CONSTANT_08601: suffix = "None-08601"; break;
+        // ### VUID-vkCmdDraw-flags-13361
+        case ActionVUID::INDEPENDENT_SETS_13361: suffix = "flags-13361"; break;
+        // ### VUID-vkCmdDraw-flags-13362
+        case ActionVUID::INDEPENDENT_SETS_13362: suffix = "flags-13362"; break;
+        // ### VUID-vkCmdDraw-flags-13363
+        case ActionVUID::INDEPENDENT_SETS_13363: suffix = "flags-13363"; break;
+        // ### VUID-vkCmdDraw-flags-13364
+        case ActionVUID::INDEPENDENT_SETS_13364: suffix = "flags-13364"; break;
+        // ### VUID-vkCmdDraw-flags-13365
+        case ActionVUID::INDEPENDENT_SETS_13365: suffix = "flags-13365"; break;
 
         // ### VUID-vkCmdDraw-None-08608
         case ActionVUID::DYNAMIC_STATE_ALL_SET_08608: suffix = "None-08608"; break;

layers/drawdispatch/drawdispatch_vuids.h

@@ -133,6 +133,11 @@ enum class ActionVUID {
     FILTER_CUBIC_02695,
     IMAGE_LAYOUT_00344,
     PUSH_CONSTANT_08601,
+    INDEPENDENT_SETS_13361,
+    INDEPENDENT_SETS_13362,
+    INDEPENDENT_SETS_13363,
+    INDEPENDENT_SETS_13364,
+    INDEPENDENT_SETS_13365,
 
     DYNAMIC_STATE_ALL_SET_08608,
     DYNAMIC_DEPTH_COMPARE_OP_07845,

layers/error_message/unimplementable_validation.h

@@ -334,7 +334,6 @@ const char* unimplementable_validation[] = {
     "VUID-VkAccelerationStructureTrianglesOpacityMicromapEXT-ppUsageCounts-parameter",
     "VUID-VkAccelerationStructureTrianglesDisplacementMicromapNV-pUsageCounts-parameter",
     "VUID-VkAccelerationStructureTrianglesDisplacementMicromapNV-ppUsageCounts-parameter",
-    "VUID-VkShaderCreateInfoEXT-pSetLayouts-parameter",
     "VUID-VkShaderCreateInfoEXT-pPushConstantRanges-parameter",
     "VUID-VkLatencySurfaceCapabilitiesNV-pPresentModes-parameter",
     "VUID-vkCmdBeginTransformFeedbackEXT-pCounterBufferOffsets-parameter",

layers/object_tracker/object_lifetime_validation.cpp

@@ -1952,4 +1952,32 @@ bool Device::PreCallValidateWriteResourceDescriptorsEXT(VkDevice device, uint32_
 
     return skip;
 }
+
+bool Device::PreCallValidateCreateShadersEXT(VkDevice device, uint32_t createInfoCount, const VkShaderCreateInfoEXT* pCreateInfos,
+                                             const VkAllocationCallbacks* pAllocator, VkShaderEXT* pShaders,
+                                             const ErrorObject& error_obj) const {
+    bool skip = false;
+    // Checked by chassis: device: "VUID-vkCreateShadersEXT-device-parameter"
+    if (pCreateInfos) {
+        for (uint32_t index0 = 0; index0 < createInfoCount; ++index0) {
+            [[maybe_unused]] const Location index0_loc = error_obj.location.dot(Field::pCreateInfos, index0);
+
+            const bool has_independent_set_flags = pCreateInfos[index0].flags & VK_SHADER_CREATE_INDEPENDENT_SETS_BIT_KHR;
+            // VK_KHR_maintenance11 added flag to allow null objects
+            bool null_allowed = has_independent_set_flags;
+            const char* vuid = null_allowed ? "VUID-VkShaderCreateInfoEXT-setLayoutCount-13360"
+                                            : "VUID-VkShaderCreateInfoEXT-setLayoutCount-13359";
+            if ((pCreateInfos[index0].setLayoutCount > 0) && (pCreateInfos[index0].pSetLayouts)) {
+                for (uint32_t index1 = 0; index1 < pCreateInfos[index0].setLayoutCount; ++index1) {
+                    skip |= ValidateObject(pCreateInfos[index0].pSetLayouts[index1], kVulkanObjectTypeDescriptorSetLayout,
+                                           null_allowed, vuid, "UNASSIGNED-VkShaderCreateInfoEXT-pSetLayouts-parent",
+                                           index0_loc.dot(Field::pSetLayouts, index1));
+                }
+            }
+        }
+    }
+
+    return skip;
+}
+
 }  // namespace object_lifetimes

layers/state_tracker/descriptor_sets.cpp

@@ -277,6 +277,8 @@ vvl::DescriptorSetLayoutDef::DescriptorSetLayoutDef(vvl::DeviceState& device_sta
                                                     const VkDescriptorSetLayoutCreateInfo* p_create_info)
     : flags_(p_create_info->flags),
       has_ycbcr_samplers_(false),
+      has_task_mask_(false),
+      has_non_mesh_pre_raster_(false),
       binding_count_(0),
       descriptor_count_(0),
       non_inline_descriptor_count_(0),
@@ -330,6 +332,15 @@ vvl::DescriptorSetLayoutDef::DescriptorSetLayoutDef(vvl::DeviceState& device_sta
                 binding_type_stats_.non_dynamic_buffer_count++;
             }
         }
+
+        if (binding_info.stageFlags & (VK_SHADER_STAGE_TASK_BIT_EXT | VK_SHADER_STAGE_MESH_BIT_EXT)) {
+            has_task_mask_ = true;
+        }
+        if (binding_info.stageFlags & (VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT |
+                                       VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT | VK_SHADER_STAGE_GEOMETRY_BIT)) {
+            has_non_mesh_pre_raster_ = true;
+        }
+
         // Get immutable samplers info
         if (binding_info.pImmutableSamplers != nullptr) {
             // Lazy allocation to avoid allocating array for layouts that don't use immutable samplers.