Add Validation for VK_KHR_create_renderpass2

build-android/cmake/layerlib/CMakeLists.txt

@@ -62,6 +62,7 @@ set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DVK_USE_PLATFORM_ANDROID_KHR \
                      -fvisibility=hidden")
 add_library(VkLayer_core_validation SHARED
         ${SRC_DIR}/layers/core_validation.cpp
+        ${SRC_DIR}/layers/convert_to_renderpass2.cpp
         ${SRC_DIR}/layers/descriptor_sets.cpp
         ${SRC_DIR}/layers/buffer_validation.cpp
         ${SRC_DIR}/layers/shader_validation.cpp

build-android/jni/Android.mk

@@ -39,6 +39,7 @@ LOCAL_SRC_FILES += $(SRC_DIR)/layers/core_validation.cpp
 LOCAL_SRC_FILES += $(SRC_DIR)/layers/descriptor_sets.cpp
 LOCAL_SRC_FILES += $(SRC_DIR)/layers/buffer_validation.cpp
 LOCAL_SRC_FILES += $(SRC_DIR)/layers/shader_validation.cpp
+LOCAL_SRC_FILES += $(SRC_DIR)/layers/convert_to_renderpass2.cpp
 LOCAL_SRC_FILES += $(SRC_DIR)/layers/xxhash.c
 LOCAL_C_INCLUDES += $(VULKAN_INCLUDE) \
                     $(LOCAL_PATH)/$(SRC_DIR)/layers \
@@ -115,6 +116,8 @@ LOCAL_SRC_FILES += $(SRC_DIR)/tests/layer_validation_tests.cpp \
                    $(SRC_DIR)/tests/vktestbinding.cpp \
                    $(SRC_DIR)/tests/vktestframeworkandroid.cpp \
                    $(SRC_DIR)/tests/vkrenderframework.cpp \
+                   $(SRC_DIR)/layers/convert_to_renderpass2.cpp \
+                   $(LAYER_DIR)/include/vk_safe_struct.cpp \
                    $(THIRD_PARTY)/Vulkan-Tools/common/vulkan_wrapper.cpp
 LOCAL_C_INCLUDES += $(VULKAN_INCLUDE) \
                     $(LOCAL_PATH)/$(LAYER_DIR)/include \
@@ -137,6 +140,8 @@ LOCAL_SRC_FILES += $(SRC_DIR)/tests/layer_validation_tests.cpp \
                    $(SRC_DIR)/tests/vktestbinding.cpp \
                    $(SRC_DIR)/tests/vktestframeworkandroid.cpp \
                    $(SRC_DIR)/tests/vkrenderframework.cpp \
+                   $(SRC_DIR)/layers/convert_to_renderpass2.cpp \
+                   $(LAYER_DIR)/include/vk_safe_struct.cpp \
                    $(THIRD_PARTY)/Vulkan-Tools/common/vulkan_wrapper.cpp
 LOCAL_C_INCLUDES += $(VULKAN_INCLUDE) \
                     $(LOCAL_PATH)/$(LAYER_DIR)/include \

layers/CMakeLists.txt

@@ -178,7 +178,7 @@ GenerateFromVkXml(dispatch_table_helper_generator.py vk_dispatch_table_helper.h)
 GenerateFromVkXml(object_tracker_generator.py object_tracker.cpp)
 
 if(BUILD_LAYERS)
-    AddVkLayer(core_validation core_validation.cpp descriptor_sets.cpp buffer_validation.cpp shader_validation.cpp xxhash.c)
+    AddVkLayer(core_validation core_validation.cpp convert_to_renderpass2.cpp descriptor_sets.cpp buffer_validation.cpp shader_validation.cpp xxhash.c)
     AddVkLayer(object_tracker object_tracker.cpp object_tracker_utils.cpp)
     AddVkLayer(threading threading.cpp thread_check.h)
     AddVkLayer(unique_objects unique_objects.cpp unique_objects_wrappers.h)

layers/buffer_validation.h

@@ -102,11 +102,12 @@ void SetImageViewLayout(layer_data *device_data, GLOBAL_CB_NODE *pCB, VkImageVie
 void SetImageViewLayout(layer_data *device_data, GLOBAL_CB_NODE *cb_node, IMAGE_VIEW_STATE *view_state,
                         const VkImageLayout &layout);
 
-bool VerifyFramebufferAndRenderPassLayouts(layer_data *dev_data, GLOBAL_CB_NODE *pCB, const VkRenderPassBeginInfo *pRenderPassBegin,
+bool VerifyFramebufferAndRenderPassLayouts(layer_data *dev_data, RenderPassCreateVersion rp_version, GLOBAL_CB_NODE *pCB,
+                                           const VkRenderPassBeginInfo *pRenderPassBegin,
                                            const FRAMEBUFFER_STATE *framebuffer_state);
 
 void TransitionAttachmentRefLayout(layer_data *dev_data, GLOBAL_CB_NODE *pCB, FRAMEBUFFER_STATE *pFramebuffer,
-                                   VkAttachmentReference ref);
+                                   const safe_VkAttachmentReference2KHR &ref);
 
 void TransitionSubpassLayouts(layer_data *, GLOBAL_CB_NODE *, const RENDER_PASS_STATE *, const int, FRAMEBUFFER_STATE *);
 
@@ -182,10 +183,12 @@ void UpdateCmdBufImageLayouts(layer_data *device_data, GLOBAL_CB_NODE *pCB);
 bool ValidateMaskBitsFromLayouts(core_validation::layer_data *device_data, VkCommandBuffer cmdBuffer,
                                  const VkAccessFlags &accessMask, const VkImageLayout &layout, const char *type);
 
-bool ValidateLayoutVsAttachmentDescription(const debug_report_data *report_data, const VkImageLayout first_layout,
-                                           const uint32_t attachment, const VkAttachmentDescription &attachment_description);
+bool ValidateLayoutVsAttachmentDescription(const debug_report_data *report_data, RenderPassCreateVersion rp_version,
+                                           const VkImageLayout first_layout, const uint32_t attachment,
+                                           const VkAttachmentDescription2KHR &attachment_description);
 
-bool ValidateLayouts(const core_validation::layer_data *dev_data, VkDevice device, const VkRenderPassCreateInfo *pCreateInfo);
+bool ValidateLayouts(const core_validation::layer_data *dev_data, RenderPassCreateVersion rp_version, VkDevice device,
+                     const VkRenderPassCreateInfo2KHR *pCreateInfo);
 
 bool ValidateMapImageLayouts(core_validation::layer_data *dev_data, VkDevice device, DEVICE_MEM_INFO const *mem_info,
                              VkDeviceSize offset, VkDeviceSize end_offset);
@@ -211,8 +214,8 @@ bool PreCallValidateCreateBufferView(const layer_data *dev_data, const VkBufferV
 
 void PostCallRecordCreateBufferView(layer_data *device_data, const VkBufferViewCreateInfo *pCreateInfo, VkBufferView *pView);
 
-bool ValidateImageAspectMask(layer_data *device_data, VkImage image, VkFormat format, VkImageAspectFlags aspect_mask,
-                             const char *func_name);
+bool ValidateImageAspectMask(const layer_data *device_data, VkImage image, VkFormat format, VkImageAspectFlags aspect_mask,
+                             const char *func_name, const char *vuid = "VUID-VkImageSubresource-aspectMask-parameter");
 
 bool ValidateCreateImageViewSubresourceRange(const layer_data *device_data, const IMAGE_STATE *image_state,
                                              bool is_imageview_2d_type, const VkImageSubresourceRange &subresourceRange);

layers/convert_to_renderpass2.cpp

@@ -0,0 +1,202 @@
+/* Copyright (c) 2015-2018 The Khronos Group Inc.
+ * Copyright (c) 2015-2018 Valve Corporation
+ * Copyright (c) 2015-2018 LunarG, Inc.
+ * Copyright (C) 2015-2018 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Author: Tobias Hector <@tobski>
+ */
+
+#include <string.h>
+
+#include "convert_to_renderpass2.h"
+#include "vk_typemap_helper.h"
+#include "vk_format_utils.h"
+
+static void ConvertVkAttachmentReferenceToV2KHR(const VkAttachmentReference* in_struct,
+                                                safe_VkAttachmentReference2KHR* out_struct) {
+    out_struct->sType = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2_KHR;
+    out_struct->pNext = nullptr;
+    out_struct->attachment = in_struct->attachment;
+    out_struct->layout = in_struct->layout;
+    out_struct->aspectMask =
+        VK_IMAGE_ASPECT_FLAG_BITS_MAX_ENUM;  // Uninitialized - must be filled in by top level struct for input attachments
+}
+
+static void ConvertVkSubpassDependencyToV2KHR(const VkSubpassDependency* in_struct, safe_VkSubpassDependency2KHR* out_struct) {
+    out_struct->sType = VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2_KHR;
+    out_struct->pNext = nullptr;
+    out_struct->srcSubpass = in_struct->srcSubpass;
+    out_struct->dstSubpass = in_struct->dstSubpass;
+    out_struct->srcStageMask = in_struct->srcStageMask;
+    out_struct->dstStageMask = in_struct->dstStageMask;
+    out_struct->srcAccessMask = in_struct->srcAccessMask;
+    out_struct->dstAccessMask = in_struct->dstAccessMask;
+    out_struct->dependencyFlags = in_struct->dependencyFlags;
+    out_struct->viewOffset = 0;
+}
+
+static void ConvertVkSubpassDescriptionToV2KHR(const VkSubpassDescription* in_struct, safe_VkSubpassDescription2KHR* out_struct) {
+    out_struct->sType = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2_KHR;
+    out_struct->pNext = nullptr;
+    out_struct->flags = in_struct->flags;
+    out_struct->pipelineBindPoint = in_struct->pipelineBindPoint;
+    out_struct->viewMask = 0;
+    out_struct->inputAttachmentCount = in_struct->inputAttachmentCount;
+    out_struct->pInputAttachments = nullptr;
+    out_struct->colorAttachmentCount = in_struct->colorAttachmentCount;
+    out_struct->pColorAttachments = nullptr;
+    out_struct->pResolveAttachments = nullptr;
+    out_struct->preserveAttachmentCount = in_struct->preserveAttachmentCount;
+    out_struct->pPreserveAttachments = nullptr;
+
+    if (out_struct->inputAttachmentCount && in_struct->pInputAttachments) {
+        out_struct->pInputAttachments = new safe_VkAttachmentReference2KHR[out_struct->inputAttachmentCount];
+        for (uint32_t i = 0; i < out_struct->inputAttachmentCount; ++i) {
+            ConvertVkAttachmentReferenceToV2KHR(&in_struct->pInputAttachments[i], &out_struct->pInputAttachments[i]);
+        }
+    }
+    if (out_struct->colorAttachmentCount && in_struct->pColorAttachments) {
+        out_struct->pColorAttachments = new safe_VkAttachmentReference2KHR[out_struct->colorAttachmentCount];
+        for (uint32_t i = 0; i < out_struct->colorAttachmentCount; ++i) {
+            ConvertVkAttachmentReferenceToV2KHR(&in_struct->pColorAttachments[i], &out_struct->pColorAttachments[i]);
+        }
+    }
+    if (out_struct->colorAttachmentCount && in_struct->pResolveAttachments) {
+        out_struct->pResolveAttachments = new safe_VkAttachmentReference2KHR[out_struct->colorAttachmentCount];
+        for (uint32_t i = 0; i < out_struct->colorAttachmentCount; ++i) {
+            ConvertVkAttachmentReferenceToV2KHR(&in_struct->pResolveAttachments[i], &out_struct->pResolveAttachments[i]);
+        }
+    }
+    if (in_struct->pDepthStencilAttachment) {
+        out_struct->pDepthStencilAttachment = new safe_VkAttachmentReference2KHR();
+        ConvertVkAttachmentReferenceToV2KHR(in_struct->pDepthStencilAttachment, out_struct->pDepthStencilAttachment);
+    } else {
+        out_struct->pDepthStencilAttachment = NULL;
+    }
+    if (in_struct->pPreserveAttachments) {
+        out_struct->pPreserveAttachments = new uint32_t[in_struct->preserveAttachmentCount];
+        memcpy((void*)out_struct->pPreserveAttachments, (void*)in_struct->pPreserveAttachments,
+               sizeof(uint32_t) * in_struct->preserveAttachmentCount);
+    }
+}
+
+static void ConvertVkAttachmentDescriptionToV2KHR(const VkAttachmentDescription* in_struct,
+                                                  safe_VkAttachmentDescription2KHR* out_struct) {
+    out_struct->sType = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2_KHR;
+    out_struct->pNext = nullptr;
+    out_struct->flags = in_struct->flags;
+    out_struct->format = in_struct->format;
+    out_struct->samples = in_struct->samples;
+    out_struct->loadOp = in_struct->loadOp;
+    out_struct->storeOp = in_struct->storeOp;
+    out_struct->stencilLoadOp = in_struct->stencilLoadOp;
+    out_struct->stencilStoreOp = in_struct->stencilStoreOp;
+    out_struct->initialLayout = in_struct->initialLayout;
+    out_struct->finalLayout = in_struct->finalLayout;
+}
+
+void ConvertVkRenderPassCreateInfoToV2KHR(const VkRenderPassCreateInfo* in_struct, safe_VkRenderPassCreateInfo2KHR* out_struct) {
+    out_struct->sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2_KHR;
+    out_struct->pNext = nullptr;
+    out_struct->flags = in_struct->flags;
+    out_struct->attachmentCount = in_struct->attachmentCount;
+    out_struct->pAttachments = nullptr;
+    out_struct->subpassCount = in_struct->subpassCount;
+    out_struct->pSubpasses = nullptr;
+    out_struct->dependencyCount = in_struct->dependencyCount;
+    out_struct->pDependencies = nullptr;
+    out_struct->correlatedViewMaskCount = 0;
+    out_struct->pCorrelatedViewMasks = nullptr;
+    if (out_struct->attachmentCount && in_struct->pAttachments) {
+        out_struct->pAttachments = new safe_VkAttachmentDescription2KHR[out_struct->attachmentCount];
+        for (uint32_t i = 0; i < out_struct->attachmentCount; ++i) {
+            ConvertVkAttachmentDescriptionToV2KHR(&in_struct->pAttachments[i], &out_struct->pAttachments[i]);
+        }
+    }
+    if (out_struct->subpassCount && in_struct->pSubpasses) {
+        out_struct->pSubpasses = new safe_VkSubpassDescription2KHR[out_struct->subpassCount];
+        for (uint32_t i = 0; i < out_struct->subpassCount; ++i) {
+            ConvertVkSubpassDescriptionToV2KHR(&in_struct->pSubpasses[i], &out_struct->pSubpasses[i]);
+        }
+    }
+    if (out_struct->dependencyCount && in_struct->pDependencies) {
+        out_struct->pDependencies = new safe_VkSubpassDependency2KHR[out_struct->dependencyCount];
+        for (uint32_t i = 0; i < out_struct->dependencyCount; ++i) {
+            ConvertVkSubpassDependencyToV2KHR(&in_struct->pDependencies[i], &out_struct->pDependencies[i]);
+        }
+    }
+
+    // Handle extension structs from KHR_multiview and KHR_maintenance2 to fill out the "filled in" bits.
+    if (in_struct->pNext) {
+        const VkRenderPassMultiviewCreateInfo* pMultiviewInfo =
+            lvl_find_in_chain<VkRenderPassMultiviewCreateInfo>(in_struct->pNext);
+        if (pMultiviewInfo) {
+            for (uint32_t subpass = 0; subpass < pMultiviewInfo->subpassCount; ++subpass) {
+                if (subpass < in_struct->subpassCount) {
+                    out_struct->pSubpasses[subpass].viewMask = pMultiviewInfo->pViewMasks[subpass];
+                }
+            }
+            for (uint32_t dependency = 0; dependency < pMultiviewInfo->dependencyCount; ++dependency) {
+                if (dependency < in_struct->dependencyCount) {
+                    out_struct->pDependencies[dependency].viewOffset = pMultiviewInfo->pViewOffsets[dependency];
+                }
+            }
+            if (pMultiviewInfo->correlationMaskCount) {
+                out_struct->correlatedViewMaskCount = pMultiviewInfo->correlationMaskCount;
+                uint32_t* pCorrelatedViewMasks = new uint32_t[out_struct->correlatedViewMaskCount];
+                for (uint32_t correlationMask = 0; correlationMask < pMultiviewInfo->correlationMaskCount; ++correlationMask) {
+                    pCorrelatedViewMasks[correlationMask] = pMultiviewInfo->pCorrelationMasks[correlationMask];
+                }
+                out_struct->pCorrelatedViewMasks = pCorrelatedViewMasks;
+            }
+        }
+        const VkRenderPassInputAttachmentAspectCreateInfo* pInputAttachmentAspectInfo =
+            lvl_find_in_chain<VkRenderPassInputAttachmentAspectCreateInfo>(in_struct->pNext);
+        if (pInputAttachmentAspectInfo) {
+            for (uint32_t i = 0; i < pInputAttachmentAspectInfo->aspectReferenceCount; ++i) {
+                uint32_t subpass = pInputAttachmentAspectInfo->pAspectReferences[i].subpass;
+                uint32_t attachment = pInputAttachmentAspectInfo->pAspectReferences[i].inputAttachmentIndex;
+                VkImageAspectFlags aspectMask = pInputAttachmentAspectInfo->pAspectReferences[i].aspectMask;
+                if (subpass < in_struct->subpassCount && attachment < in_struct->pSubpasses[subpass].inputAttachmentCount) {
+                    out_struct->pSubpasses[subpass].pInputAttachments[attachment].aspectMask = aspectMask;
+                }
+            }
+        }
+    }
+
+    if (out_struct->subpassCount && out_struct->pSubpasses) {
+        for (uint32_t i = 0; i < out_struct->subpassCount; ++i) {
+            if (out_struct->pSubpasses[i].inputAttachmentCount && out_struct->pSubpasses[i].pInputAttachments) {
+                for (uint32_t j = 0; j < out_struct->pSubpasses[i].inputAttachmentCount; ++j) {
+                    safe_VkAttachmentReference2KHR& attachment_ref = out_struct->pSubpasses[i].pInputAttachments[j];
+                    if (attachment_ref.aspectMask == VK_IMAGE_ASPECT_FLAG_BITS_MAX_ENUM &&
+                        attachment_ref.attachment < out_struct->attachmentCount && out_struct->pAttachments) {
+                        attachment_ref.aspectMask = 0;
+                        VkFormat attachmentFormat = out_struct->pAttachments[attachment_ref.attachment].format;
+                        if (FormatIsColor(attachmentFormat)) {
+                            attachment_ref.aspectMask |= VK_IMAGE_ASPECT_COLOR_BIT;
+                        }
+                        if (FormatHasDepth(attachmentFormat)) {
+                            attachment_ref.aspectMask |= VK_IMAGE_ASPECT_DEPTH_BIT;
+                        }
+                        if (FormatHasStencil(attachmentFormat)) {
+                            attachment_ref.aspectMask |= VK_IMAGE_ASPECT_STENCIL_BIT;
+                        }
+                    }
+                }
+            }
+        }
+    }
+}

layers/convert_to_renderpass2.h

@@ -0,0 +1,24 @@
+/* Copyright (c) 2015-2018 The Khronos Group Inc.
+ * Copyright (c) 2015-2018 Valve Corporation
+ * Copyright (c) 2015-2018 LunarG, Inc.
+ * Copyright (C) 2015-2018 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Author: Tobias Hector <@tobski>
+ */
+
+#pragma once
+#include "vk_safe_struct.h"
+
+void ConvertVkRenderPassCreateInfoToV2KHR(const VkRenderPassCreateInfo* in_struct, safe_VkRenderPassCreateInfo2KHR* out_struct);